Upload folder using huggingface_hub (part 18)

.gitattributes

@@ -432,3 +432,26 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/error_functions.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_error_functions.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/polygon.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/sympy/holonomic/__pycache__/holonomic.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/sympy/integrals/__pycache__/laplace.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/sympy/integrals/__pycache__/manualintegrate.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/sympy/integrals/__pycache__/meijerint.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/sympy/integrals/tests/__pycache__/test_integrals.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/sympy/logic/__pycache__/boolalg.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/sympy/logic/tests/__pycache__/test_boolalg.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/sympy/matrices/__pycache__/common.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/sympy/matrices/__pycache__/matrixbase.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/sympy/matrices/tests/__pycache__/test_matrices.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/sympy/matrices/tests/__pycache__/test_matrixbase.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/sympy/parsing/autolev/__pycache__/_listener_autolev_antlr.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/sympy/parsing/autolev/_antlr/__pycache__/autolevparser.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/sympy/parsing/latex/_antlr/__pycache__/latexparser.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/sympy/parsing/tests/__pycache__/test_c_parser.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/sympy/physics/__pycache__/secondquant.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/sympy/physics/biomechanics/tests/__pycache__/test_curve.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/sympy/physics/continuum_mechanics/__pycache__/beam.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/sympy/physics/control/__pycache__/lti.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/sympy/physics/control/tests/__pycache__/test_lti.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/sympy/physics/mechanics/tests/__pycache__/test_joint.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/sympy/physics/quantum/__pycache__/spin.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/sympy/physics/quantum/tests/__pycache__/test_spin.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text

.venv/lib/python3.12/site-packages/sympy/geometry/util.py

@@ -0,0 +1,731 @@
+"""Utility functions for geometrical entities.
+
+Contains
+========
+intersection
+convex_hull
+closest_points
+farthest_points
+are_coplanar
+are_similar
+
+"""
+
+from collections import deque
+from math import sqrt as _sqrt
+
+from sympy import nsimplify
+from .entity import GeometryEntity
+from .exceptions import GeometryError
+from .point import Point, Point2D, Point3D
+from sympy.core.containers import OrderedSet
+from sympy.core.exprtools import factor_terms
+from sympy.core.function import Function, expand_mul
+from sympy.core.numbers import Float
+from sympy.core.sorting import ordered
+from sympy.core.symbol import Symbol
+from sympy.core.singleton import S
+from sympy.polys.polytools import cancel
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.utilities.iterables import is_sequence
+
+from mpmath.libmp.libmpf import prec_to_dps
+
+
+def find(x, equation):
+    """
+    Checks whether a Symbol matching ``x`` is present in ``equation``
+    or not. If present, the matching symbol is returned, else a
+    ValueError is raised. If ``x`` is a string the matching symbol
+    will have the same name; if ``x`` is a Symbol then it will be
+    returned if found.
+
+    Examples
+    ========
+
+    >>> from sympy.geometry.util import find
+    >>> from sympy import Dummy
+    >>> from sympy.abc import x
+    >>> find('x', x)
+    x
+    >>> find('x', Dummy('x'))
+    _x
+
+    The dummy symbol is returned since it has a matching name:
+
+    >>> _.name == 'x'
+    True
+    >>> find(x, Dummy('x'))
+    Traceback (most recent call last):
+    ...
+    ValueError: could not find x
+    """
+
+    free = equation.free_symbols
+    xs = [i for i in free if (i.name if isinstance(x, str) else i) == x]
+    if not xs:
+        raise ValueError('could not find %s' % x)
+    if len(xs) != 1:
+        raise ValueError('ambiguous %s' % x)
+    return xs[0]
+
+
+def _ordered_points(p):
+    """Return the tuple of points sorted numerically according to args"""
+    return tuple(sorted(p, key=lambda x: x.args))
+
+
+def are_coplanar(*e):
+    """ Returns True if the given entities are coplanar otherwise False
+
+    Parameters
+    ==========
+
+    e: entities to be checked for being coplanar
+
+    Returns
+    =======
+
+    Boolean
+
+    Examples
+    ========
+
+    >>> from sympy import Point3D, Line3D
+    >>> from sympy.geometry.util import are_coplanar
+    >>> a = Line3D(Point3D(5, 0, 0), Point3D(1, -1, 1))
+    >>> b = Line3D(Point3D(0, -2, 0), Point3D(3, 1, 1))
+    >>> c = Line3D(Point3D(0, -1, 0), Point3D(5, -1, 9))
+    >>> are_coplanar(a, b, c)
+    False
+
+    """
+    from .line import LinearEntity3D
+    from .plane import Plane
+    # XXX update tests for coverage
+
+    e = set(e)
+    # first work with a Plane if present
+    for i in list(e):
+        if isinstance(i, Plane):
+            e.remove(i)
+            return all(p.is_coplanar(i) for p in e)
+
+    if all(isinstance(i, Point3D) for i in e):
+        if len(e) < 3:
+            return False
+
+        # remove pts that are collinear with 2 pts
+        a, b = e.pop(), e.pop()
+        for i in list(e):
+            if Point3D.are_collinear(a, b, i):
+                e.remove(i)
+
+        if not e:
+            return False
+        else:
+            # define a plane
+            p = Plane(a, b, e.pop())
+            for i in e:
+                if i not in p:
+                    return False
+            return True
+    else:
+        pt3d = []
+        for i in e:
+            if isinstance(i, Point3D):
+                pt3d.append(i)
+            elif isinstance(i, LinearEntity3D):
+                pt3d.extend(i.args)
+            elif isinstance(i, GeometryEntity):  # XXX we should have a GeometryEntity3D class so we can tell the difference between 2D and 3D -- here we just want to deal with 2D objects; if new 3D objects are encountered that we didn't handle above, an error should be raised
+                # all 2D objects have some Point that defines them; so convert those points to 3D pts by making z=0
+                for p in i.args:
+                    if isinstance(p, Point):
+                        pt3d.append(Point3D(*(p.args + (0,))))
+        return are_coplanar(*pt3d)
+
+
+def are_similar(e1, e2):
+    """Are two geometrical entities similar.
+
+    Can one geometrical entity be uniformly scaled to the other?
+
+    Parameters
+    ==========
+
+    e1 : GeometryEntity
+    e2 : GeometryEntity
+
+    Returns
+    =======
+
+    are_similar : boolean
+
+    Raises
+    ======
+
+    GeometryError
+        When `e1` and `e2` cannot be compared.
+
+    Notes
+    =====
+
+    If the two objects are equal then they are similar.
+
+    See Also
+    ========
+
+    sympy.geometry.entity.GeometryEntity.is_similar
+
+    Examples
+    ========
+
+    >>> from sympy import Point, Circle, Triangle, are_similar
+    >>> c1, c2 = Circle(Point(0, 0), 4), Circle(Point(1, 4), 3)
+    >>> t1 = Triangle(Point(0, 0), Point(1, 0), Point(0, 1))
+    >>> t2 = Triangle(Point(0, 0), Point(2, 0), Point(0, 2))
+    >>> t3 = Triangle(Point(0, 0), Point(3, 0), Point(0, 1))
+    >>> are_similar(t1, t2)
+    True
+    >>> are_similar(t1, t3)
+    False
+
+    """
+    if e1 == e2:
+        return True
+    is_similar1 = getattr(e1, 'is_similar', None)
+    if is_similar1:
+        return is_similar1(e2)
+    is_similar2 = getattr(e2, 'is_similar', None)
+    if is_similar2:
+        return is_similar2(e1)
+    n1 = e1.__class__.__name__
+    n2 = e2.__class__.__name__
+    raise GeometryError(
+        "Cannot test similarity between %s and %s" % (n1, n2))
+
+
+def centroid(*args):
+    """Find the centroid (center of mass) of the collection containing only Points,
+    Segments or Polygons. The centroid is the weighted average of the individual centroid
+    where the weights are the lengths (of segments) or areas (of polygons).
+    Overlapping regions will add to the weight of that region.
+
+    If there are no objects (or a mixture of objects) then None is returned.
+
+    See Also
+    ========
+
+    sympy.geometry.point.Point, sympy.geometry.line.Segment,
+    sympy.geometry.polygon.Polygon
+
+    Examples
+    ========
+
+    >>> from sympy import Point, Segment, Polygon
+    >>> from sympy.geometry.util import centroid
+    >>> p = Polygon((0, 0), (10, 0), (10, 10))
+    >>> q = p.translate(0, 20)
+    >>> p.centroid, q.centroid
+    (Point2D(20/3, 10/3), Point2D(20/3, 70/3))
+    >>> centroid(p, q)
+    Point2D(20/3, 40/3)
+    >>> p, q = Segment((0, 0), (2, 0)), Segment((0, 0), (2, 2))
+    >>> centroid(p, q)
+    Point2D(1, 2 - sqrt(2))
+    >>> centroid(Point(0, 0), Point(2, 0))
+    Point2D(1, 0)
+
+    Stacking 3 polygons on top of each other effectively triples the
+    weight of that polygon:
+
+    >>> p = Polygon((0, 0), (1, 0), (1, 1), (0, 1))
+    >>> q = Polygon((1, 0), (3, 0), (3, 1), (1, 1))
+    >>> centroid(p, q)
+    Point2D(3/2, 1/2)
+    >>> centroid(p, p, p, q) # centroid x-coord shifts left
+    Point2D(11/10, 1/2)
+
+    Stacking the squares vertically above and below p has the same
+    effect:
+
+    >>> centroid(p, p.translate(0, 1), p.translate(0, -1), q)
+    Point2D(11/10, 1/2)
+
+    """
+    from .line import Segment
+    from .polygon import Polygon
+    if args:
+        if all(isinstance(g, Point) for g in args):
+            c = Point(0, 0)
+            for g in args:
+                c += g
+            den = len(args)
+        elif all(isinstance(g, Segment) for g in args):
+            c = Point(0, 0)
+            L = 0
+            for g in args:
+                l = g.length
+                c += g.midpoint*l
+                L += l
+            den = L
+        elif all(isinstance(g, Polygon) for g in args):
+            c = Point(0, 0)
+            A = 0
+            for g in args:
+                a = g.area
+                c += g.centroid*a
+                A += a
+            den = A
+        c /= den
+        return c.func(*[i.simplify() for i in c.args])
+
+
+def closest_points(*args):
+    """Return the subset of points from a set of points that were
+    the closest to each other in the 2D plane.
+
+    Parameters
+    ==========
+
+    args
+        A collection of Points on 2D plane.
+
+    Notes
+    =====
+
+    This can only be performed on a set of points whose coordinates can
+    be ordered on the number line. If there are no ties then a single
+    pair of Points will be in the set.
+
+    Examples
+    ========
+
+    >>> from sympy import closest_points, Triangle
+    >>> Triangle(sss=(3, 4, 5)).args
+    (Point2D(0, 0), Point2D(3, 0), Point2D(3, 4))
+    >>> closest_points(*_)
+    {(Point2D(0, 0), Point2D(3, 0))}
+
+    References
+    ==========
+
+    .. [1] https://www.cs.mcgill.ca/~cs251/ClosestPair/ClosestPairPS.html
+
+    .. [2] Sweep line algorithm
+        https://en.wikipedia.org/wiki/Sweep_line_algorithm
+
+    """
+    p = [Point2D(i) for i in set(args)]
+    if len(p) < 2:
+        raise ValueError('At least 2 distinct points must be given.')
+
+    try:
+        p.sort(key=lambda x: x.args)
+    except TypeError:
+        raise ValueError("The points could not be sorted.")
+
+    if not all(i.is_Rational for j in p for i in j.args):
+        def hypot(x, y):
+            arg = x*x + y*y
+            if arg.is_Rational:
+                return _sqrt(arg)
+            return sqrt(arg)
+    else:
+        from math import hypot
+
+    rv = [(0, 1)]
+    best_dist = hypot(p[1].x - p[0].x, p[1].y - p[0].y)
+    left = 0
+    box = deque([0, 1])
+    for i in range(2, len(p)):
+        while left < i and p[i][0] - p[left][0] > best_dist:
+            box.popleft()
+            left += 1
+
+        for j in box:
+            d = hypot(p[i].x - p[j].x, p[i].y - p[j].y)
+            if d < best_dist:
+                rv = [(j, i)]
+            elif d == best_dist:
+                rv.append((j, i))
+            else:
+                continue
+            best_dist = d
+        box.append(i)
+
+    return {tuple([p[i] for i in pair]) for pair in rv}
+
+
+def convex_hull(*args, polygon=True):
+    """The convex hull surrounding the Points contained in the list of entities.
+
+    Parameters
+    ==========
+
+    args : a collection of Points, Segments and/or Polygons
+
+    Optional parameters
+    ===================
+
+    polygon : Boolean. If True, returns a Polygon, if false a tuple, see below.
+              Default is True.
+
+    Returns
+    =======
+
+    convex_hull : Polygon if ``polygon`` is True else as a tuple `(U, L)` where
+                  ``L`` and ``U`` are the lower and upper hulls, respectively.
+
+    Notes
+    =====
+
+    This can only be performed on a set of points whose coordinates can
+    be ordered on the number line.
+
+    See Also
+    ========
+
+    sympy.geometry.point.Point, sympy.geometry.polygon.Polygon
+
+    Examples
+    ========
+
+    >>> from sympy import convex_hull
+    >>> points = [(1, 1), (1, 2), (3, 1), (-5, 2), (15, 4)]
+    >>> convex_hull(*points)
+    Polygon(Point2D(-5, 2), Point2D(1, 1), Point2D(3, 1), Point2D(15, 4))
+    >>> convex_hull(*points, **dict(polygon=False))
+    ([Point2D(-5, 2), Point2D(15, 4)],
+     [Point2D(-5, 2), Point2D(1, 1), Point2D(3, 1), Point2D(15, 4)])
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Graham_scan
+
+    .. [2] Andrew's Monotone Chain Algorithm
+      (A.M. Andrew,
+      "Another Efficient Algorithm for Convex Hulls in Two Dimensions", 1979)
+      https://web.archive.org/web/20210511015444/http://geomalgorithms.com/a10-_hull-1.html
+
+    """
+    from .line import Segment
+    from .polygon import Polygon
+    p = OrderedSet()
+    for e in args:
+        if not isinstance(e, GeometryEntity):
+            try:
+                e = Point(e)
+            except NotImplementedError:
+                raise ValueError('%s is not a GeometryEntity and cannot be made into Point' % str(e))
+        if isinstance(e, Point):
+            p.add(e)
+        elif isinstance(e, Segment):
+            p.update(e.points)
+        elif isinstance(e, Polygon):
+            p.update(e.vertices)
+        else:
+            raise NotImplementedError(
+                'Convex hull for %s not implemented.' % type(e))
+
+    # make sure all our points are of the same dimension
+    if any(len(x) != 2 for x in p):
+        raise ValueError('Can only compute the convex hull in two dimensions')
+
+    p = list(p)
+    if len(p) == 1:
+        return p[0] if polygon else (p[0], None)
+    elif len(p) == 2:
+        s = Segment(p[0], p[1])
+        return s if polygon else (s, None)
+
+    def _orientation(p, q, r):
+        '''Return positive if p-q-r are clockwise, neg if ccw, zero if
+        collinear.'''
+        return (q.y - p.y)*(r.x - p.x) - (q.x - p.x)*(r.y - p.y)
+
+    # scan to find upper and lower convex hulls of a set of 2d points.
+    U = []
+    L = []
+    try:
+        p.sort(key=lambda x: x.args)
+    except TypeError:
+        raise ValueError("The points could not be sorted.")
+    for p_i in p:
+        while len(U) > 1 and _orientation(U[-2], U[-1], p_i) <= 0:
+            U.pop()
+        while len(L) > 1 and _orientation(L[-2], L[-1], p_i) >= 0:
+            L.pop()
+        U.append(p_i)
+        L.append(p_i)
+    U.reverse()
+    convexHull = tuple(L + U[1:-1])
+
+    if len(convexHull) == 2:
+        s = Segment(convexHull[0], convexHull[1])
+        return s if polygon else (s, None)
+    if polygon:
+        return Polygon(*convexHull)
+    else:
+        U.reverse()
+        return (U, L)
+
+def farthest_points(*args):
+    """Return the subset of points from a set of points that were
+    the furthest apart from each other in the 2D plane.
+
+    Parameters
+    ==========
+
+    args
+        A collection of Points on 2D plane.
+
+    Notes
+    =====
+
+    This can only be performed on a set of points whose coordinates can
+    be ordered on the number line. If there are no ties then a single
+    pair of Points will be in the set.
+
+    Examples
+    ========
+
+    >>> from sympy.geometry import farthest_points, Triangle
+    >>> Triangle(sss=(3, 4, 5)).args
+    (Point2D(0, 0), Point2D(3, 0), Point2D(3, 4))
+    >>> farthest_points(*_)
+    {(Point2D(0, 0), Point2D(3, 4))}
+
+    References
+    ==========
+
+    .. [1] https://code.activestate.com/recipes/117225-convex-hull-and-diameter-of-2d-point-sets/
+
+    .. [2] Rotating Callipers Technique
+        https://en.wikipedia.org/wiki/Rotating_calipers
+
+    """
+
+    def rotatingCalipers(Points):
+        U, L = convex_hull(*Points, **{"polygon": False})
+
+        if L is None:
+            if isinstance(U, Point):
+                raise ValueError('At least two distinct points must be given.')
+            yield U.args
+        else:
+            i = 0
+            j = len(L) - 1
+            while i < len(U) - 1 or j > 0:
+                yield U[i], L[j]
+                # if all the way through one side of hull, advance the other side
+                if i == len(U) - 1:
+                    j -= 1
+                elif j == 0:
+                    i += 1
+                # still points left on both lists, compare slopes of next hull edges
+                # being careful to avoid divide-by-zero in slope calculation
+                elif (U[i+1].y - U[i].y) * (L[j].x - L[j-1].x) > \
+                        (L[j].y - L[j-1].y) * (U[i+1].x - U[i].x):
+                    i += 1
+                else:
+                    j -= 1
+
+    p = [Point2D(i) for i in set(args)]
+
+    if not all(i.is_Rational for j in p for i in j.args):
+        def hypot(x, y):
+            arg = x*x + y*y
+            if arg.is_Rational:
+                return _sqrt(arg)
+            return sqrt(arg)
+    else:
+        from math import hypot
+
+    rv = []
+    diam = 0
+    for pair in rotatingCalipers(args):
+        h, q = _ordered_points(pair)
+        d = hypot(h.x - q.x, h.y - q.y)
+        if d > diam:
+            rv = [(h, q)]
+        elif d == diam:
+            rv.append((h, q))
+        else:
+            continue
+        diam = d
+
+    return set(rv)
+
+
+def idiff(eq, y, x, n=1):
+    """Return ``dy/dx`` assuming that ``eq == 0``.
+
+    Parameters
+    ==========
+
+    y : the dependent variable or a list of dependent variables (with y first)
+    x : the variable that the derivative is being taken with respect to
+    n : the order of the derivative (default is 1)
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y, a
+    >>> from sympy.geometry.util import idiff
+
+    >>> circ = x**2 + y**2 - 4
+    >>> idiff(circ, y, x)
+    -x/y
+    >>> idiff(circ, y, x, 2).simplify()
+    (-x**2 - y**2)/y**3
+
+    Here, ``a`` is assumed to be independent of ``x``:
+
+    >>> idiff(x + a + y, y, x)
+    -1
+
+    Now the x-dependence of ``a`` is made explicit by listing ``a`` after
+    ``y`` in a list.
+
+    >>> idiff(x + a + y, [y, a], x)
+    -Derivative(a, x) - 1
+
+    See Also
+    ========
+
+    sympy.core.function.Derivative: represents unevaluated derivatives
+    sympy.core.function.diff: explicitly differentiates wrt symbols
+
+    """
+    if is_sequence(y):
+        dep = set(y)
+        y = y[0]
+    elif isinstance(y, Symbol):
+        dep = {y}
+    elif isinstance(y, Function):
+        pass
+    else:
+        raise ValueError("expecting x-dependent symbol(s) or function(s) but got: %s" % y)
+
+    f = {s: Function(s.name)(x) for s in eq.free_symbols
+        if s != x and s in dep}
+
+    if isinstance(y, Symbol):
+        dydx = Function(y.name)(x).diff(x)
+    else:
+        dydx = y.diff(x)
+
+    eq = eq.subs(f)
+    derivs = {}
+    for i in range(n):
+        # equation will be linear in dydx, a*dydx + b, so dydx = -b/a
+        deq = eq.diff(x)
+        b = deq.xreplace({dydx: S.Zero})
+        a = (deq - b).xreplace({dydx: S.One})
+        yp = factor_terms(expand_mul(cancel((-b/a).subs(derivs)), deep=False))
+        if i == n - 1:
+            return yp.subs([(v, k) for k, v in f.items()])
+        derivs[dydx] = yp
+        eq = dydx - yp
+        dydx = dydx.diff(x)
+
+
+def intersection(*entities, pairwise=False, **kwargs):
+    """The intersection of a collection of GeometryEntity instances.
+
+    Parameters
+    ==========
+    entities : sequence of GeometryEntity
+    pairwise (keyword argument) : Can be either True or False
+
+    Returns
+    =======
+    intersection : list of GeometryEntity
+
+    Raises
+    ======
+    NotImplementedError
+        When unable to calculate intersection.
+
+    Notes
+    =====
+    The intersection of any geometrical entity with itself should return
+    a list with one item: the entity in question.
+    An intersection requires two or more entities. If only a single
+    entity is given then the function will return an empty list.
+    It is possible for `intersection` to miss intersections that one
+    knows exists because the required quantities were not fully
+    simplified internally.
+    Reals should be converted to Rationals, e.g. Rational(str(real_num))
+    or else failures due to floating point issues may result.
+
+    Case 1: When the keyword argument 'pairwise' is False (default value):
+    In this case, the function returns a list of intersections common to
+    all entities.
+
+    Case 2: When the keyword argument 'pairwise' is True:
+    In this case, the functions returns a list intersections that occur
+    between any pair of entities.
+
+    See Also
+    ========
+
+    sympy.geometry.entity.GeometryEntity.intersection
+
+    Examples
+    ========
+
+    >>> from sympy import Ray, Circle, intersection
+    >>> c = Circle((0, 1), 1)
+    >>> intersection(c, c.center)
+    []
+    >>> right = Ray((0, 0), (1, 0))
+    >>> up = Ray((0, 0), (0, 1))
+    >>> intersection(c, right, up)
+    [Point2D(0, 0)]
+    >>> intersection(c, right, up, pairwise=True)
+    [Point2D(0, 0), Point2D(0, 2)]
+    >>> left = Ray((1, 0), (0, 0))
+    >>> intersection(right, left)
+    [Segment2D(Point2D(0, 0), Point2D(1, 0))]
+
+    """
+    if len(entities) <= 1:
+        return []
+
+    entities = list(entities)
+    prec = None
+    for i, e in enumerate(entities):
+        if not isinstance(e, GeometryEntity):
+            # entities may be an immutable tuple
+            e = Point(e)
+        # convert to exact Rationals
+        d = {}
+        for f in e.atoms(Float):
+            prec = f._prec if prec is None else min(f._prec, prec)
+            d.setdefault(f, nsimplify(f, rational=True))
+        entities[i] = e.xreplace(d)
+
+    if not pairwise:
+        # find the intersection common to all objects
+        res = entities[0].intersection(entities[1])
+        for entity in entities[2:]:
+            newres = []
+            for x in res:
+                newres.extend(x.intersection(entity))
+            res = newres
+    else:
+        # find all pairwise intersections
+        ans = []
+        for j in range(len(entities)):
+            for k in range(j + 1, len(entities)):
+                ans.extend(intersection(entities[j], entities[k]))
+        res = list(ordered(set(ans)))
+
+    # convert back to Floats
+    if prec is not None:
+        p = prec_to_dps(prec)
+        res = [i.n(p) for i in res]
+    return res

.venv/lib/python3.12/site-packages/sympy/holonomic/__init__.py

@@ -0,0 +1,18 @@
+r"""
+The :py:mod:`~sympy.holonomic` module is intended to deal with holonomic functions along
+with various operations on them like addition, multiplication, composition,
+integration and differentiation. The module also implements various kinds of
+conversions such as converting holonomic functions to a different form and the
+other way around.
+"""
+
+from .holonomic import (DifferentialOperator, HolonomicFunction, DifferentialOperators,
+    from_hyper, from_meijerg, expr_to_holonomic)
+from .recurrence import RecurrenceOperators, RecurrenceOperator, HolonomicSequence
+
+__all__ = [
+    'DifferentialOperator', 'HolonomicFunction', 'DifferentialOperators',
+    'from_hyper', 'from_meijerg', 'expr_to_holonomic',
+
+    'RecurrenceOperators', 'RecurrenceOperator', 'HolonomicSequence',
+]

.venv/lib/python3.12/site-packages/sympy/holonomic/__pycache__/holonomic.cpython-312.pyc

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

.venv/lib/python3.12/site-packages/sympy/holonomic/holonomic.py

@@ -0,0 +1,2765 @@
+"""
+This module implements Holonomic Functions and
+various operations on them.
+"""
+
+from sympy.core import Add, Mul, Pow
+from sympy.core.numbers import (NaN, Infinity, NegativeInfinity, Float, I, pi,
+        equal_valued, int_valued)
+from sympy.core.singleton import S
+from sympy.core.sorting import ordered
+from sympy.core.symbol import Dummy, Symbol
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import binomial, factorial, rf
+from sympy.functions.elementary.exponential import exp_polar, exp, log
+from sympy.functions.elementary.hyperbolic import (cosh, sinh)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin, sinc)
+from sympy.functions.special.error_functions import (Ci, Shi, Si, erf, erfc, erfi)
+from sympy.functions.special.gamma_functions import gamma
+from sympy.functions.special.hyper import hyper, meijerg
+from sympy.integrals import meijerint
+from sympy.matrices import Matrix
+from sympy.polys.rings import PolyElement
+from sympy.polys.fields import FracElement
+from sympy.polys.domains import QQ, RR
+from sympy.polys.polyclasses import DMF
+from sympy.polys.polyroots import roots
+from sympy.polys.polytools import Poly
+from sympy.polys.matrices import DomainMatrix
+from sympy.printing import sstr
+from sympy.series.limits import limit
+from sympy.series.order import Order
+from sympy.simplify.hyperexpand import hyperexpand
+from sympy.simplify.simplify import nsimplify
+from sympy.solvers.solvers import solve
+
+from .recurrence import HolonomicSequence, RecurrenceOperator, RecurrenceOperators
+from .holonomicerrors import (NotPowerSeriesError, NotHyperSeriesError,
+    SingularityError, NotHolonomicError)
+
+
+def _find_nonzero_solution(r, homosys):
+    ones = lambda shape: DomainMatrix.ones(shape, r.domain)
+    particular, nullspace = r._solve(homosys)
+    nullity = nullspace.shape[0]
+    nullpart = ones((1, nullity)) * nullspace
+    sol = (particular + nullpart).transpose()
+    return sol
+
+
+
+def DifferentialOperators(base, generator):
+    r"""
+    This function is used to create annihilators using ``Dx``.
+
+    Explanation
+    ===========
+
+    Returns an Algebra of Differential Operators also called Weyl Algebra
+    and the operator for differentiation i.e. the ``Dx`` operator.
+
+    Parameters
+    ==========
+
+    base:
+        Base polynomial ring for the algebra.
+        The base polynomial ring is the ring of polynomials in :math:`x` that
+        will appear as coefficients in the operators.
+    generator:
+        Generator of the algebra which can
+        be either a noncommutative ``Symbol`` or a string. e.g. "Dx" or "D".
+
+    Examples
+    ========
+
+    >>> from sympy import ZZ
+    >>> from sympy.abc import x
+    >>> from sympy.holonomic.holonomic import DifferentialOperators
+    >>> R, Dx = DifferentialOperators(ZZ.old_poly_ring(x), 'Dx')
+    >>> R
+    Univariate Differential Operator Algebra in intermediate Dx over the base ring ZZ[x]
+    >>> Dx*x
+    (1) + (x)*Dx
+    """
+
+    ring = DifferentialOperatorAlgebra(base, generator)
+    return (ring, ring.derivative_operator)
+
+
+class DifferentialOperatorAlgebra:
+    r"""
+    An Ore Algebra is a set of noncommutative polynomials in the
+    intermediate ``Dx`` and coefficients in a base polynomial ring :math:`A`.
+    It follows the commutation rule:
+
+    .. math ::
+       Dxa = \sigma(a)Dx + \delta(a)
+
+    for :math:`a \subset A`.
+
+    Where :math:`\sigma: A \Rightarrow A` is an endomorphism and :math:`\delta: A \rightarrow A`
+    is a skew-derivation i.e. :math:`\delta(ab) = \delta(a) b + \sigma(a) \delta(b)`.
+
+    If one takes the sigma as identity map and delta as the standard derivation
+    then it becomes the algebra of Differential Operators also called
+    a Weyl Algebra i.e. an algebra whose elements are Differential Operators.
+
+    This class represents a Weyl Algebra and serves as the parent ring for
+    Differential Operators.
+
+    Examples
+    ========
+
+    >>> from sympy import ZZ
+    >>> from sympy import symbols
+    >>> from sympy.holonomic.holonomic import DifferentialOperators
+    >>> x = symbols('x')
+    >>> R, Dx = DifferentialOperators(ZZ.old_poly_ring(x), 'Dx')
+    >>> R
+    Univariate Differential Operator Algebra in intermediate Dx over the base ring
+    ZZ[x]
+
+    See Also
+    ========
+
+    DifferentialOperator
+    """
+
+    def __init__(self, base, generator):
+        # the base polynomial ring for the algebra
+        self.base = base
+        # the operator representing differentiation i.e. `Dx`
+        self.derivative_operator = DifferentialOperator(
+            [base.zero, base.one], self)
+
+        if generator is None:
+            self.gen_symbol = Symbol('Dx', commutative=False)
+        else:
+            if isinstance(generator, str):
+                self.gen_symbol = Symbol(generator, commutative=False)
+            elif isinstance(generator, Symbol):
+                self.gen_symbol = generator
+
+    def __str__(self):
+        string = 'Univariate Differential Operator Algebra in intermediate '\
+            + sstr(self.gen_symbol) + ' over the base ring ' + \
+            (self.base).__str__()
+
+        return string
+
+    __repr__ = __str__
+
+    def __eq__(self, other):
+        return self.base == other.base and \
+               self.gen_symbol == other.gen_symbol
+
+
+class DifferentialOperator:
+    """
+    Differential Operators are elements of Weyl Algebra. The Operators
+    are defined by a list of polynomials in the base ring and the
+    parent ring of the Operator i.e. the algebra it belongs to.
+
+    Explanation
+    ===========
+
+    Takes a list of polynomials for each power of ``Dx`` and the
+    parent ring which must be an instance of DifferentialOperatorAlgebra.
+
+    A Differential Operator can be created easily using
+    the operator ``Dx``. See examples below.
+
+    Examples
+    ========
+
+    >>> from sympy.holonomic.holonomic import DifferentialOperator, DifferentialOperators
+    >>> from sympy import ZZ
+    >>> from sympy import symbols
+    >>> x = symbols('x')
+    >>> R, Dx = DifferentialOperators(ZZ.old_poly_ring(x),'Dx')
+
+    >>> DifferentialOperator([0, 1, x**2], R)
+    (1)*Dx + (x**2)*Dx**2
+
+    >>> (x*Dx*x + 1 - Dx**2)**2
+    (2*x**2 + 2*x + 1) + (4*x**3 + 2*x**2 - 4)*Dx + (x**4 - 6*x - 2)*Dx**2 + (-2*x**2)*Dx**3 + (1)*Dx**4
+
+    See Also
+    ========
+
+    DifferentialOperatorAlgebra
+    """
+
+    _op_priority = 20
+
+    def __init__(self, list_of_poly, parent):
+        """
+        Parameters
+        ==========
+
+        list_of_poly:
+            List of polynomials belonging to the base ring of the algebra.
+        parent:
+            Parent algebra of the operator.
+        """
+
+        # the parent ring for this operator
+        # must be an DifferentialOperatorAlgebra object
+        self.parent = parent
+        base = self.parent.base
+        self.x = base.gens[0] if isinstance(base.gens[0], Symbol) else base.gens[0][0]
+        # sequence of polynomials in x for each power of Dx
+        # the list should not have trailing zeroes
+        # represents the operator
+        # convert the expressions into ring elements using from_sympy
+        for i, j in enumerate(list_of_poly):
+            if not isinstance(j, base.dtype):
+                list_of_poly[i] = base.from_sympy(sympify(j))
+            else:
+                list_of_poly[i] = base.from_sympy(base.to_sympy(j))
+
+        self.listofpoly = list_of_poly
+        # highest power of `Dx`
+        self.order = len(self.listofpoly) - 1
+
+    def __mul__(self, other):
+        """
+        Multiplies two DifferentialOperator and returns another
+        DifferentialOperator instance using the commutation rule
+        Dx*a = a*Dx + a'
+        """
+
+        listofself = self.listofpoly
+        if isinstance(other, DifferentialOperator):
+            listofother = other.listofpoly
+        elif isinstance(other, self.parent.base.dtype):
+            listofother = [other]
+        else:
+            listofother = [self.parent.base.from_sympy(sympify(other))]
+
+        # multiplies a polynomial `b` with a list of polynomials
+        def _mul_dmp_diffop(b, listofother):
+            if isinstance(listofother, list):
+                return [i * b for i in listofother]
+            return [b * listofother]
+
+        sol = _mul_dmp_diffop(listofself[0], listofother)
+
+        # compute Dx^i * b
+        def _mul_Dxi_b(b):
+            sol1 = [self.parent.base.zero]
+            sol2 = []
+
+            if isinstance(b, list):
+                for i in b:
+                    sol1.append(i)
+                    sol2.append(i.diff())
+            else:
+                sol1.append(self.parent.base.from_sympy(b))
+                sol2.append(self.parent.base.from_sympy(b).diff())
+
+            return _add_lists(sol1, sol2)
+
+        for i in range(1, len(listofself)):
+            # find Dx^i * b in ith iteration
+            listofother = _mul_Dxi_b(listofother)
+            # solution = solution + listofself[i] * (Dx^i * b)
+            sol = _add_lists(sol, _mul_dmp_diffop(listofself[i], listofother))
+
+        return DifferentialOperator(sol, self.parent)
+
+    def __rmul__(self, other):
+        if not isinstance(other, DifferentialOperator):
+
+            if not isinstance(other, self.parent.base.dtype):
+                other = (self.parent.base).from_sympy(sympify(other))
+
+            sol = [other * j for j in self.listofpoly]
+            return DifferentialOperator(sol, self.parent)
+
+    def __add__(self, other):
+        if isinstance(other, DifferentialOperator):
+
+            sol = _add_lists(self.listofpoly, other.listofpoly)
+            return DifferentialOperator(sol, self.parent)
+
+        list_self = self.listofpoly
+        if not isinstance(other, self.parent.base.dtype):
+            list_other = [((self.parent).base).from_sympy(sympify(other))]
+        else:
+            list_other = [other]
+        sol = [list_self[0] + list_other[0]] + list_self[1:]
+        return DifferentialOperator(sol, self.parent)
+
+    __radd__ = __add__
+
+    def __sub__(self, other):
+        return self + (-1) * other
+
+    def __rsub__(self, other):
+        return (-1) * self + other
+
+    def __neg__(self):
+        return -1 * self
+
+    def __truediv__(self, other):
+        return self * (S.One / other)
+
+    def __pow__(self, n):
+        if n == 1:
+            return self
+        result = DifferentialOperator([self.parent.base.one], self.parent)
+        if n == 0:
+            return result
+        # if self is `Dx`
+        if self.listofpoly == self.parent.derivative_operator.listofpoly:
+            sol = [self.parent.base.zero]*n + [self.parent.base.one]
+            return DifferentialOperator(sol, self.parent)
+        x = self
+        while True:
+            if n % 2:
+                result *= x
+            n >>= 1
+            if not n:
+                break
+            x *= x
+        return result
+
+    def __str__(self):
+        listofpoly = self.listofpoly
+        print_str = ''
+
+        for i, j in enumerate(listofpoly):
+            if j == self.parent.base.zero:
+                continue
+
+            j = self.parent.base.to_sympy(j)
+
+            if i == 0:
+                print_str += '(' + sstr(j) + ')'
+                continue
+
+            if print_str:
+                print_str += ' + '
+
+            if i == 1:
+                print_str += '(' + sstr(j) + ')*%s' %(self.parent.gen_symbol)
+                continue
+
+            print_str += '(' + sstr(j) + ')' + '*%s**' %(self.parent.gen_symbol) + sstr(i)
+
+        return print_str
+
+    __repr__ = __str__
+
+    def __eq__(self, other):
+        if isinstance(other, DifferentialOperator):
+            return self.listofpoly == other.listofpoly and \
+                   self.parent == other.parent
+        return self.listofpoly[0] == other and \
+            all(i is self.parent.base.zero for i in self.listofpoly[1:])
+
+    def is_singular(self, x0):
+        """
+        Checks if the differential equation is singular at x0.
+        """
+
+        base = self.parent.base
+        return x0 in roots(base.to_sympy(self.listofpoly[-1]), self.x)
+
+
+class HolonomicFunction:
+    r"""
+    A Holonomic Function is a solution to a linear homogeneous ordinary
+    differential equation with polynomial coefficients. This differential
+    equation can also be represented by an annihilator i.e. a Differential
+    Operator ``L`` such that :math:`L.f = 0`. For uniqueness of these functions,
+    initial conditions can also be provided along with the annihilator.
+
+    Explanation
+    ===========
+
+    Holonomic functions have closure properties and thus forms a ring.
+    Given two Holonomic Functions f and g, their sum, product,
+    integral and derivative is also a Holonomic Function.
+
+    For ordinary points initial condition should be a vector of values of
+    the derivatives i.e. :math:`[y(x_0), y'(x_0), y''(x_0) ... ]`.
+
+    For regular singular points initial conditions can also be provided in this
+    format:
+    :math:`{s0: [C_0, C_1, ...], s1: [C^1_0, C^1_1, ...], ...}`
+    where s0, s1, ... are the roots of indicial equation and vectors
+    :math:`[C_0, C_1, ...], [C^0_0, C^0_1, ...], ...` are the corresponding initial
+    terms of the associated power series. See Examples below.
+
+    Examples
+    ========
+
+    >>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators
+    >>> from sympy import QQ
+    >>> from sympy import symbols, S
+    >>> x = symbols('x')
+    >>> R, Dx = DifferentialOperators(QQ.old_poly_ring(x),'Dx')
+
+    >>> p = HolonomicFunction(Dx - 1, x, 0, [1])  # e^x
+    >>> q = HolonomicFunction(Dx**2 + 1, x, 0, [0, 1])  # sin(x)
+
+    >>> p + q  # annihilator of e^x + sin(x)
+    HolonomicFunction((-1) + (1)*Dx + (-1)*Dx**2 + (1)*Dx**3, x, 0, [1, 2, 1])
+
+    >>> p * q  # annihilator of e^x * sin(x)
+    HolonomicFunction((2) + (-2)*Dx + (1)*Dx**2, x, 0, [0, 1])
+
+    An example of initial conditions for regular singular points,
+    the indicial equation has only one root `1/2`.
+
+    >>> HolonomicFunction(-S(1)/2 + x*Dx, x, 0, {S(1)/2: [1]})
+    HolonomicFunction((-1/2) + (x)*Dx, x, 0, {1/2: [1]})
+
+    >>> HolonomicFunction(-S(1)/2 + x*Dx, x, 0, {S(1)/2: [1]}).to_expr()
+    sqrt(x)
+
+    To plot a Holonomic Function, one can use `.evalf()` for numerical
+    computation. Here's an example on `sin(x)**2/x` using numpy and matplotlib.
+
+    >>> import sympy.holonomic # doctest: +SKIP
+    >>> from sympy import var, sin # doctest: +SKIP
+    >>> import matplotlib.pyplot as plt # doctest: +SKIP
+    >>> import numpy as np # doctest: +SKIP
+    >>> var("x") # doctest: +SKIP
+    >>> r = np.linspace(1, 5, 100) # doctest: +SKIP
+    >>> y = sympy.holonomic.expr_to_holonomic(sin(x)**2/x, x0=1).evalf(r) # doctest: +SKIP
+    >>> plt.plot(r, y, label="holonomic function") # doctest: +SKIP
+    >>> plt.show() # doctest: +SKIP
+
+    """
+
+    _op_priority = 20
+
+    def __init__(self, annihilator, x, x0=0, y0=None):
+        """
+
+        Parameters
+        ==========
+
+        annihilator:
+            Annihilator of the Holonomic Function, represented by a
+            `DifferentialOperator` object.
+        x:
+            Variable of the function.
+        x0:
+            The point at which initial conditions are stored.
+            Generally an integer.
+        y0:
+            The initial condition. The proper format for the initial condition
+            is described in class docstring. To make the function unique,
+            length of the vector `y0` should be equal to or greater than the
+            order of differential equation.
+        """
+
+        # initial condition
+        self.y0 = y0
+        # the point for initial conditions, default is zero.
+        self.x0 = x0
+        # differential operator L such that L.f = 0
+        self.annihilator = annihilator
+        self.x = x
+
+    def __str__(self):
+        if self._have_init_cond():
+            str_sol = 'HolonomicFunction(%s, %s, %s, %s)' % (str(self.annihilator),\
+                sstr(self.x), sstr(self.x0), sstr(self.y0))
+        else:
+            str_sol = 'HolonomicFunction(%s, %s)' % (str(self.annihilator),\
+                sstr(self.x))
+
+        return str_sol
+
+    __repr__ = __str__
+
+    def unify(self, other):
+        """
+        Unifies the base polynomial ring of a given two Holonomic
+        Functions.
+        """
+
+        R1 = self.annihilator.parent.base
+        R2 = other.annihilator.parent.base
+
+        dom1 = R1.dom
+        dom2 = R2.dom
+
+        if R1 == R2:
+            return (self, other)
+
+        R = (dom1.unify(dom2)).old_poly_ring(self.x)
+
+        newparent, _ = DifferentialOperators(R, str(self.annihilator.parent.gen_symbol))
+
+        sol1 = [R1.to_sympy(i) for i in self.annihilator.listofpoly]
+        sol2 = [R2.to_sympy(i) for i in other.annihilator.listofpoly]
+
+        sol1 = DifferentialOperator(sol1, newparent)
+        sol2 = DifferentialOperator(sol2, newparent)
+
+        sol1 = HolonomicFunction(sol1, self.x, self.x0, self.y0)
+        sol2 = HolonomicFunction(sol2, other.x, other.x0, other.y0)
+
+        return (sol1, sol2)
+
+    def is_singularics(self):
+        """
+        Returns True if the function have singular initial condition
+        in the dictionary format.
+
+        Returns False if the function have ordinary initial condition
+        in the list format.
+
+        Returns None for all other cases.
+        """
+
+        if isinstance(self.y0, dict):
+            return True
+        elif isinstance(self.y0, list):
+            return False
+
+    def _have_init_cond(self):
+        """
+        Checks if the function have initial condition.
+        """
+        return bool(self.y0)
+
+    def _singularics_to_ord(self):
+        """
+        Converts a singular initial condition to ordinary if possible.
+        """
+        a = list(self.y0)[0]
+        b = self.y0[a]
+
+        if len(self.y0) == 1 and a == int(a) and a > 0:
+            a = int(a)
+            y0 = [S.Zero] * a
+            y0 += [j * factorial(a + i) for i, j in enumerate(b)]
+
+            return HolonomicFunction(self.annihilator, self.x, self.x0, y0)
+
+    def __add__(self, other):
+        # if the ground domains are different
+        if self.annihilator.parent.base != other.annihilator.parent.base:
+            a, b = self.unify(other)
+            return a + b
+
+        deg1 = self.annihilator.order
+        deg2 = other.annihilator.order
+        dim = max(deg1, deg2)
+        R = self.annihilator.parent.base
+        K = R.get_field()
+
+        rowsself = [self.annihilator]
+        rowsother = [other.annihilator]
+        gen = self.annihilator.parent.derivative_operator
+
+        # constructing annihilators up to order dim
+        for i in range(dim - deg1):
+            diff1 = (gen * rowsself[-1])
+            rowsself.append(diff1)
+
+        for i in range(dim - deg2):
+            diff2 = (gen * rowsother[-1])
+            rowsother.append(diff2)
+
+        row = rowsself + rowsother
+
+        # constructing the matrix of the ansatz
+        r = []
+
+        for expr in row:
+            p = []
+            for i in range(dim + 1):
+                if i >= len(expr.listofpoly):
+                    p.append(K.zero)
+                else:
+                    p.append(K.new(expr.listofpoly[i].to_list()))
+            r.append(p)
+
+        # solving the linear system using gauss jordan solver
+        r = DomainMatrix(r, (len(row), dim+1), K).transpose()
+        homosys = DomainMatrix.zeros((dim+1, 1), K)
+        sol = _find_nonzero_solution(r, homosys)
+
+        # if a solution is not obtained then increasing the order by 1 in each
+        # iteration
+        while sol.is_zero_matrix:
+            dim += 1
+
+            diff1 = (gen * rowsself[-1])
+            rowsself.append(diff1)
+
+            diff2 = (gen * rowsother[-1])
+            rowsother.append(diff2)
+
+            row = rowsself + rowsother
+            r = []
+
+            for expr in row:
+                p = []
+                for i in range(dim + 1):
+                    if i >= len(expr.listofpoly):
+                        p.append(K.zero)
+                    else:
+                        p.append(K.new(expr.listofpoly[i].to_list()))
+                r.append(p)
+
+            # solving the linear system using gauss jordan solver
+            r = DomainMatrix(r, (len(row), dim+1), K).transpose()
+            homosys = DomainMatrix.zeros((dim+1, 1), K)
+            sol = _find_nonzero_solution(r, homosys)
+
+        # taking only the coefficients needed to multiply with `self`
+        # can be also be done the other way by taking R.H.S and multiplying with
+        # `other`
+        sol = sol.flat()[:dim + 1 - deg1]
+        sol1 = _normalize(sol, self.annihilator.parent)
+        # annihilator of the solution
+        sol = sol1 * (self.annihilator)
+        sol = _normalize(sol.listofpoly, self.annihilator.parent, negative=False)
+
+        if not (self._have_init_cond() and other._have_init_cond()):
+            return HolonomicFunction(sol, self.x)
+
+        # both the functions have ordinary initial conditions
+        if self.is_singularics() == False and other.is_singularics() == False:
+
+            # directly add the corresponding value
+            if self.x0 == other.x0:
+                # try to extended the initial conditions
+                # using the annihilator
+                y1 = _extend_y0(self, sol.order)
+                y2 = _extend_y0(other, sol.order)
+                y0 = [a + b for a, b in zip(y1, y2)]
+                return HolonomicFunction(sol, self.x, self.x0, y0)
+
+            # change the initial conditions to a same point
+            selfat0 = self.annihilator.is_singular(0)
+            otherat0 = other.annihilator.is_singular(0)
+            if self.x0 == 0 and not selfat0 and not otherat0:
+                return self + other.change_ics(0)
+            if other.x0 == 0 and not selfat0 and not otherat0:
+                return self.change_ics(0) + other
+
+            selfatx0 = self.annihilator.is_singular(self.x0)
+            otheratx0 = other.annihilator.is_singular(self.x0)
+            if not selfatx0 and not otheratx0:
+                return self + other.change_ics(self.x0)
+            return self.change_ics(other.x0) + other
+
+        if self.x0 != other.x0:
+            return HolonomicFunction(sol, self.x)
+
+        # if the functions have singular_ics
+        y1 = None
+        y2 = None
+
+        if self.is_singularics() == False and other.is_singularics() == True:
+            # convert the ordinary initial condition to singular.
+            _y0 = [j / factorial(i) for i, j in enumerate(self.y0)]
+            y1 = {S.Zero: _y0}
+            y2 = other.y0
+        elif self.is_singularics() == True and other.is_singularics() == False:
+            _y0 = [j / factorial(i) for i, j in enumerate(other.y0)]
+            y1 = self.y0
+            y2 = {S.Zero: _y0}
+        elif self.is_singularics() == True and other.is_singularics() == True:
+            y1 = self.y0
+            y2 = other.y0
+
+        # computing singular initial condition for the result
+        # taking union of the series terms of both functions
+        y0 = {}
+        for i in y1:
+            # add corresponding initial terms if the power
+            # on `x` is same
+            if i in y2:
+                y0[i] = [a + b for a, b in zip(y1[i], y2[i])]
+            else:
+                y0[i] = y1[i]
+        for i in y2:
+            if i not in y1:
+                y0[i] = y2[i]
+        return HolonomicFunction(sol, self.x, self.x0, y0)
+
+    def integrate(self, limits, initcond=False):
+        """
+        Integrates the given holonomic function.
+
+        Examples
+        ========
+
+        >>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators
+        >>> from sympy import QQ
+        >>> from sympy import symbols
+        >>> x = symbols('x')
+        >>> R, Dx = DifferentialOperators(QQ.old_poly_ring(x),'Dx')
+        >>> HolonomicFunction(Dx - 1, x, 0, [1]).integrate((x, 0, x))  # e^x - 1
+        HolonomicFunction((-1)*Dx + (1)*Dx**2, x, 0, [0, 1])
+        >>> HolonomicFunction(Dx**2 + 1, x, 0, [1, 0]).integrate((x, 0, x))
+        HolonomicFunction((1)*Dx + (1)*Dx**3, x, 0, [0, 1, 0])
+        """
+
+        # to get the annihilator, just multiply by Dx from right
+        D = self.annihilator.parent.derivative_operator
+
+        # if the function have initial conditions of the series format
+        if self.is_singularics() == True:
+
+            r = self._singularics_to_ord()
+            if r:
+                return r.integrate(limits, initcond=initcond)
+
+            # computing singular initial condition for the function
+            # produced after integration.
+            y0 = {}
+            for i in self.y0:
+                c = self.y0[i]
+                c2 = []
+                for j, cj in enumerate(c):
+                    if cj == 0:
+                        c2.append(S.Zero)
+
+                    # if power on `x` is -1, the integration becomes log(x)
+                    # TODO: Implement this case
+                    elif i + j + 1 == 0:
+                        raise NotImplementedError("logarithmic terms in the series are not supported")
+                    else:
+                        c2.append(cj / S(i + j + 1))
+                y0[i + 1] = c2
+
+            if hasattr(limits, "__iter__"):
+                raise NotImplementedError("Definite integration for singular initial conditions")
+
+            return HolonomicFunction(self.annihilator * D, self.x, self.x0, y0)
+
+        # if no initial conditions are available for the function
+        if not self._have_init_cond():
+            if initcond:
+                return HolonomicFunction(self.annihilator * D, self.x, self.x0, [S.Zero])
+            return HolonomicFunction(self.annihilator * D, self.x)
+
+        # definite integral
+        # initial conditions for the answer will be stored at point `a`,
+        # where `a` is the lower limit of the integrand
+        if hasattr(limits, "__iter__"):
+
+            if len(limits) == 3 and limits[0] == self.x:
+                x0 = self.x0
+                a = limits[1]
+                b = limits[2]
+                definite = True
+
+        else:
+            definite = False
+
+        y0 = [S.Zero]
+        y0 += self.y0
+
+        indefinite_integral = HolonomicFunction(self.annihilator * D, self.x, self.x0, y0)
+
+        if not definite:
+            return indefinite_integral
+
+        # use evalf to get the values at `a`
+        if x0 != a:
+            try:
+                indefinite_expr = indefinite_integral.to_expr()
+            except (NotHyperSeriesError, NotPowerSeriesError):
+                indefinite_expr = None
+
+            if indefinite_expr:
+                lower = indefinite_expr.subs(self.x, a)
+                if isinstance(lower, NaN):
+                    lower = indefinite_expr.limit(self.x, a)
+            else:
+                lower = indefinite_integral.evalf(a)
+
+            if b == self.x:
+                y0[0] = y0[0] - lower
+                return HolonomicFunction(self.annihilator * D, self.x, x0, y0)
+
+            elif S(b).is_Number:
+                if indefinite_expr:
+                    upper = indefinite_expr.subs(self.x, b)
+                    if isinstance(upper, NaN):
+                        upper = indefinite_expr.limit(self.x, b)
+                else:
+                    upper = indefinite_integral.evalf(b)
+
+                return upper - lower
+
+
+        # if the upper limit is `x`, the answer will be a function
+        if b == self.x:
+            return HolonomicFunction(self.annihilator * D, self.x, a, y0)
+
+        # if the upper limits is a Number, a numerical value will be returned
+        elif S(b).is_Number:
+            try:
+                s = HolonomicFunction(self.annihilator * D, self.x, a,\
+                    y0).to_expr()
+                indefinite = s.subs(self.x, b)
+                if not isinstance(indefinite, NaN):
+                    return indefinite
+                else:
+                    return s.limit(self.x, b)
+            except (NotHyperSeriesError, NotPowerSeriesError):
+                return HolonomicFunction(self.annihilator * D, self.x, a, y0).evalf(b)
+
+        return HolonomicFunction(self.annihilator * D, self.x)
+
+    def diff(self, *args, **kwargs):
+        r"""
+        Differentiation of the given Holonomic function.
+
+        Examples
+        ========
+
+        >>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators
+        >>> from sympy import ZZ
+        >>> from sympy import symbols
+        >>> x = symbols('x')
+        >>> R, Dx = DifferentialOperators(ZZ.old_poly_ring(x),'Dx')
+        >>> HolonomicFunction(Dx**2 + 1, x, 0, [0, 1]).diff().to_expr()
+        cos(x)
+        >>> HolonomicFunction(Dx - 2, x, 0, [1]).diff().to_expr()
+        2*exp(2*x)
+
+        See Also
+        ========
+
+        integrate
+        """
+        kwargs.setdefault('evaluate', True)
+        if args:
+            if args[0] != self.x:
+                return S.Zero
+            elif len(args) == 2:
+                sol = self
+                for i in range(args[1]):
+                    sol = sol.diff(args[0])
+                return sol
+
+        ann = self.annihilator
+
+        # if the function is constant.
+        if ann.listofpoly[0] == ann.parent.base.zero and ann.order == 1:
+            return S.Zero
+
+        # if the coefficient of y in the differential equation is zero.
+        # a shifting is done to compute the answer in this case.
+        elif ann.listofpoly[0] == ann.parent.base.zero:
+
+            sol = DifferentialOperator(ann.listofpoly[1:], ann.parent)
+
+            if self._have_init_cond():
+                # if ordinary initial condition
+                if self.is_singularics() == False:
+                    return HolonomicFunction(sol, self.x, self.x0, self.y0[1:])
+                # TODO: support for singular initial condition
+                return HolonomicFunction(sol, self.x)
+            else:
+                return HolonomicFunction(sol, self.x)
+
+        # the general algorithm
+        R = ann.parent.base
+        K = R.get_field()
+
+        seq_dmf = [K.new(i.to_list()) for i in ann.listofpoly]
+
+        # -y = a1*y'/a0 + a2*y''/a0 ... + an*y^n/a0
+        rhs = [i / seq_dmf[0] for i in seq_dmf[1:]]
+        rhs.insert(0, K.zero)
+
+        # differentiate both lhs and rhs
+        sol = _derivate_diff_eq(rhs, K)
+
+        # add the term y' in lhs to rhs
+        sol = _add_lists(sol, [K.zero, K.one])
+
+        sol = _normalize(sol[1:], self.annihilator.parent, negative=False)
+
+        if not self._have_init_cond() or self.is_singularics() == True:
+            return HolonomicFunction(sol, self.x)
+
+        y0 = _extend_y0(self, sol.order + 1)[1:]
+        return HolonomicFunction(sol, self.x, self.x0, y0)
+
+    def __eq__(self, other):
+        if self.annihilator != other.annihilator or self.x != other.x:
+            return False
+        if self._have_init_cond() and other._have_init_cond():
+            return self.x0 == other.x0 and self.y0 == other.y0
+        return True
+
+    def __mul__(self, other):
+        ann_self = self.annihilator
+
+        if not isinstance(other, HolonomicFunction):
+            other = sympify(other)
+
+            if other.has(self.x):
+                raise NotImplementedError(" Can't multiply a HolonomicFunction and expressions/functions.")
+
+            if not self._have_init_cond():
+                return self
+            y0 = _extend_y0(self, ann_self.order)
+            y1 = [(Poly.new(j, self.x) * other).rep for j in y0]
+            return HolonomicFunction(ann_self, self.x, self.x0, y1)
+
+        if self.annihilator.parent.base != other.annihilator.parent.base:
+            a, b = self.unify(other)
+            return a * b
+
+        ann_other = other.annihilator
+
+        a = ann_self.order
+        b = ann_other.order
+
+        R = ann_self.parent.base
+        K = R.get_field()
+
+        list_self = [K.new(j.to_list()) for j in ann_self.listofpoly]
+        list_other = [K.new(j.to_list()) for j in ann_other.listofpoly]
+
+        # will be used to reduce the degree
+        self_red = [-list_self[i] / list_self[a] for i in range(a)]
+
+        other_red = [-list_other[i] / list_other[b] for i in range(b)]
+
+        # coeff_mull[i][j] is the coefficient of Dx^i(f).Dx^j(g)
+        coeff_mul = [[K.zero for i in range(b + 1)] for j in range(a + 1)]
+        coeff_mul[0][0] = K.one
+
+        # making the ansatz
+        lin_sys_elements = [[coeff_mul[i][j] for i in range(a) for j in range(b)]]
+        lin_sys = DomainMatrix(lin_sys_elements, (1, a*b), K).transpose()
+
+        homo_sys = DomainMatrix.zeros((a*b, 1), K)
+
+        sol = _find_nonzero_solution(lin_sys, homo_sys)
+
+        # until a non trivial solution is found
+        while sol.is_zero_matrix:
+
+            # updating the coefficients Dx^i(f).Dx^j(g) for next degree
+            for i in range(a - 1, -1, -1):
+                for j in range(b - 1, -1, -1):
+                    coeff_mul[i][j + 1] += coeff_mul[i][j]
+                    coeff_mul[i + 1][j] += coeff_mul[i][j]
+                    if isinstance(coeff_mul[i][j], K.dtype):
+                        coeff_mul[i][j] = DMFdiff(coeff_mul[i][j], K)
+                    else:
+                        coeff_mul[i][j] = coeff_mul[i][j].diff(self.x)
+
+            # reduce the terms to lower power using annihilators of f, g
+            for i in range(a + 1):
+                if coeff_mul[i][b].is_zero:
+                    continue
+                for j in range(b):
+                    coeff_mul[i][j] += other_red[j] * coeff_mul[i][b]
+                coeff_mul[i][b] = K.zero
+
+            # not d2 + 1, as that is already covered in previous loop
+            for j in range(b):
+                if coeff_mul[a][j] == 0:
+                    continue
+                for i in range(a):
+                    coeff_mul[i][j] += self_red[i] * coeff_mul[a][j]
+                coeff_mul[a][j] = K.zero
+
+            lin_sys_elements.append([coeff_mul[i][j] for i in range(a) for j in range(b)])
+            lin_sys = DomainMatrix(lin_sys_elements, (len(lin_sys_elements), a*b), K).transpose()
+
+            sol = _find_nonzero_solution(lin_sys, homo_sys)
+
+        sol_ann = _normalize(sol.flat(), self.annihilator.parent, negative=False)
+
+        if not (self._have_init_cond() and other._have_init_cond()):
+            return HolonomicFunction(sol_ann, self.x)
+
+        if self.is_singularics() == False and other.is_singularics() == False:
+
+            # if both the conditions are at same point
+            if self.x0 == other.x0:
+
+                # try to find more initial conditions
+                y0_self = _extend_y0(self, sol_ann.order)
+                y0_other = _extend_y0(other, sol_ann.order)
+                # h(x0) = f(x0) * g(x0)
+                y0 = [y0_self[0] * y0_other[0]]
+
+                # coefficient of Dx^j(f)*Dx^i(g) in Dx^i(fg)
+                for i in range(1, min(len(y0_self), len(y0_other))):
+                    coeff = [[0 for i in range(i + 1)] for j in range(i + 1)]
+                    for j in range(i + 1):
+                        for k in range(i + 1):
+                            if j + k == i:
+                                coeff[j][k] = binomial(i, j)
+
+                    sol = 0
+                    for j in range(i + 1):
+                        for k in range(i + 1):
+                            sol += coeff[j][k]* y0_self[j] * y0_other[k]
+
+                    y0.append(sol)
+
+                return HolonomicFunction(sol_ann, self.x, self.x0, y0)
+
+            # if the points are different, consider one
+            selfat0 = self.annihilator.is_singular(0)
+            otherat0 = other.annihilator.is_singular(0)
+
+            if self.x0 == 0 and not selfat0 and not otherat0:
+                return self * other.change_ics(0)
+            if other.x0 == 0 and not selfat0 and not otherat0:
+                return self.change_ics(0) * other
+
+            selfatx0 = self.annihilator.is_singular(self.x0)
+            otheratx0 = other.annihilator.is_singular(self.x0)
+            if not selfatx0 and not otheratx0:
+                return self * other.change_ics(self.x0)
+            return self.change_ics(other.x0) * other
+
+        if self.x0 != other.x0:
+            return HolonomicFunction(sol_ann, self.x)
+
+        # if the functions have singular_ics
+        y1 = None
+        y2 = None
+
+        if self.is_singularics() == False and other.is_singularics() == True:
+            _y0 = [j / factorial(i) for i, j in enumerate(self.y0)]
+            y1 = {S.Zero: _y0}
+            y2 = other.y0
+        elif self.is_singularics() == True and other.is_singularics() == False:
+            _y0 = [j / factorial(i) for i, j in enumerate(other.y0)]
+            y1 = self.y0
+            y2 = {S.Zero: _y0}
+        elif self.is_singularics() == True and other.is_singularics() == True:
+            y1 = self.y0
+            y2 = other.y0
+
+        y0 = {}
+        # multiply every possible pair of the series terms
+        for i in y1:
+            for j in y2:
+                k = min(len(y1[i]), len(y2[j]))
+                c = [sum((y1[i][b] * y2[j][a - b] for b in range(a + 1)),
+                         start=S.Zero) for a in range(k)]
+                if not i + j in y0:
+                    y0[i + j] = c
+                else:
+                    y0[i + j] = [a + b for a, b in zip(c, y0[i + j])]
+        return HolonomicFunction(sol_ann, self.x, self.x0, y0)
+
+    __rmul__ = __mul__
+
+    def __sub__(self, other):
+        return self + other * -1
+
+    def __rsub__(self, other):
+        return self * -1 + other
+
+    def __neg__(self):
+        return -1 * self
+
+    def __truediv__(self, other):
+        return self * (S.One / other)
+
+    def __pow__(self, n):
+        if self.annihilator.order <= 1:
+            ann = self.annihilator
+            parent = ann.parent
+
+            if self.y0 is None:
+                y0 = None
+            else:
+                y0 = [list(self.y0)[0] ** n]
+
+            p0 = ann.listofpoly[0]
+            p1 = ann.listofpoly[1]
+
+            p0 = (Poly.new(p0, self.x) * n).rep
+
+            sol = [parent.base.to_sympy(i) for i in [p0, p1]]
+            dd = DifferentialOperator(sol, parent)
+            return HolonomicFunction(dd, self.x, self.x0, y0)
+        if n < 0:
+            raise NotHolonomicError("Negative Power on a Holonomic Function")
+        Dx = self.annihilator.parent.derivative_operator
+        result = HolonomicFunction(Dx, self.x, S.Zero, [S.One])
+        if n == 0:
+            return result
+        x = self
+        while True:
+            if n % 2:
+                result *= x
+            n >>= 1
+            if not n:
+                break
+            x *= x
+        return result
+
+    def degree(self):
+        """
+        Returns the highest power of `x` in the annihilator.
+        """
+        return max(i.degree() for i in self.annihilator.listofpoly)
+
+    def composition(self, expr, *args, **kwargs):
+        """
+        Returns function after composition of a holonomic
+        function with an algebraic function. The method cannot compute
+        initial conditions for the result by itself, so they can be also be
+        provided.
+
+        Examples
+        ========
+
+        >>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators
+        >>> from sympy import QQ
+        >>> from sympy import symbols
+        >>> x = symbols('x')
+        >>> R, Dx = DifferentialOperators(QQ.old_poly_ring(x),'Dx')
+        >>> HolonomicFunction(Dx - 1, x).composition(x**2, 0, [1])  # e^(x**2)
+        HolonomicFunction((-2*x) + (1)*Dx, x, 0, [1])
+        >>> HolonomicFunction(Dx**2 + 1, x).composition(x**2 - 1, 1, [1, 0])
+        HolonomicFunction((4*x**3) + (-1)*Dx + (x)*Dx**2, x, 1, [1, 0])
+
+        See Also
+        ========
+
+        from_hyper
+        """
+
+        R = self.annihilator.parent
+        a = self.annihilator.order
+        diff = expr.diff(self.x)
+        listofpoly = self.annihilator.listofpoly
+
+        for i, j in enumerate(listofpoly):
+            if isinstance(j, self.annihilator.parent.base.dtype):
+                listofpoly[i] = self.annihilator.parent.base.to_sympy(j)
+
+        r = listofpoly[a].subs({self.x:expr})
+        subs = [-listofpoly[i].subs({self.x:expr}) / r for i in range (a)]
+        coeffs = [S.Zero for i in range(a)]  # coeffs[i] == coeff of (D^i f)(a) in D^k (f(a))
+        coeffs[0] = S.One
+        system = [coeffs]
+        homogeneous = Matrix([[S.Zero for i in range(a)]]).transpose()
+        while True:
+            coeffs_next = [p.diff(self.x) for p in coeffs]
+            for i in range(a - 1):
+                coeffs_next[i + 1] += (coeffs[i] * diff)
+            for i in range(a):
+                coeffs_next[i] += (coeffs[-1] * subs[i] * diff)
+            coeffs = coeffs_next
+            # check for linear relations
+            system.append(coeffs)
+            sol, taus = (Matrix(system).transpose()
+                ).gauss_jordan_solve(homogeneous)
+            if sol.is_zero_matrix is not True:
+                break
+
+        tau = list(taus)[0]
+        sol = sol.subs(tau, 1)
+        sol = _normalize(sol[0:], R, negative=False)
+
+        # if initial conditions are given for the resulting function
+        if args:
+            return HolonomicFunction(sol, self.x, args[0], args[1])
+        return HolonomicFunction(sol, self.x)
+
+    def to_sequence(self, lb=True):
+        r"""
+        Finds recurrence relation for the coefficients in the series expansion
+        of the function about :math:`x_0`, where :math:`x_0` is the point at
+        which the initial condition is stored.
+
+        Explanation
+        ===========
+
+        If the point :math:`x_0` is ordinary, solution of the form :math:`[(R, n_0)]`
+        is returned. Where :math:`R` is the recurrence relation and :math:`n_0` is the
+        smallest ``n`` for which the recurrence holds true.
+
+        If the point :math:`x_0` is regular singular, a list of solutions in
+        the format :math:`(R, p, n_0)` is returned, i.e. `[(R, p, n_0), ... ]`.
+        Each tuple in this vector represents a recurrence relation :math:`R`
+        associated with a root of the indicial equation ``p``. Conditions of
+        a different format can also be provided in this case, see the
+        docstring of HolonomicFunction class.
+
+        If it's not possible to numerically compute a initial condition,
+        it is returned as a symbol :math:`C_j`, denoting the coefficient of
+        :math:`(x - x_0)^j` in the power series about :math:`x_0`.
+
+        Examples
+        ========
+
+        >>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators
+        >>> from sympy import QQ
+        >>> from sympy import symbols, S
+        >>> x = symbols('x')
+        >>> R, Dx = DifferentialOperators(QQ.old_poly_ring(x),'Dx')
+        >>> HolonomicFunction(Dx - 1, x, 0, [1]).to_sequence()
+        [(HolonomicSequence((-1) + (n + 1)Sn, n), u(0) = 1, 0)]
+        >>> HolonomicFunction((1 + x)*Dx**2 + Dx, x, 0, [0, 1]).to_sequence()
+        [(HolonomicSequence((n**2) + (n**2 + n)Sn, n), u(0) = 0, u(1) = 1, u(2) = -1/2, 2)]
+        >>> HolonomicFunction(-S(1)/2 + x*Dx, x, 0, {S(1)/2: [1]}).to_sequence()
+        [(HolonomicSequence((n), n), u(0) = 1, 1/2, 1)]
+
+        See Also
+        ========
+
+        HolonomicFunction.series
+
+        References
+        ==========
+
+        .. [1] https://hal.inria.fr/inria-00070025/document
+        .. [2] https://www3.risc.jku.at/publications/download/risc_2244/DIPLFORM.pdf
+
+        """
+
+        if self.x0 != 0:
+            return self.shift_x(self.x0).to_sequence()
+
+        # check whether a power series exists if the point is singular
+        if self.annihilator.is_singular(self.x0):
+            return self._frobenius(lb=lb)
+
+        dict1 = {}
+        n = Symbol('n', integer=True)
+        dom = self.annihilator.parent.base.dom
+        R, _ = RecurrenceOperators(dom.old_poly_ring(n), 'Sn')
+
+        # substituting each term of the form `x^k Dx^j` in the
+        # annihilator, according to the formula below:
+        # x^k Dx^j = Sum(rf(n + 1 - k, j) * a(n + j - k) * x^n, (n, k, oo))
+        # for explanation see [2].
+        for i, j in enumerate(self.annihilator.listofpoly):
+
+            listofdmp = j.all_coeffs()
+            degree = len(listofdmp) - 1
+
+            for k in range(degree + 1):
+                coeff = listofdmp[degree - k]
+
+                if coeff == 0:
+                    continue
+
+                if (i - k, k) in dict1:
+                    dict1[(i - k, k)] += (dom.to_sympy(coeff) * rf(n - k + 1, i))
+                else:
+                    dict1[(i - k, k)] = (dom.to_sympy(coeff) * rf(n - k + 1, i))
+
+
+        sol = []
+        keylist = [i[0] for i in dict1]
+        lower = min(keylist)
+        upper = max(keylist)
+        degree = self.degree()
+
+        # the recurrence relation holds for all values of
+        # n greater than smallest_n, i.e. n >= smallest_n
+        smallest_n = lower + degree
+        dummys = {}
+        eqs = []
+        unknowns = []
+
+        # an appropriate shift of the recurrence
+        for j in range(lower, upper + 1):
+            if j in keylist:
+                temp = sum((v.subs(n, n - lower)
+                           for k, v in dict1.items() if k[0] == j),
+                           start=S.Zero)
+                sol.append(temp)
+            else:
+                sol.append(S.Zero)
+
+        # the recurrence relation
+        sol = RecurrenceOperator(sol, R)
+
+        # computing the initial conditions for recurrence
+        order = sol.order
+        all_roots = roots(R.base.to_sympy(sol.listofpoly[-1]), n, filter='Z')
+        all_roots = all_roots.keys()
+
+        if all_roots:
+            max_root = max(all_roots) + 1
+            smallest_n = max(max_root, smallest_n)
+        order += smallest_n
+
+        y0 = _extend_y0(self, order)
+        # u(n) = y^n(0)/factorial(n)
+        u0 = [j / factorial(i) for i, j in enumerate(y0)]
+
+        # if sufficient conditions can't be computed then
+        # try to use the series method i.e.
+        # equate the coefficients of x^k in the equation formed by
+        # substituting the series in differential equation, to zero.
+        if len(u0) < order:
+
+            for i in range(degree):
+                eq = S.Zero
+
+                for j in dict1:
+
+                    if i + j[0] < 0:
+                        dummys[i + j[0]] = S.Zero
+
+                    elif i + j[0] < len(u0):
+                        dummys[i + j[0]] = u0[i + j[0]]
+
+                    elif not i + j[0] in dummys:
+                        dummys[i + j[0]] = Symbol('C_%s' %(i + j[0]))
+                        unknowns.append(dummys[i + j[0]])
+
+                    if j[1] <= i:
+                        eq += dict1[j].subs(n, i) * dummys[i + j[0]]
+
+                eqs.append(eq)
+
+            # solve the system of equations formed
+            soleqs = solve(eqs, *unknowns)
+
+            if isinstance(soleqs, dict):
+
+                for i in range(len(u0), order):
+
+                    if i not in dummys:
+                        dummys[i] = Symbol('C_%s' %i)
+
+                    if dummys[i] in soleqs:
+                        u0.append(soleqs[dummys[i]])
+
+                    else:
+                        u0.append(dummys[i])
+
+                if lb:
+                    return [(HolonomicSequence(sol, u0), smallest_n)]
+                return [HolonomicSequence(sol, u0)]
+
+            for i in range(len(u0), order):
+
+                if i not in dummys:
+                    dummys[i] = Symbol('C_%s' %i)
+
+                s = False
+                for j in soleqs:
+                    if dummys[i] in j:
+                        u0.append(j[dummys[i]])
+                        s = True
+                if not s:
+                    u0.append(dummys[i])
+
+        if lb:
+            return [(HolonomicSequence(sol, u0), smallest_n)]
+
+        return [HolonomicSequence(sol, u0)]
+
+    def _frobenius(self, lb=True):
+        # compute the roots of indicial equation
+        indicialroots = self._indicial()
+
+        reals = []
+        compl = []
+        for i in ordered(indicialroots.keys()):
+            if i.is_real:
+                reals.extend([i] * indicialroots[i])
+            else:
+                a, b = i.as_real_imag()
+                compl.extend([(i, a, b)] * indicialroots[i])
+
+        # sort the roots for a fixed ordering of solution
+        compl.sort(key=lambda x : x[1])
+        compl.sort(key=lambda x : x[2])
+        reals.sort()
+
+        # grouping the roots, roots differ by an integer are put in the same group.
+        grp = []
+
+        for i in reals:
+            if len(grp) == 0:
+                grp.append([i])
+                continue
+            for j in grp:
+                if int_valued(j[0] - i):
+                    j.append(i)
+                    break
+            else:
+                grp.append([i])
+
+        # True if none of the roots differ by an integer i.e.
+        # each element in group have only one member
+        independent = all(len(i) == 1 for i in grp)
+
+        allpos = all(i >= 0 for i in reals)
+        allint = all(int_valued(i) for i in reals)
+
+        # if initial conditions are provided
+        # then use them.
+        if self.is_singularics() == True:
+            rootstoconsider = []
+            for i in ordered(self.y0.keys()):
+                for j in ordered(indicialroots.keys()):
+                    if equal_valued(j, i):
+                        rootstoconsider.append(i)
+
+        elif allpos and allint:
+            rootstoconsider = [min(reals)]
+
+        elif independent:
+            rootstoconsider = [i[0] for i in grp] + [j[0] for j in compl]
+
+        elif not allint:
+            rootstoconsider = [i for i in reals if not int(i) == i]
+
+        elif not allpos:
+
+            if not self._have_init_cond() or S(self.y0[0]).is_finite ==  False:
+                rootstoconsider = [min(reals)]
+
+            else:
+                posroots = [i for i in reals if i >= 0]
+                rootstoconsider = [min(posroots)]
+
+        n = Symbol('n', integer=True)
+        dom = self.annihilator.parent.base.dom
+        R, _ = RecurrenceOperators(dom.old_poly_ring(n), 'Sn')
+
+        finalsol = []
+        char = ord('C')
+
+        for p in rootstoconsider:
+            dict1 = {}
+
+            for i, j in enumerate(self.annihilator.listofpoly):
+
+                listofdmp = j.all_coeffs()
+                degree = len(listofdmp) - 1
+
+                for k in range(degree + 1):
+                    coeff = listofdmp[degree - k]
+
+                    if coeff == 0:
+                        continue
+
+                    if (i - k, k - i) in dict1:
+                        dict1[(i - k, k - i)] += (dom.to_sympy(coeff) * rf(n - k + 1 + p, i))
+                    else:
+                        dict1[(i - k, k - i)] = (dom.to_sympy(coeff) * rf(n - k + 1 + p, i))
+
+            sol = []
+            keylist = [i[0] for i in dict1]
+            lower = min(keylist)
+            upper = max(keylist)
+            degree = max(i[1] for i in dict1)
+            degree2 = min(i[1] for i in dict1)
+
+            smallest_n = lower + degree
+            dummys = {}
+            eqs = []
+            unknowns = []
+
+            for j in range(lower, upper + 1):
+                if j in keylist:
+                    temp = sum((v.subs(n, n - lower)
+                               for k, v in dict1.items() if k[0] == j),
+                               start=S.Zero)
+                    sol.append(temp)
+                else:
+                    sol.append(S.Zero)
+
+            # the recurrence relation
+            sol = RecurrenceOperator(sol, R)
+
+            # computing the initial conditions for recurrence
+            order = sol.order
+            all_roots = roots(R.base.to_sympy(sol.listofpoly[-1]), n, filter='Z')
+            all_roots = all_roots.keys()
+
+            if all_roots:
+                max_root = max(all_roots) + 1
+                smallest_n = max(max_root, smallest_n)
+            order += smallest_n
+
+            u0 = []
+
+            if self.is_singularics() == True:
+                u0 = self.y0[p]
+
+            elif self.is_singularics() == False and p >= 0 and int(p) == p and len(rootstoconsider) == 1:
+                y0 = _extend_y0(self, order + int(p))
+                # u(n) = y^n(0)/factorial(n)
+                if len(y0) > int(p):
+                    u0 = [y0[i] / factorial(i) for i in range(int(p), len(y0))]
+
+            if len(u0) < order:
+
+                for i in range(degree2, degree):
+                    eq = S.Zero
+
+                    for j in dict1:
+                        if i + j[0] < 0:
+                            dummys[i + j[0]] = S.Zero
+
+                        elif i + j[0] < len(u0):
+                            dummys[i + j[0]] = u0[i + j[0]]
+
+                        elif not i + j[0] in dummys:
+                            letter = chr(char) + '_%s' %(i + j[0])
+                            dummys[i + j[0]] = Symbol(letter)
+                            unknowns.append(dummys[i + j[0]])
+
+                        if j[1] <= i:
+                            eq += dict1[j].subs(n, i) * dummys[i + j[0]]
+
+                    eqs.append(eq)
+
+                # solve the system of equations formed
+                soleqs = solve(eqs, *unknowns)
+
+                if isinstance(soleqs, dict):
+
+                    for i in range(len(u0), order):
+
+                        if i not in dummys:
+                            letter = chr(char) + '_%s' %i
+                            dummys[i] = Symbol(letter)
+
+                        if dummys[i] in soleqs:
+                            u0.append(soleqs[dummys[i]])
+
+                        else:
+                            u0.append(dummys[i])
+
+                    if lb:
+                        finalsol.append((HolonomicSequence(sol, u0), p, smallest_n))
+                        continue
+                    else:
+                        finalsol.append((HolonomicSequence(sol, u0), p))
+                        continue
+
+                for i in range(len(u0), order):
+
+                    if i not in dummys:
+                        letter = chr(char) + '_%s' %i
+                        dummys[i] = Symbol(letter)
+
+                    s = False
+                    for j in soleqs:
+                        if dummys[i] in j:
+                            u0.append(j[dummys[i]])
+                            s = True
+                    if not s:
+                        u0.append(dummys[i])
+            if lb:
+                finalsol.append((HolonomicSequence(sol, u0), p, smallest_n))
+
+            else:
+                finalsol.append((HolonomicSequence(sol, u0), p))
+            char += 1
+        return finalsol
+
+    def series(self, n=6, coefficient=False, order=True, _recur=None):
+        r"""
+        Finds the power series expansion of given holonomic function about :math:`x_0`.
+
+        Explanation
+        ===========
+
+        A list of series might be returned if :math:`x_0` is a regular point with
+        multiple roots of the indicial equation.
+
+        Examples
+        ========
+
+        >>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators
+        >>> from sympy import QQ
+        >>> from sympy import symbols
+        >>> x = symbols('x')
+        >>> R, Dx = DifferentialOperators(QQ.old_poly_ring(x),'Dx')
+        >>> HolonomicFunction(Dx - 1, x, 0, [1]).series()  # e^x
+        1 + x + x**2/2 + x**3/6 + x**4/24 + x**5/120 + O(x**6)
+        >>> HolonomicFunction(Dx**2 + 1, x, 0, [0, 1]).series(n=8)  # sin(x)
+        x - x**3/6 + x**5/120 - x**7/5040 + O(x**8)
+
+        See Also
+        ========
+
+        HolonomicFunction.to_sequence
+        """
+
+        if _recur is None:
+            recurrence = self.to_sequence()
+        else:
+            recurrence = _recur
+
+        if isinstance(recurrence, tuple) and len(recurrence) == 2:
+            recurrence = recurrence[0]
+            constantpower = 0
+        elif isinstance(recurrence, tuple) and len(recurrence) == 3:
+            constantpower = recurrence[1]
+            recurrence = recurrence[0]
+
+        elif len(recurrence) == 1 and len(recurrence[0]) == 2:
+            recurrence = recurrence[0][0]
+            constantpower = 0
+        elif len(recurrence) == 1 and len(recurrence[0]) == 3:
+            constantpower = recurrence[0][1]
+            recurrence = recurrence[0][0]
+        else:
+            return [self.series(_recur=i) for i in recurrence]
+
+        n = n - int(constantpower)
+        l = len(recurrence.u0) - 1
+        k = recurrence.recurrence.order
+        x = self.x
+        x0 = self.x0
+        seq_dmp = recurrence.recurrence.listofpoly
+        R = recurrence.recurrence.parent.base
+        K = R.get_field()
+        seq = [K.new(j.to_list()) for j in seq_dmp]
+        sub = [-seq[i] / seq[k] for i in range(k)]
+        sol = list(recurrence.u0)
+
+        if l + 1 < n:
+            # use the initial conditions to find the next term
+            for i in range(l + 1 - k, n - k):
+                coeff = sum((DMFsubs(sub[j], i) * sol[i + j]
+                            for j in range(k) if i + j >= 0), start=S.Zero)
+                sol.append(coeff)
+
+        if coefficient:
+            return sol
+
+        ser = sum((x**(i + constantpower) * j for i, j in enumerate(sol)),
+                  start=S.Zero)
+        if order:
+            ser += Order(x**(n + int(constantpower)), x)
+        if x0 != 0:
+            return ser.subs(x, x - x0)
+        return ser
+
+    def _indicial(self):
+        """
+        Computes roots of the Indicial equation.
+        """
+
+        if self.x0 != 0:
+            return self.shift_x(self.x0)._indicial()
+
+        list_coeff = self.annihilator.listofpoly
+        R = self.annihilator.parent.base
+        x = self.x
+        s = R.zero
+        y = R.one
+
+        def _pole_degree(poly):
+            root_all = roots(R.to_sympy(poly), x, filter='Z')
+            if 0 in root_all.keys():
+                return root_all[0]
+            else:
+                return 0
+
+        degree = max(j.degree() for j in list_coeff)
+        inf = 10 * (max(1, degree) + max(1, self.annihilator.order))
+
+        deg = lambda q: inf if q.is_zero else _pole_degree(q)
+        b = min(deg(q) - j for j, q in enumerate(list_coeff))
+
+        for i, j in enumerate(list_coeff):
+            listofdmp = j.all_coeffs()
+            degree = len(listofdmp) - 1
+            if 0 <= i + b <= degree:
+                s = s + listofdmp[degree - i - b] * y
+            y *= R.from_sympy(x - i)
+
+        return roots(R.to_sympy(s), x)
+
+    def evalf(self, points, method='RK4', h=0.05, derivatives=False):
+        r"""
+        Finds numerical value of a holonomic function using numerical methods.
+        (RK4 by default). A set of points (real or complex) must be provided
+        which will be the path for the numerical integration.
+
+        Explanation
+        ===========
+
+        The path should be given as a list :math:`[x_1, x_2, \dots x_n]`. The numerical
+        values will be computed at each point in this order
+        :math:`x_1 \rightarrow x_2 \rightarrow x_3 \dots \rightarrow x_n`.
+
+        Returns values of the function at :math:`x_1, x_2, \dots x_n` in a list.
+
+        Examples
+        ========
+
+        >>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators
+        >>> from sympy import QQ
+        >>> from sympy import symbols
+        >>> x = symbols('x')
+        >>> R, Dx = DifferentialOperators(QQ.old_poly_ring(x),'Dx')
+
+        A straight line on the real axis from (0 to 1)
+
+        >>> r = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1]
+
+        Runge-Kutta 4th order on e^x from 0.1 to 1.
+        Exact solution at 1 is 2.71828182845905
+
+        >>> HolonomicFunction(Dx - 1, x, 0, [1]).evalf(r)
+        [1.10517083333333, 1.22140257085069, 1.34985849706254, 1.49182424008069,
+        1.64872063859684, 1.82211796209193, 2.01375162659678, 2.22553956329232,
+        2.45960141378007, 2.71827974413517]
+
+        Euler's method for the same
+
+        >>> HolonomicFunction(Dx - 1, x, 0, [1]).evalf(r, method='Euler')
+        [1.1, 1.21, 1.331, 1.4641, 1.61051, 1.771561, 1.9487171, 2.14358881,
+        2.357947691, 2.5937424601]
+
+        One can also observe that the value obtained using Runge-Kutta 4th order
+        is much more accurate than Euler's method.
+        """
+
+        from sympy.holonomic.numerical import _evalf
+        lp = False
+
+        # if a point `b` is given instead of a mesh
+        if not hasattr(points, "__iter__"):
+            lp = True
+            b = S(points)
+            if self.x0 == b:
+                return _evalf(self, [b], method=method, derivatives=derivatives)[-1]
+
+            if not b.is_Number:
+                raise NotImplementedError
+
+            a = self.x0
+            if a > b:
+                h = -h
+            n = int((b - a) / h)
+            points = [a + h]
+            for i in range(n - 1):
+                points.append(points[-1] + h)
+
+        for i in roots(self.annihilator.parent.base.to_sympy(self.annihilator.listofpoly[-1]), self.x):
+            if i == self.x0 or i in points:
+                raise SingularityError(self, i)
+
+        if lp:
+            return _evalf(self, points, method=method, derivatives=derivatives)[-1]
+        return _evalf(self, points, method=method, derivatives=derivatives)
+
+    def change_x(self, z):
+        """
+        Changes only the variable of Holonomic Function, for internal
+        purposes. For composition use HolonomicFunction.composition()
+        """
+
+        dom = self.annihilator.parent.base.dom
+        R = dom.old_poly_ring(z)
+        parent, _ = DifferentialOperators(R, 'Dx')
+        sol = [R(j.to_list()) for j in self.annihilator.listofpoly]
+        sol =  DifferentialOperator(sol, parent)
+        return HolonomicFunction(sol, z, self.x0, self.y0)
+
+    def shift_x(self, a):
+        """
+        Substitute `x + a` for `x`.
+        """
+
+        x = self.x
+        listaftershift = self.annihilator.listofpoly
+        base = self.annihilator.parent.base
+
+        sol = [base.from_sympy(base.to_sympy(i).subs(x, x + a)) for i in listaftershift]
+        sol = DifferentialOperator(sol, self.annihilator.parent)
+        x0 = self.x0 - a
+        if not self._have_init_cond():
+            return HolonomicFunction(sol, x)
+        return HolonomicFunction(sol, x, x0, self.y0)
+
+    def to_hyper(self, as_list=False, _recur=None):
+        r"""
+        Returns a hypergeometric function (or linear combination of them)
+        representing the given holonomic function.
+
+        Explanation
+        ===========
+
+        Returns an answer of the form:
+        `a_1 \cdot x^{b_1} \cdot{hyper()} + a_2 \cdot x^{b_2} \cdot{hyper()} \dots`
+
+        This is very useful as one can now use ``hyperexpand`` to find the
+        symbolic expressions/functions.
+
+        Examples
+        ========
+
+        >>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators
+        >>> from sympy import ZZ
+        >>> from sympy import symbols
+        >>> x = symbols('x')
+        >>> R, Dx = DifferentialOperators(ZZ.old_poly_ring(x),'Dx')
+        >>> # sin(x)
+        >>> HolonomicFunction(Dx**2 + 1, x, 0, [0, 1]).to_hyper()
+        x*hyper((), (3/2,), -x**2/4)
+        >>> # exp(x)
+        >>> HolonomicFunction(Dx - 1, x, 0, [1]).to_hyper()
+        hyper((), (), x)
+
+        See Also
+        ========
+
+        from_hyper, from_meijerg
+        """
+
+        if _recur is None:
+            recurrence = self.to_sequence()
+        else:
+            recurrence = _recur
+
+        if isinstance(recurrence, tuple) and len(recurrence) == 2:
+            smallest_n = recurrence[1]
+            recurrence = recurrence[0]
+            constantpower = 0
+        elif isinstance(recurrence, tuple) and len(recurrence) == 3:
+            smallest_n = recurrence[2]
+            constantpower = recurrence[1]
+            recurrence = recurrence[0]
+        elif len(recurrence) == 1 and len(recurrence[0]) == 2:
+            smallest_n = recurrence[0][1]
+            recurrence = recurrence[0][0]
+            constantpower = 0
+        elif len(recurrence) == 1 and len(recurrence[0]) == 3:
+            smallest_n = recurrence[0][2]
+            constantpower = recurrence[0][1]
+            recurrence = recurrence[0][0]
+        else:
+            sol = self.to_hyper(as_list=as_list, _recur=recurrence[0])
+            for i in recurrence[1:]:
+                sol += self.to_hyper(as_list=as_list, _recur=i)
+            return sol
+
+        u0 = recurrence.u0
+        r = recurrence.recurrence
+        x = self.x
+        x0 = self.x0
+
+        # order of the recurrence relation
+        m = r.order
+
+        # when no recurrence exists, and the power series have finite terms
+        if m == 0:
+            nonzeroterms = roots(r.parent.base.to_sympy(r.listofpoly[0]), recurrence.n, filter='R')
+
+            sol = S.Zero
+            for j, i in enumerate(nonzeroterms):
+
+                if i < 0 or not int_valued(i):
+                    continue
+
+                i = int(i)
+                if i < len(u0):
+                    if isinstance(u0[i], (PolyElement, FracElement)):
+                        u0[i] = u0[i].as_expr()
+                    sol += u0[i] * x**i
+
+                else:
+                    sol += Symbol('C_%s' %j) * x**i
+
+            if isinstance(sol, (PolyElement, FracElement)):
+                sol = sol.as_expr() * x**constantpower
+            else:
+                sol = sol * x**constantpower
+            if as_list:
+                if x0 != 0:
+                    return [(sol.subs(x, x - x0), )]
+                return [(sol, )]
+            if x0 != 0:
+                return sol.subs(x, x - x0)
+            return sol
+
+        if smallest_n + m > len(u0):
+            raise NotImplementedError("Can't compute sufficient Initial Conditions")
+
+        # check if the recurrence represents a hypergeometric series
+        if any(i != r.parent.base.zero for i in r.listofpoly[1:-1]):
+            raise NotHyperSeriesError(self, self.x0)
+
+        a = r.listofpoly[0]
+        b = r.listofpoly[-1]
+
+        # the constant multiple of argument of hypergeometric function
+        if isinstance(a.LC(), (PolyElement, FracElement)):
+            c = - (S(a.LC().as_expr()) * m**(a.degree())) / (S(b.LC().as_expr()) * m**(b.degree()))
+        else:
+            c = - (S(a.LC()) * m**(a.degree())) / (S(b.LC()) * m**(b.degree()))
+
+        sol = 0
+
+        arg1 = roots(r.parent.base.to_sympy(a), recurrence.n)
+        arg2 = roots(r.parent.base.to_sympy(b), recurrence.n)
+
+        # iterate through the initial conditions to find
+        # the hypergeometric representation of the given
+        # function.
+        # The answer will be a linear combination
+        # of different hypergeometric series which satisfies
+        # the recurrence.
+        if as_list:
+            listofsol = []
+        for i in range(smallest_n + m):
+
+            # if the recurrence relation doesn't hold for `n = i`,
+            # then a Hypergeometric representation doesn't exist.
+            # add the algebraic term a * x**i to the solution,
+            # where a is u0[i]
+            if i < smallest_n:
+                if as_list:
+                    listofsol.append(((S(u0[i]) * x**(i+constantpower)).subs(x, x-x0), ))
+                else:
+                    sol += S(u0[i]) * x**i
+                continue
+
+            # if the coefficient u0[i] is zero, then the
+            # independent hypergeomtric series starting with
+            # x**i is not a part of the answer.
+            if S(u0[i]) == 0:
+                continue
+
+            ap = []
+            bq = []
+
+            # substitute m * n + i for n
+            for k in ordered(arg1.keys()):
+                ap.extend([nsimplify((i - k) / m)] * arg1[k])
+
+            for k in ordered(arg2.keys()):
+                bq.extend([nsimplify((i - k) / m)] * arg2[k])
+
+            # convention of (k + 1) in the denominator
+            if 1 in bq:
+                bq.remove(1)
+            else:
+                ap.append(1)
+            if as_list:
+                listofsol.append(((S(u0[i])*x**(i+constantpower)).subs(x, x-x0), (hyper(ap, bq, c*x**m)).subs(x, x-x0)))
+            else:
+                sol += S(u0[i]) * hyper(ap, bq, c * x**m) * x**i
+        if as_list:
+            return listofsol
+        sol = sol * x**constantpower
+        if x0 != 0:
+            return sol.subs(x, x - x0)
+
+        return sol
+
+    def to_expr(self):
+        """
+        Converts a Holonomic Function back to elementary functions.
+
+        Examples
+        ========
+
+        >>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators
+        >>> from sympy import ZZ
+        >>> from sympy import symbols, S
+        >>> x = symbols('x')
+        >>> R, Dx = DifferentialOperators(ZZ.old_poly_ring(x),'Dx')
+        >>> HolonomicFunction(x**2*Dx**2 + x*Dx + (x**2 - 1), x, 0, [0, S(1)/2]).to_expr()
+        besselj(1, x)
+        >>> HolonomicFunction((1 + x)*Dx**3 + Dx**2, x, 0, [1, 1, 1]).to_expr()
+        x*log(x + 1) + log(x + 1) + 1
+
+        """
+
+        return hyperexpand(self.to_hyper()).simplify()
+
+    def change_ics(self, b, lenics=None):
+        """
+        Changes the point `x0` to ``b`` for initial conditions.
+
+        Examples
+        ========
+
+        >>> from sympy.holonomic import expr_to_holonomic
+        >>> from sympy import symbols, sin, exp
+        >>> x = symbols('x')
+
+        >>> expr_to_holonomic(sin(x)).change_ics(1)
+        HolonomicFunction((1) + (1)*Dx**2, x, 1, [sin(1), cos(1)])
+
+        >>> expr_to_holonomic(exp(x)).change_ics(2)
+        HolonomicFunction((-1) + (1)*Dx, x, 2, [exp(2)])
+        """
+
+        symbolic = True
+
+        if lenics is None and len(self.y0) > self.annihilator.order:
+            lenics = len(self.y0)
+        dom = self.annihilator.parent.base.domain
+
+        try:
+            sol = expr_to_holonomic(self.to_expr(), x=self.x, x0=b, lenics=lenics, domain=dom)
+        except (NotPowerSeriesError, NotHyperSeriesError):
+            symbolic = False
+
+        if symbolic and sol.x0 == b:
+            return sol
+
+        y0 = self.evalf(b, derivatives=True)
+        return HolonomicFunction(self.annihilator, self.x, b, y0)
+
+    def to_meijerg(self):
+        """
+        Returns a linear combination of Meijer G-functions.
+
+        Examples
+        ========
+
+        >>> from sympy.holonomic import expr_to_holonomic
+        >>> from sympy import sin, cos, hyperexpand, log, symbols
+        >>> x = symbols('x')
+        >>> hyperexpand(expr_to_holonomic(cos(x) + sin(x)).to_meijerg())
+        sin(x) + cos(x)
+        >>> hyperexpand(expr_to_holonomic(log(x)).to_meijerg()).simplify()
+        log(x)
+
+        See Also
+        ========
+
+        to_hyper
+        """
+
+        # convert to hypergeometric first
+        rep = self.to_hyper(as_list=True)
+        sol = S.Zero
+
+        for i in rep:
+            if len(i) == 1:
+                sol += i[0]
+
+            elif len(i) == 2:
+                sol += i[0] * _hyper_to_meijerg(i[1])
+
+        return sol
+
+
+def from_hyper(func, x0=0, evalf=False):
+    r"""
+    Converts a hypergeometric function to holonomic.
+    ``func`` is the Hypergeometric Function and ``x0`` is the point at
+    which initial conditions are required.
+
+    Examples
+    ========
+
+    >>> from sympy.holonomic.holonomic import from_hyper
+    >>> from sympy import symbols, hyper, S
+    >>> x = symbols('x')
+    >>> from_hyper(hyper([], [S(3)/2], x**2/4))
+    HolonomicFunction((-x) + (2)*Dx + (x)*Dx**2, x, 1, [sinh(1), -sinh(1) + cosh(1)])
+    """
+
+    a = func.ap
+    b = func.bq
+    z = func.args[2]
+    x = z.atoms(Symbol).pop()
+    R, Dx = DifferentialOperators(QQ.old_poly_ring(x), 'Dx')
+
+    # generalized hypergeometric differential equation
+    xDx = x*Dx
+    r1 = 1
+    for ai in a:  # XXX gives sympify error if Mul is used with list of all factors
+        r1 *= xDx + ai
+    xDx_1 = xDx - 1
+    # r2 = Mul(*([Dx] + [xDx_1 + bi for bi in b]))  # XXX gives sympify error
+    r2 = Dx
+    for bi in b:
+        r2 *= xDx_1 + bi
+    sol = r1 - r2
+
+    simp = hyperexpand(func)
+
+    if simp in (Infinity, NegativeInfinity):
+        return HolonomicFunction(sol, x).composition(z)
+
+    # if the function is known symbolically
+    if not isinstance(simp, hyper):
+        y0 = _find_conditions(simp, x, x0, sol.order, use_limit=False)
+        while not y0:
+            # if values don't exist at 0, then try to find initial
+            # conditions at 1. If it doesn't exist at 1 too then
+            # try 2 and so on.
+            x0 += 1
+            y0 = _find_conditions(simp, x, x0, sol.order, use_limit=False)
+
+        return HolonomicFunction(sol, x).composition(z, x0, y0)
+
+    if isinstance(simp, hyper):
+        x0 = 1
+        # use evalf if the function can't be simplified
+        y0 = _find_conditions(simp, x, x0, sol.order, evalf, use_limit=False)
+        while not y0:
+            x0 += 1
+            y0 = _find_conditions(simp, x, x0, sol.order, evalf, use_limit=False)
+        return HolonomicFunction(sol, x).composition(z, x0, y0)
+
+    return HolonomicFunction(sol, x).composition(z)
+
+
+def from_meijerg(func, x0=0, evalf=False, initcond=True, domain=QQ):
+    """
+    Converts a Meijer G-function to Holonomic.
+    ``func`` is the G-Function and ``x0`` is the point at
+    which initial conditions are required.
+
+    Examples
+    ========
+
+    >>> from sympy.holonomic.holonomic import from_meijerg
+    >>> from sympy import symbols, meijerg, S
+    >>> x = symbols('x')
+    >>> from_meijerg(meijerg(([], []), ([S(1)/2], [0]), x**2/4))
+    HolonomicFunction((1) + (1)*Dx**2, x, 0, [0, 1/sqrt(pi)])
+    """
+
+    a = func.ap
+    b = func.bq
+    n = len(func.an)
+    m = len(func.bm)
+    p = len(a)
+    z = func.args[2]
+    x = z.atoms(Symbol).pop()
+    R, Dx = DifferentialOperators(domain.old_poly_ring(x), 'Dx')
+
+    # compute the differential equation satisfied by the
+    # Meijer G-function.
+    xDx = x*Dx
+    xDx1 = xDx + 1
+    r1 = x*(-1)**(m + n - p)
+    for ai in a:  # XXX gives sympify error if args given in list
+        r1 *= xDx1 - ai
+    # r2 = Mul(*[xDx - bi for bi in b])  # gives sympify error
+    r2 = 1
+    for bi in b:
+        r2 *= xDx - bi
+    sol = r1 - r2
+
+    if not initcond:
+        return HolonomicFunction(sol, x).composition(z)
+
+    simp = hyperexpand(func)
+
+    if simp in (Infinity, NegativeInfinity):
+        return HolonomicFunction(sol, x).composition(z)
+
+    # computing initial conditions
+    if not isinstance(simp, meijerg):
+        y0 = _find_conditions(simp, x, x0, sol.order, use_limit=False)
+        while not y0:
+            x0 += 1
+            y0 = _find_conditions(simp, x, x0, sol.order, use_limit=False)
+
+        return HolonomicFunction(sol, x).composition(z, x0, y0)
+
+    if isinstance(simp, meijerg):
+        x0 = 1
+        y0 = _find_conditions(simp, x, x0, sol.order, evalf, use_limit=False)
+        while not y0:
+            x0 += 1
+            y0 = _find_conditions(simp, x, x0, sol.order, evalf, use_limit=False)
+
+        return HolonomicFunction(sol, x).composition(z, x0, y0)
+
+    return HolonomicFunction(sol, x).composition(z)
+
+
+x_1 = Dummy('x_1')
+_lookup_table = None
+domain_for_table = None
+from sympy.integrals.meijerint import _mytype
+
+
+def expr_to_holonomic(func, x=None, x0=0, y0=None, lenics=None, domain=None, initcond=True):
+    """
+    Converts a function or an expression to a holonomic function.
+
+    Parameters
+    ==========
+
+    func:
+        The expression to be converted.
+    x:
+        variable for the function.
+    x0:
+        point at which initial condition must be computed.
+    y0:
+        One can optionally provide initial condition if the method
+        is not able to do it automatically.
+    lenics:
+        Number of terms in the initial condition. By default it is
+        equal to the order of the annihilator.
+    domain:
+        Ground domain for the polynomials in ``x`` appearing as coefficients
+        in the annihilator.
+    initcond:
+        Set it false if you do not want the initial conditions to be computed.
+
+    Examples
+    ========
+
+    >>> from sympy.holonomic.holonomic import expr_to_holonomic
+    >>> from sympy import sin, exp, symbols
+    >>> x = symbols('x')
+    >>> expr_to_holonomic(sin(x))
+    HolonomicFunction((1) + (1)*Dx**2, x, 0, [0, 1])
+    >>> expr_to_holonomic(exp(x))
+    HolonomicFunction((-1) + (1)*Dx, x, 0, [1])
+
+    See Also
+    ========
+
+    sympy.integrals.meijerint._rewrite1, _convert_poly_rat_alg, _create_table
+    """
+    func = sympify(func)
+    syms = func.free_symbols
+
+    if not x:
+        if len(syms) == 1:
+            x= syms.pop()
+        else:
+            raise ValueError("Specify the variable for the function")
+    elif x in syms:
+        syms.remove(x)
+
+    extra_syms = list(syms)
+
+    if domain is None:
+        if func.has(Float):
+            domain = RR
+        else:
+            domain = QQ
+        if len(extra_syms) != 0:
+            domain = domain[extra_syms].get_field()
+
+    # try to convert if the function is polynomial or rational
+    solpoly = _convert_poly_rat_alg(func, x, x0=x0, y0=y0, lenics=lenics, domain=domain, initcond=initcond)
+    if solpoly:
+        return solpoly
+
+    # create the lookup table
+    global _lookup_table, domain_for_table
+    if not _lookup_table:
+        domain_for_table = domain
+        _lookup_table = {}
+        _create_table(_lookup_table, domain=domain)
+    elif domain != domain_for_table:
+        domain_for_table = domain
+        _lookup_table = {}
+        _create_table(_lookup_table, domain=domain)
+
+    # use the table directly to convert to Holonomic
+    if func.is_Function:
+        f = func.subs(x, x_1)
+        t = _mytype(f, x_1)
+        if t in _lookup_table:
+            l = _lookup_table[t]
+            sol = l[0][1].change_x(x)
+        else:
+            sol = _convert_meijerint(func, x, initcond=False, domain=domain)
+            if not sol:
+                raise NotImplementedError
+            if y0:
+                sol.y0 = y0
+            if y0 or not initcond:
+                sol.x0 = x0
+                return sol
+            if not lenics:
+                lenics = sol.annihilator.order
+            _y0 = _find_conditions(func, x, x0, lenics)
+            while not _y0:
+                x0 += 1
+                _y0 = _find_conditions(func, x, x0, lenics)
+            return HolonomicFunction(sol.annihilator, x, x0, _y0)
+
+        if y0 or not initcond:
+            sol = sol.composition(func.args[0])
+            if y0:
+                sol.y0 = y0
+            sol.x0 = x0
+            return sol
+        if not lenics:
+            lenics = sol.annihilator.order
+
+        _y0 = _find_conditions(func, x, x0, lenics)
+        while not _y0:
+            x0 += 1
+            _y0 = _find_conditions(func, x, x0, lenics)
+        return sol.composition(func.args[0], x0, _y0)
+
+    # iterate through the expression recursively
+    args = func.args
+    f = func.func
+    sol = expr_to_holonomic(args[0], x=x, initcond=False, domain=domain)
+
+    if f is Add:
+        for i in range(1, len(args)):
+            sol += expr_to_holonomic(args[i], x=x, initcond=False, domain=domain)
+
+    elif f is Mul:
+        for i in range(1, len(args)):
+            sol *= expr_to_holonomic(args[i], x=x, initcond=False, domain=domain)
+
+    elif f is Pow:
+        sol = sol**args[1]
+    sol.x0 = x0
+    if not sol:
+        raise NotImplementedError
+    if y0:
+        sol.y0 = y0
+    if y0 or not initcond:
+        return sol
+    if sol.y0:
+        return sol
+    if not lenics:
+        lenics = sol.annihilator.order
+    if sol.annihilator.is_singular(x0):
+        r = sol._indicial()
+        l = list(r)
+        if len(r) == 1 and r[l[0]] == S.One:
+            r = l[0]
+            g = func / (x - x0)**r
+            singular_ics = _find_conditions(g, x, x0, lenics)
+            singular_ics = [j / factorial(i) for i, j in enumerate(singular_ics)]
+            y0 = {r:singular_ics}
+            return HolonomicFunction(sol.annihilator, x, x0, y0)
+
+    _y0 = _find_conditions(func, x, x0, lenics)
+    while not _y0:
+        x0 += 1
+        _y0 = _find_conditions(func, x, x0, lenics)
+
+    return HolonomicFunction(sol.annihilator, x, x0, _y0)
+
+
+## Some helper functions ##
+
+def _normalize(list_of, parent, negative=True):
+    """
+    Normalize a given annihilator
+    """
+
+    num = []
+    denom = []
+    base = parent.base
+    K = base.get_field()
+    lcm_denom = base.from_sympy(S.One)
+    list_of_coeff = []
+
+    # convert polynomials to the elements of associated
+    # fraction field
+    for i, j in enumerate(list_of):
+        if isinstance(j, base.dtype):
+            list_of_coeff.append(K.new(j.to_list()))
+        elif not isinstance(j, K.dtype):
+            list_of_coeff.append(K.from_sympy(sympify(j)))
+        else:
+            list_of_coeff.append(j)
+
+        # corresponding numerators of the sequence of polynomials
+        num.append(list_of_coeff[i].numer())
+
+        # corresponding denominators
+        denom.append(list_of_coeff[i].denom())
+
+    # lcm of denominators in the coefficients
+    for i in denom:
+        lcm_denom = i.lcm(lcm_denom)
+
+    if negative:
+        lcm_denom = -lcm_denom
+
+    lcm_denom = K.new(lcm_denom.to_list())
+
+    # multiply the coefficients with lcm
+    for i, j in enumerate(list_of_coeff):
+        list_of_coeff[i] = j * lcm_denom
+
+    gcd_numer = base((list_of_coeff[-1].numer() / list_of_coeff[-1].denom()).to_list())
+
+    # gcd of numerators in the coefficients
+    for i in num:
+        gcd_numer = i.gcd(gcd_numer)
+
+    gcd_numer = K.new(gcd_numer.to_list())
+
+    # divide all the coefficients by the gcd
+    for i, j in enumerate(list_of_coeff):
+        frac_ans = j / gcd_numer
+        list_of_coeff[i] = base((frac_ans.numer() / frac_ans.denom()).to_list())
+
+    return DifferentialOperator(list_of_coeff, parent)
+
+
+def _derivate_diff_eq(listofpoly, K):
+    """
+    Let a differential equation a0(x)y(x) + a1(x)y'(x) + ... = 0
+    where a0, a1,... are polynomials or rational functions. The function
+    returns b0, b1, b2... such that the differential equation
+    b0(x)y(x) + b1(x)y'(x) +... = 0 is formed after differentiating the
+    former equation.
+    """
+
+    sol = []
+    a = len(listofpoly) - 1
+    sol.append(DMFdiff(listofpoly[0], K))
+
+    for i, j in enumerate(listofpoly[1:]):
+        sol.append(DMFdiff(j, K) + listofpoly[i])
+
+    sol.append(listofpoly[a])
+    return sol
+
+
+def _hyper_to_meijerg(func):
+    """
+    Converts a `hyper` to meijerg.
+    """
+    ap = func.ap
+    bq = func.bq
+
+    if any(i <= 0 and int(i) == i for i in ap):
+        return hyperexpand(func)
+
+    z = func.args[2]
+
+    # parameters of the `meijerg` function.
+    an = (1 - i for i in ap)
+    anp = ()
+    bm = (S.Zero, )
+    bmq = (1 - i for i in bq)
+
+    k = S.One
+
+    for i in bq:
+        k = k * gamma(i)
+
+    for i in ap:
+        k = k / gamma(i)
+
+    return k * meijerg(an, anp, bm, bmq, -z)
+
+
+def _add_lists(list1, list2):
+    """Takes polynomial sequences of two annihilators a and b and returns
+    the list of polynomials of sum of a and b.
+    """
+    if len(list1) <= len(list2):
+        sol = [a + b for a, b in zip(list1, list2)] + list2[len(list1):]
+    else:
+        sol = [a + b for a, b in zip(list1, list2)] + list1[len(list2):]
+    return sol
+
+
+def _extend_y0(Holonomic, n):
+    """
+    Tries to find more initial conditions by substituting the initial
+    value point in the differential equation.
+    """
+
+    if Holonomic.annihilator.is_singular(Holonomic.x0) or Holonomic.is_singularics() == True:
+        return Holonomic.y0
+
+    annihilator = Holonomic.annihilator
+    a = annihilator.order
+
+    listofpoly = []
+
+    y0 = Holonomic.y0
+    R = annihilator.parent.base
+    K = R.get_field()
+
+    for j in annihilator.listofpoly:
+        if isinstance(j, annihilator.parent.base.dtype):
+            listofpoly.append(K.new(j.to_list()))
+
+    if len(y0) < a or n <= len(y0):
+        return y0
+    list_red = [-listofpoly[i] / listofpoly[a]
+                for i in range(a)]
+    y1 = y0[:min(len(y0), a)]
+    for _ in range(n - a):
+        sol = 0
+        for a, b in zip(y1, list_red):
+            r = DMFsubs(b, Holonomic.x0)
+            if not getattr(r, 'is_finite', True):
+                return y0
+            if isinstance(r, (PolyElement, FracElement)):
+                r = r.as_expr()
+            sol += a * r
+        y1.append(sol)
+        list_red = _derivate_diff_eq(list_red, K)
+    return y0 + y1[len(y0):]
+
+
+def DMFdiff(frac, K):
+    # differentiate a DMF object represented as p/q
+    if not isinstance(frac, DMF):
+        return frac.diff()
+
+    p = K.numer(frac)
+    q = K.denom(frac)
+    sol_num = - p * q.diff() + q * p.diff()
+    sol_denom = q**2
+    return K((sol_num.to_list(), sol_denom.to_list()))
+
+
+def DMFsubs(frac, x0, mpm=False):
+    # substitute the point x0 in DMF object of the form p/q
+    if not isinstance(frac, DMF):
+        return frac
+
+    p = frac.num
+    q = frac.den
+    sol_p = S.Zero
+    sol_q = S.Zero
+
+    if mpm:
+        from mpmath import mp
+
+    for i, j in enumerate(reversed(p)):
+        if mpm:
+            j = sympify(j)._to_mpmath(mp.prec)
+        sol_p += j * x0**i
+
+    for i, j in enumerate(reversed(q)):
+        if mpm:
+            j = sympify(j)._to_mpmath(mp.prec)
+        sol_q += j * x0**i
+
+    if isinstance(sol_p, (PolyElement, FracElement)):
+        sol_p = sol_p.as_expr()
+    if isinstance(sol_q, (PolyElement, FracElement)):
+        sol_q = sol_q.as_expr()
+
+    return sol_p / sol_q
+
+
+def _convert_poly_rat_alg(func, x, x0=0, y0=None, lenics=None, domain=QQ, initcond=True):
+    """
+    Converts polynomials, rationals and algebraic functions to holonomic.
+    """
+
+    ispoly = func.is_polynomial()
+    if not ispoly:
+        israt = func.is_rational_function()
+    else:
+        israt = True
+
+    if not (ispoly or israt):
+        basepoly, ratexp = func.as_base_exp()
+        if basepoly.is_polynomial() and ratexp.is_Number:
+            if isinstance(ratexp, Float):
+                ratexp = nsimplify(ratexp)
+            m, n = ratexp.p, ratexp.q
+            is_alg = True
+        else:
+            is_alg = False
+    else:
+        is_alg = True
+
+    if not (ispoly or israt or is_alg):
+        return None
+
+    R = domain.old_poly_ring(x)
+    _, Dx = DifferentialOperators(R, 'Dx')
+
+    # if the function is constant
+    if not func.has(x):
+        return HolonomicFunction(Dx, x, 0, [func])
+
+    if ispoly:
+        # differential equation satisfied by polynomial
+        sol = func * Dx - func.diff(x)
+        sol = _normalize(sol.listofpoly, sol.parent, negative=False)
+        is_singular = sol.is_singular(x0)
+
+        # try to compute the conditions for singular points
+        if y0 is None and x0 == 0 and is_singular:
+            rep = R.from_sympy(func).to_list()
+            for i, j in enumerate(reversed(rep)):
+                if j == 0:
+                    continue
+                coeff = list(reversed(rep))[i:]
+                indicial = i
+                break
+            for i, j in enumerate(coeff):
+                if isinstance(j, (PolyElement, FracElement)):
+                    coeff[i] = j.as_expr()
+            y0 = {indicial: S(coeff)}
+
+    elif israt:
+        p, q = func.as_numer_denom()
+        # differential equation satisfied by rational
+        sol = p * q * Dx + p * q.diff(x) - q * p.diff(x)
+        sol = _normalize(sol.listofpoly, sol.parent, negative=False)
+
+    elif is_alg:
+        sol = n * (x / m) * Dx - 1
+        sol = HolonomicFunction(sol, x).composition(basepoly).annihilator
+        is_singular = sol.is_singular(x0)
+
+        # try to compute the conditions for singular points
+        if y0 is None and x0 == 0 and is_singular and \
+            (lenics is None or lenics <= 1):
+            rep = R.from_sympy(basepoly).to_list()
+            for i, j in enumerate(reversed(rep)):
+                if j == 0:
+                    continue
+                if isinstance(j, (PolyElement, FracElement)):
+                    j = j.as_expr()
+
+                coeff = S(j)**ratexp
+                indicial = S(i) * ratexp
+                break
+            if isinstance(coeff, (PolyElement, FracElement)):
+                coeff = coeff.as_expr()
+            y0 = {indicial: S([coeff])}
+
+    if y0 or not initcond:
+        return HolonomicFunction(sol, x, x0, y0)
+
+    if not lenics:
+        lenics = sol.order
+
+    if sol.is_singular(x0):
+        r = HolonomicFunction(sol, x, x0)._indicial()
+        l = list(r)
+        if len(r) == 1 and r[l[0]] == S.One:
+            r = l[0]
+            g = func / (x - x0)**r
+            singular_ics = _find_conditions(g, x, x0, lenics)
+            singular_ics = [j / factorial(i) for i, j in enumerate(singular_ics)]
+            y0 = {r:singular_ics}
+            return HolonomicFunction(sol, x, x0, y0)
+
+    y0 = _find_conditions(func, x, x0, lenics)
+    while not y0:
+        x0 += 1
+        y0 = _find_conditions(func, x, x0, lenics)
+
+    return HolonomicFunction(sol, x, x0, y0)
+
+
+def _convert_meijerint(func, x, initcond=True, domain=QQ):
+    args = meijerint._rewrite1(func, x)
+
+    if args:
+        fac, po, g, _ = args
+    else:
+        return None
+
+    # lists for sum of meijerg functions
+    fac_list = [fac * i[0] for i in g]
+    t = po.as_base_exp()
+    s = t[1] if t[0] == x else S.Zero
+    po_list = [s + i[1] for i in g]
+    G_list = [i[2] for i in g]
+
+    # finds meijerg representation of x**s * meijerg(a1 ... ap, b1 ... bq, z)
+    def _shift(func, s):
+        z = func.args[-1]
+        if z.has(I):
+            z = z.subs(exp_polar, exp)
+
+        d = z.collect(x, evaluate=False)
+        b = list(d)[0]
+        a = d[b]
+
+        t = b.as_base_exp()
+        b = t[1] if t[0] == x else S.Zero
+        r = s / b
+        an = (i + r for i in func.args[0][0])
+        ap = (i + r for i in func.args[0][1])
+        bm = (i + r for i in func.args[1][0])
+        bq = (i + r for i in func.args[1][1])
+
+        return a**-r, meijerg((an, ap), (bm, bq), z)
+
+    coeff, m = _shift(G_list[0], po_list[0])
+    sol = fac_list[0] * coeff * from_meijerg(m, initcond=initcond, domain=domain)
+
+    # add all the meijerg functions after converting to holonomic
+    for i in range(1, len(G_list)):
+        coeff, m = _shift(G_list[i], po_list[i])
+        sol += fac_list[i] * coeff * from_meijerg(m, initcond=initcond, domain=domain)
+
+    return sol
+
+
+def _create_table(table, domain=QQ):
+    """
+    Creates the look-up table. For a similar implementation
+    see meijerint._create_lookup_table.
+    """
+
+    def add(formula, annihilator, arg, x0=0, y0=()):
+        """
+        Adds a formula in the dictionary
+        """
+        table.setdefault(_mytype(formula, x_1), []).append((formula,
+            HolonomicFunction(annihilator, arg, x0, y0)))
+
+    R = domain.old_poly_ring(x_1)
+    _, Dx = DifferentialOperators(R, 'Dx')
+
+    # add some basic functions
+    add(sin(x_1), Dx**2 + 1, x_1, 0, [0, 1])
+    add(cos(x_1), Dx**2 + 1, x_1, 0, [1, 0])
+    add(exp(x_1), Dx - 1, x_1, 0, 1)
+    add(log(x_1), Dx + x_1*Dx**2, x_1, 1, [0, 1])
+
+    add(erf(x_1), 2*x_1*Dx + Dx**2, x_1, 0, [0, 2/sqrt(pi)])
+    add(erfc(x_1), 2*x_1*Dx + Dx**2, x_1, 0, [1, -2/sqrt(pi)])
+    add(erfi(x_1), -2*x_1*Dx + Dx**2, x_1, 0, [0, 2/sqrt(pi)])
+
+    add(sinh(x_1), Dx**2 - 1, x_1, 0, [0, 1])
+    add(cosh(x_1), Dx**2 - 1, x_1, 0, [1, 0])
+
+    add(sinc(x_1), x_1 + 2*Dx + x_1*Dx**2, x_1)
+
+    add(Si(x_1), x_1*Dx + 2*Dx**2 + x_1*Dx**3, x_1)
+    add(Ci(x_1), x_1*Dx + 2*Dx**2 + x_1*Dx**3, x_1)
+
+    add(Shi(x_1), -x_1*Dx + 2*Dx**2 + x_1*Dx**3, x_1)
+
+
+def _find_conditions(func, x, x0, order, evalf=False, use_limit=True):
+    y0 = []
+    for _ in range(order):
+        val = func.subs(x, x0)
+        if evalf:
+            val = val.evalf()
+        if use_limit and isinstance(val, NaN):
+            val = limit(func, x, x0)
+        if val.is_finite is False or isinstance(val, NaN):
+            return None
+        y0.append(val)
+        func = func.diff(x)
+    return y0

.venv/lib/python3.12/site-packages/sympy/holonomic/holonomicerrors.py

@@ -0,0 +1,49 @@
+""" Common Exceptions for `holonomic` module. """
+
+class BaseHolonomicError(Exception):
+
+    def new(self, *args):
+        raise NotImplementedError("abstract base class")
+
+class NotPowerSeriesError(BaseHolonomicError):
+
+    def __init__(self, holonomic, x0):
+        self.holonomic = holonomic
+        self.x0 = x0
+
+    def __str__(self):
+        s = 'A Power Series does not exists for '
+        s += str(self.holonomic)
+        s += ' about %s.' %self.x0
+        return s
+
+class NotHolonomicError(BaseHolonomicError):
+
+    def __init__(self, m):
+        self.m = m
+
+    def __str__(self):
+        return self.m
+
+class SingularityError(BaseHolonomicError):
+
+    def __init__(self, holonomic, x0):
+        self.holonomic = holonomic
+        self.x0 = x0
+
+    def __str__(self):
+        s = str(self.holonomic)
+        s += ' has a singularity at %s.' %self.x0
+        return s
+
+class NotHyperSeriesError(BaseHolonomicError):
+
+    def __init__(self, holonomic, x0):
+        self.holonomic = holonomic
+        self.x0 = x0
+
+    def __str__(self):
+        s = 'Power series expansion of '
+        s += str(self.holonomic)
+        s += ' about %s is not hypergeometric' %self.x0
+        return s

.venv/lib/python3.12/site-packages/sympy/holonomic/numerical.py

@@ -0,0 +1,98 @@
+"""Numerical Methods for Holonomic Functions"""
+
+from sympy.core.sympify import sympify
+from sympy.holonomic.holonomic import DMFsubs
+
+from mpmath import mp
+
+
+def _evalf(func, points, derivatives=False, method='RK4'):
+    """
+    Numerical methods for numerical integration along a given set of
+    points in the complex plane.
+    """
+
+    ann = func.annihilator
+    a = ann.order
+    R = ann.parent.base
+    K = R.get_field()
+
+    if method == 'Euler':
+        meth = _euler
+    else:
+        meth = _rk4
+
+    dmf = [K.new(j.to_list()) for j in ann.listofpoly]
+    red = [-dmf[i] / dmf[a] for i in range(a)]
+
+    y0 = func.y0
+    if len(y0) < a:
+        raise TypeError("Not Enough Initial Conditions")
+    x0 = func.x0
+    sol = [meth(red, x0, points[0], y0, a)]
+
+    for i, j in enumerate(points[1:]):
+        sol.append(meth(red, points[i], j, sol[-1], a))
+
+    if not derivatives:
+        return [sympify(i[0]) for i in sol]
+    else:
+        return sympify(sol)
+
+
+def _euler(red, x0, x1, y0, a):
+    """
+    Euler's method for numerical integration.
+    From x0 to x1 with initial values given at x0 as vector y0.
+    """
+
+    A = sympify(x0)._to_mpmath(mp.prec)
+    B = sympify(x1)._to_mpmath(mp.prec)
+    y_0 = [sympify(i)._to_mpmath(mp.prec) for i in y0]
+    h = B - A
+    f_0 = y_0[1:]
+    f_0_n = 0
+
+    for i in range(a):
+        f_0_n += sympify(DMFsubs(red[i], A, mpm=True))._to_mpmath(mp.prec) * y_0[i]
+    f_0.append(f_0_n)
+
+    return [y_0[i] + h * f_0[i] for i in range(a)]
+
+
+def _rk4(red, x0, x1, y0, a):
+    """
+    Runge-Kutta 4th order numerical method.
+    """
+
+    A = sympify(x0)._to_mpmath(mp.prec)
+    B = sympify(x1)._to_mpmath(mp.prec)
+    y_0 = [sympify(i)._to_mpmath(mp.prec) for i in y0]
+    h = B - A
+
+    f_0_n = 0
+    f_1_n = 0
+    f_2_n = 0
+    f_3_n = 0
+
+    f_0 = y_0[1:]
+    for i in range(a):
+        f_0_n += sympify(DMFsubs(red[i], A, mpm=True))._to_mpmath(mp.prec) * y_0[i]
+    f_0.append(f_0_n)
+
+    f_1 = [y_0[i] + f_0[i]*h/2 for i in range(1, a)]
+    for i in range(a):
+        f_1_n += sympify(DMFsubs(red[i], A + h/2, mpm=True))._to_mpmath(mp.prec) * (y_0[i] + f_0[i]*h/2)
+    f_1.append(f_1_n)
+
+    f_2 = [y_0[i] + f_1[i]*h/2 for i in range(1, a)]
+    for i in range(a):
+        f_2_n += sympify(DMFsubs(red[i], A + h/2, mpm=True))._to_mpmath(mp.prec) * (y_0[i] + f_1[i]*h/2)
+    f_2.append(f_2_n)
+
+    f_3 = [y_0[i] + f_2[i]*h for i in range(1, a)]
+    for i in range(a):
+        f_3_n += sympify(DMFsubs(red[i], A + h, mpm=True))._to_mpmath(mp.prec) * (y_0[i] + f_2[i]*h)
+    f_3.append(f_3_n)
+
+    return [y_0[i] + h*(f_0[i]+2*f_1[i]+2*f_2[i]+f_3[i])/6 for i in range(a)]

.venv/lib/python3.12/site-packages/sympy/holonomic/recurrence.py

@@ -0,0 +1,342 @@
+"""Recurrence Operators"""
+
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.printing import sstr
+from sympy.core.sympify import sympify
+
+
+def RecurrenceOperators(base, generator):
+    """
+    Returns an Algebra of Recurrence Operators and the operator for
+    shifting i.e. the `Sn` operator.
+    The first argument needs to be the base polynomial ring for the algebra
+    and the second argument must be a generator which can be either a
+    noncommutative Symbol or a string.
+
+    Examples
+    ========
+
+    >>> from sympy import ZZ
+    >>> from sympy import symbols
+    >>> from sympy.holonomic.recurrence import RecurrenceOperators
+    >>> n = symbols('n', integer=True)
+    >>> R, Sn = RecurrenceOperators(ZZ.old_poly_ring(n), 'Sn')
+    """
+
+    ring = RecurrenceOperatorAlgebra(base, generator)
+    return (ring, ring.shift_operator)
+
+
+class RecurrenceOperatorAlgebra:
+    """
+    A Recurrence Operator Algebra is a set of noncommutative polynomials
+    in intermediate `Sn` and coefficients in a base ring A. It follows the
+    commutation rule:
+    Sn * a(n) = a(n + 1) * Sn
+
+    This class represents a Recurrence Operator Algebra and serves as the parent ring
+    for Recurrence Operators.
+
+    Examples
+    ========
+
+    >>> from sympy import ZZ
+    >>> from sympy import symbols
+    >>> from sympy.holonomic.recurrence import RecurrenceOperators
+    >>> n = symbols('n', integer=True)
+    >>> R, Sn = RecurrenceOperators(ZZ.old_poly_ring(n), 'Sn')
+    >>> R
+    Univariate Recurrence Operator Algebra in intermediate Sn over the base ring
+    ZZ[n]
+
+    See Also
+    ========
+
+    RecurrenceOperator
+    """
+
+    def __init__(self, base, generator):
+        # the base ring for the algebra
+        self.base = base
+        # the operator representing shift i.e. `Sn`
+        self.shift_operator = RecurrenceOperator(
+            [base.zero, base.one], self)
+
+        if generator is None:
+            self.gen_symbol = symbols('Sn', commutative=False)
+        else:
+            if isinstance(generator, str):
+                self.gen_symbol = symbols(generator, commutative=False)
+            elif isinstance(generator, Symbol):
+                self.gen_symbol = generator
+
+    def __str__(self):
+        string = 'Univariate Recurrence Operator Algebra in intermediate '\
+            + sstr(self.gen_symbol) + ' over the base ring ' + \
+            (self.base).__str__()
+
+        return string
+
+    __repr__ = __str__
+
+    def __eq__(self, other):
+        if self.base == other.base and self.gen_symbol == other.gen_symbol:
+            return True
+        else:
+            return False
+
+
+def _add_lists(list1, list2):
+    if len(list1) <= len(list2):
+        sol = [a + b for a, b in zip(list1, list2)] + list2[len(list1):]
+    else:
+        sol = [a + b for a, b in zip(list1, list2)] + list1[len(list2):]
+    return sol
+
+
+class RecurrenceOperator:
+    """
+    The Recurrence Operators are defined by a list of polynomials
+    in the base ring and the parent ring of the Operator.
+
+    Explanation
+    ===========
+
+    Takes a list of polynomials for each power of Sn and the
+    parent ring which must be an instance of RecurrenceOperatorAlgebra.
+
+    A Recurrence Operator can be created easily using
+    the operator `Sn`. See examples below.
+
+    Examples
+    ========
+
+    >>> from sympy.holonomic.recurrence import RecurrenceOperator, RecurrenceOperators
+    >>> from sympy import ZZ
+    >>> from sympy import symbols
+    >>> n = symbols('n', integer=True)
+    >>> R, Sn = RecurrenceOperators(ZZ.old_poly_ring(n),'Sn')
+
+    >>> RecurrenceOperator([0, 1, n**2], R)
+    (1)Sn + (n**2)Sn**2
+
+    >>> Sn*n
+    (n + 1)Sn
+
+    >>> n*Sn*n + 1 - Sn**2*n
+    (1) + (n**2 + n)Sn + (-n - 2)Sn**2
+
+    See Also
+    ========
+
+    DifferentialOperatorAlgebra
+    """
+
+    _op_priority = 20
+
+    def __init__(self, list_of_poly, parent):
+        # the parent ring for this operator
+        # must be an RecurrenceOperatorAlgebra object
+        self.parent = parent
+        # sequence of polynomials in n for each power of Sn
+        # represents the operator
+        # convert the expressions into ring elements using from_sympy
+        if isinstance(list_of_poly, list):
+            for i, j in enumerate(list_of_poly):
+                if isinstance(j, int):
+                    list_of_poly[i] = self.parent.base.from_sympy(S(j))
+                elif not isinstance(j, self.parent.base.dtype):
+                    list_of_poly[i] = self.parent.base.from_sympy(j)
+
+            self.listofpoly = list_of_poly
+        self.order = len(self.listofpoly) - 1
+
+    def __mul__(self, other):
+        """
+        Multiplies two Operators and returns another
+        RecurrenceOperator instance using the commutation rule
+        Sn * a(n) = a(n + 1) * Sn
+        """
+
+        listofself = self.listofpoly
+        base = self.parent.base
+
+        if not isinstance(other, RecurrenceOperator):
+            if not isinstance(other, self.parent.base.dtype):
+                listofother = [self.parent.base.from_sympy(sympify(other))]
+
+            else:
+                listofother = [other]
+        else:
+            listofother = other.listofpoly
+        # multiply a polynomial `b` with a list of polynomials
+
+        def _mul_dmp_diffop(b, listofother):
+            if isinstance(listofother, list):
+                return [i * b for i in listofother]
+            return [b * listofother]
+
+        sol = _mul_dmp_diffop(listofself[0], listofother)
+
+        # compute Sn^i * b
+        def _mul_Sni_b(b):
+            sol = [base.zero]
+
+            if isinstance(b, list):
+                for i in b:
+                    j = base.to_sympy(i).subs(base.gens[0], base.gens[0] + S.One)
+                    sol.append(base.from_sympy(j))
+
+            else:
+                j = b.subs(base.gens[0], base.gens[0] + S.One)
+                sol.append(base.from_sympy(j))
+
+            return sol
+
+        for i in range(1, len(listofself)):
+            # find Sn^i * b in ith iteration
+            listofother = _mul_Sni_b(listofother)
+            # solution = solution + listofself[i] * (Sn^i * b)
+            sol = _add_lists(sol, _mul_dmp_diffop(listofself[i], listofother))
+
+        return RecurrenceOperator(sol, self.parent)
+
+    def __rmul__(self, other):
+        if not isinstance(other, RecurrenceOperator):
+
+            if isinstance(other, int):
+                other = S(other)
+
+            if not isinstance(other, self.parent.base.dtype):
+                other = (self.parent.base).from_sympy(other)
+
+            sol = [other * j for j in self.listofpoly]
+            return RecurrenceOperator(sol, self.parent)
+
+    def __add__(self, other):
+        if isinstance(other, RecurrenceOperator):
+
+            sol = _add_lists(self.listofpoly, other.listofpoly)
+            return RecurrenceOperator(sol, self.parent)
+
+        else:
+
+            if isinstance(other, int):
+                other = S(other)
+            list_self = self.listofpoly
+            if not isinstance(other, self.parent.base.dtype):
+                list_other = [((self.parent).base).from_sympy(other)]
+            else:
+                list_other = [other]
+            sol = [list_self[0] + list_other[0]] + list_self[1:]
+
+            return RecurrenceOperator(sol, self.parent)
+
+    __radd__ = __add__
+
+    def __sub__(self, other):
+        return self + (-1) * other
+
+    def __rsub__(self, other):
+        return (-1) * self + other
+
+    def __pow__(self, n):
+        if n == 1:
+            return self
+        result = RecurrenceOperator([self.parent.base.one], self.parent)
+        if n == 0:
+            return result
+        # if self is `Sn`
+        if self.listofpoly == self.parent.shift_operator.listofpoly:
+            sol = [self.parent.base.zero] * n + [self.parent.base.one]
+            return RecurrenceOperator(sol, self.parent)
+        x = self
+        while True:
+            if n % 2:
+                result *= x
+            n >>= 1
+            if not n:
+                break
+            x *= x
+        return result
+
+    def __str__(self):
+        listofpoly = self.listofpoly
+        print_str = ''
+
+        for i, j in enumerate(listofpoly):
+            if j == self.parent.base.zero:
+                continue
+
+            j = self.parent.base.to_sympy(j)
+
+            if i == 0:
+                print_str += '(' + sstr(j) + ')'
+                continue
+
+            if print_str:
+                print_str += ' + '
+
+            if i == 1:
+                print_str += '(' + sstr(j) + ')Sn'
+                continue
+
+            print_str += '(' + sstr(j) + ')' + 'Sn**' + sstr(i)
+
+        return print_str
+
+    __repr__ = __str__
+
+    def __eq__(self, other):
+        if isinstance(other, RecurrenceOperator):
+            if self.listofpoly == other.listofpoly and self.parent == other.parent:
+                return True
+            else:
+                return False
+        return self.listofpoly[0] == other and \
+            all(i is self.parent.base.zero for i in self.listofpoly[1:])
+
+
+class HolonomicSequence:
+    """
+    A Holonomic Sequence is a type of sequence satisfying a linear homogeneous
+    recurrence relation with Polynomial coefficients. Alternatively, A sequence
+    is Holonomic if and only if its generating function is a Holonomic Function.
+    """
+
+    def __init__(self, recurrence, u0=[]):
+        self.recurrence = recurrence
+        if not isinstance(u0, list):
+            self.u0 = [u0]
+        else:
+            self.u0 = u0
+
+        if len(self.u0) == 0:
+            self._have_init_cond = False
+        else:
+            self._have_init_cond = True
+        self.n = recurrence.parent.base.gens[0]
+
+    def __repr__(self):
+        str_sol = 'HolonomicSequence(%s, %s)' % ((self.recurrence).__repr__(), sstr(self.n))
+        if not self._have_init_cond:
+            return str_sol
+        else:
+            cond_str = ''
+            seq_str = 0
+            for i in self.u0:
+                cond_str += ', u(%s) = %s' % (sstr(seq_str), sstr(i))
+                seq_str += 1
+
+            sol = str_sol + cond_str
+            return sol
+
+    __str__ = __repr__
+
+    def __eq__(self, other):
+        if self.recurrence != other.recurrence or self.n != other.n:
+            return False
+        if self._have_init_cond and other._have_init_cond:
+            return self.u0 == other.u0
+        return True

.venv/lib/python3.12/site-packages/sympy/holonomic/tests/test_holonomic.py

@@ -0,0 +1,851 @@
+from sympy.holonomic import (DifferentialOperator, HolonomicFunction,
+                             DifferentialOperators, from_hyper,
+                             from_meijerg, expr_to_holonomic)
+from sympy.holonomic.recurrence import RecurrenceOperators, HolonomicSequence
+from sympy.core import EulerGamma
+from sympy.core.numbers import (I, Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.hyperbolic import (asinh, cosh)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.bessel import besselj
+from sympy.functions.special.beta_functions import beta
+from sympy.functions.special.error_functions import (Ci, Si, erf, erfc)
+from sympy.functions.special.gamma_functions import gamma
+from sympy.functions.special.hyper import (hyper, meijerg)
+from sympy.printing.str import sstr
+from sympy.series.order import O
+from sympy.simplify.hyperexpand import hyperexpand
+from sympy.polys.domains.integerring import ZZ
+from sympy.polys.domains.rationalfield import QQ
+from sympy.polys.domains.realfield import RR
+
+
+def test_DifferentialOperator():
+    x = symbols('x')
+    R, Dx = DifferentialOperators(QQ.old_poly_ring(x), 'Dx')
+    assert Dx == R.derivative_operator
+    assert Dx == DifferentialOperator([R.base.zero, R.base.one], R)
+    assert x * Dx + x**2 * Dx**2 == DifferentialOperator([0, x, x**2], R)
+    assert (x**2 + 1) + Dx + x * \
+        Dx**5 == DifferentialOperator([x**2 + 1, 1, 0, 0, 0, x], R)
+    assert (x * Dx + x**2 + 1 - Dx * (x**3 + x))**3 == (-48 * x**6) + \
+        (-57 * x**7) * Dx + (-15 * x**8) * Dx**2 + (-x**9) * Dx**3
+    p = (x * Dx**2 + (x**2 + 3) * Dx**5) * (Dx + x**2)
+    q = (2 * x) + (4 * x**2) * Dx + (x**3) * Dx**2 + \
+        (20 * x**2 + x + 60) * Dx**3 + (10 * x**3 + 30 * x) * Dx**4 + \
+        (x**4 + 3 * x**2) * Dx**5 + (x**2 + 3) * Dx**6
+    assert p == q
+
+
+def test_HolonomicFunction_addition():
+    x = symbols('x')
+    R, Dx = DifferentialOperators(ZZ.old_poly_ring(x), 'Dx')
+    p = HolonomicFunction(Dx**2 * x, x)
+    q = HolonomicFunction((2) * Dx + (x) * Dx**2, x)
+    assert p == q
+    p = HolonomicFunction(x * Dx + 1, x)
+    q = HolonomicFunction(Dx + 1, x)
+    r = HolonomicFunction((x - 2) + (x**2 - 2) * Dx + (x**2 - x) * Dx**2, x)
+    assert p + q == r
+    p = HolonomicFunction(x * Dx + Dx**2 * (x**2 + 2), x)
+    q = HolonomicFunction(Dx - 3, x)
+    r = HolonomicFunction((-54 * x**2 - 126 * x - 150) + (-135 * x**3 - 252 * x**2 - 270 * x + 140) * Dx +\
+                 (-27 * x**4 - 24 * x**2 + 14 * x - 150) * Dx**2 + \
+                 (9 * x**4 + 15 * x**3 + 38 * x**2 + 30 * x +40) * Dx**3, x)
+    assert p + q == r
+    p = HolonomicFunction(Dx**5 - 1, x)
+    q = HolonomicFunction(x**3 + Dx, x)
+    r = HolonomicFunction((-x**18 + 45*x**14 - 525*x**10 + 1575*x**6 - x**3 - 630*x**2) + \
+        (-x**15 + 30*x**11 - 195*x**7 + 210*x**3 - 1)*Dx + (x**18 - 45*x**14 + 525*x**10 - \
+        1575*x**6 + x**3 + 630*x**2)*Dx**5 + (x**15 - 30*x**11 + 195*x**7 - 210*x**3 + \
+        1)*Dx**6, x)
+    assert p+q == r
+
+    p = x**2 + 3*x + 8
+    q = x**3 - 7*x + 5
+    p = p*Dx - p.diff()
+    q = q*Dx - q.diff()
+    r = HolonomicFunction(p, x) + HolonomicFunction(q, x)
+    s = HolonomicFunction((6*x**2 + 18*x + 14) + (-4*x**3 - 18*x**2 - 62*x + 10)*Dx +\
+        (x**4 + 6*x**3 + 31*x**2 - 10*x - 71)*Dx**2, x)
+    assert r == s
+
+
+def test_HolonomicFunction_multiplication():
+    x = symbols('x')
+    R, Dx = DifferentialOperators(ZZ.old_poly_ring(x), 'Dx')
+    p = HolonomicFunction(Dx+x+x*Dx**2, x)
+    q = HolonomicFunction(x*Dx+Dx*x+Dx**2, x)
+    r = HolonomicFunction((8*x**6 + 4*x**4 + 6*x**2 + 3) + (24*x**5 - 4*x**3 + 24*x)*Dx + \
+        (8*x**6 + 20*x**4 + 12*x**2 + 2)*Dx**2 + (8*x**5 + 4*x**3 + 4*x)*Dx**3 + \
+        (2*x**4 + x**2)*Dx**4, x)
+    assert p*q == r
+    p = HolonomicFunction(Dx**2+1, x)
+    q = HolonomicFunction(Dx-1, x)
+    r = HolonomicFunction((2) + (-2)*Dx + (1)*Dx**2, x)
+    assert p*q == r
+    p = HolonomicFunction(Dx**2+1+x+Dx, x)
+    q = HolonomicFunction((Dx*x-1)**2, x)
+    r = HolonomicFunction((4*x**7 + 11*x**6 + 16*x**5 + 4*x**4 - 6*x**3 - 7*x**2 - 8*x - 2) + \
+        (8*x**6 + 26*x**5 + 24*x**4 - 3*x**3 - 11*x**2 - 6*x - 2)*Dx + \
+        (8*x**6 + 18*x**5 + 15*x**4 - 3*x**3 - 6*x**2 - 6*x - 2)*Dx**2 + (8*x**5 + \
+            10*x**4 + 6*x**3 - 2*x**2 - 4*x)*Dx**3 + (4*x**5 + 3*x**4 - x**2)*Dx**4, x)
+    assert p*q == r
+    p = HolonomicFunction(x*Dx**2-1, x)
+    q = HolonomicFunction(Dx*x-x, x)
+    r = HolonomicFunction((x - 3) + (-2*x + 2)*Dx + (x)*Dx**2, x)
+    assert p*q == r
+
+
+def test_HolonomicFunction_power():
+    x = symbols('x')
+    R, Dx = DifferentialOperators(ZZ.old_poly_ring(x), 'Dx')
+    p = HolonomicFunction(Dx+x+x*Dx**2, x)
+    a = HolonomicFunction(Dx, x)
+    for n in range(10):
+        assert a == p**n
+        a *= p
+
+
+def test_addition_initial_condition():
+    x = symbols('x')
+    R, Dx = DifferentialOperators(QQ.old_poly_ring(x), 'Dx')
+    p = HolonomicFunction(Dx-1, x, 0, [3])
+    q = HolonomicFunction(Dx**2+1, x, 0, [1, 0])
+    r = HolonomicFunction(-1 + Dx - Dx**2 + Dx**3, x, 0, [4, 3, 2])
+    assert p + q == r
+    p = HolonomicFunction(Dx - x + Dx**2, x, 0, [1, 2])
+    q = HolonomicFunction(Dx**2 + x, x, 0, [1, 0])
+    r = HolonomicFunction((-x**4 - x**3/4 - x**2 + Rational(1, 4)) + (x**3 + x**2/4 + x*Rational(3, 4) + 1)*Dx + \
+        (x*Rational(-3, 2) + Rational(7, 4))*Dx**2 + (x**2 - x*Rational(7, 4) + Rational(1, 4))*Dx**3 + (x**2 + x/4 + S.Half)*Dx**4, x, 0, [2, 2, -2, 2])
+    assert p + q == r
+    p = HolonomicFunction(Dx**2 + 4*x*Dx + x**2, x, 0, [3, 4])
+    q = HolonomicFunction(Dx**2 + 1, x, 0, [1, 1])
+    r = HolonomicFunction((x**6 + 2*x**4 - 5*x**2 - 6) + (4*x**5 + 36*x**3 - 32*x)*Dx + \
+         (x**6 + 3*x**4 + 5*x**2 - 9)*Dx**2 + (4*x**5 + 36*x**3 - 32*x)*Dx**3 + (x**4 + \
+            10*x**2 - 3)*Dx**4, x, 0, [4, 5, -1, -17])
+    assert p + q == r
+    q = HolonomicFunction(Dx**3 + x, x, 2, [3, 0, 1])
+    p = HolonomicFunction(Dx - 1, x, 2, [1])
+    r = HolonomicFunction((-x**2 - x + 1) + (x**2 + x)*Dx + (-x - 2)*Dx**3 + \
+        (x + 1)*Dx**4, x, 2, [4, 1, 2, -5 ])
+    assert p + q == r
+    p = expr_to_holonomic(sin(x))
+    q = expr_to_holonomic(1/x, x0=1)
+    r = HolonomicFunction((x**2 + 6) + (x**3 + 2*x)*Dx + (x**2 + 6)*Dx**2 + (x**3 + 2*x)*Dx**3, \
+        x, 1, [sin(1) + 1, -1 + cos(1), -sin(1) + 2])
+    assert p + q == r
+    C_1 = symbols('C_1')
+    p = expr_to_holonomic(sqrt(x))
+    q = expr_to_holonomic(sqrt(x**2-x))
+    r = (p + q).to_expr().subs(C_1, -I/2).expand()
+    assert r == I*sqrt(x)*sqrt(-x + 1) + sqrt(x)
+
+
+def test_multiplication_initial_condition():
+    x = symbols('x')
+    R, Dx = DifferentialOperators(QQ.old_poly_ring(x), 'Dx')
+    p = HolonomicFunction(Dx**2 + x*Dx - 1, x, 0, [3, 1])
+    q = HolonomicFunction(Dx**2 + 1, x, 0, [1, 1])
+    r = HolonomicFunction((x**4 + 14*x**2 + 60) + 4*x*Dx + (x**4 + 9*x**2 + 20)*Dx**2 + \
+        (2*x**3 + 18*x)*Dx**3 + (x**2 + 10)*Dx**4, x, 0, [3, 4, 2, 3])
+    assert p * q == r
+    p = HolonomicFunction(Dx**2 + x, x, 0, [1, 0])
+    q = HolonomicFunction(Dx**3 - x**2, x, 0, [3, 3, 3])
+    r = HolonomicFunction((x**8 - 37*x**7/27 - 10*x**6/27 - 164*x**5/9 - 184*x**4/9 + \
+        160*x**3/27 + 404*x**2/9 + 8*x + Rational(40, 3)) + (6*x**7 - 128*x**6/9 - 98*x**5/9 - 28*x**4/9 + \
+        8*x**3/9 + 28*x**2 + x*Rational(40, 9) - 40)*Dx + (3*x**6 - 82*x**5/9 + 76*x**4/9 + 4*x**3/3 + \
+        220*x**2/9 - x*Rational(80, 3))*Dx**2 + (-2*x**6 + 128*x**5/27 - 2*x**4/3 -80*x**2/9 + Rational(200, 9))*Dx**3 + \
+        (3*x**5 - 64*x**4/9 - 28*x**3/9 + 6*x**2 - x*Rational(20, 9) - Rational(20, 3))*Dx**4 + (-4*x**3 + 64*x**2/9 + \
+            x*Rational(8, 3))*Dx**5 + (x**4 - 64*x**3/27 - 4*x**2/3 + Rational(20, 9))*Dx**6, x, 0, [3, 3, 3, -3, -12, -24])
+    assert p * q == r
+    p = HolonomicFunction(Dx - 1, x, 0, [2])
+    q = HolonomicFunction(Dx**2 + 1, x, 0, [0, 1])
+    r = HolonomicFunction(2 -2*Dx + Dx**2, x, 0, [0, 2])
+    assert p * q == r
+    q = HolonomicFunction(x*Dx**2 + 1 + 2*Dx, x, 0,[0, 1])
+    r = HolonomicFunction((x - 1) + (-2*x + 2)*Dx + x*Dx**2, x, 0, [0, 2])
+    assert p * q == r
+    p = HolonomicFunction(Dx**2 - 1, x, 0, [1, 3])
+    q = HolonomicFunction(Dx**3 + 1, x, 0, [1, 2, 1])
+    r = HolonomicFunction(6*Dx + 3*Dx**2 + 2*Dx**3 - 3*Dx**4 + Dx**6, x, 0, [1, 5, 14, 17, 17, 2])
+    assert p * q == r
+    p = expr_to_holonomic(sin(x))
+    q = expr_to_holonomic(1/x, x0=1)
+    r = HolonomicFunction(x + 2*Dx + x*Dx**2, x, 1, [sin(1), -sin(1) + cos(1)])
+    assert p * q == r
+    p = expr_to_holonomic(sqrt(x))
+    q = expr_to_holonomic(sqrt(x**2-x))
+    r = (p * q).to_expr()
+    assert r == I*x*sqrt(-x + 1)
+
+
+def test_HolonomicFunction_composition():
+    x = symbols('x')
+    R, Dx = DifferentialOperators(ZZ.old_poly_ring(x), 'Dx')
+    p = HolonomicFunction(Dx-1, x).composition(x**2+x)
+    r = HolonomicFunction((-2*x - 1) + Dx, x)
+    assert p == r
+    p = HolonomicFunction(Dx**2+1, x).composition(x**5+x**2+1)
+    r = HolonomicFunction((125*x**12 + 150*x**9 + 60*x**6 + 8*x**3) + (-20*x**3 - 2)*Dx + \
+        (5*x**4 + 2*x)*Dx**2, x)
+    assert p == r
+    p = HolonomicFunction(Dx**2*x+x, x).composition(2*x**3+x**2+1)
+    r = HolonomicFunction((216*x**9 + 324*x**8 + 180*x**7 + 152*x**6 + 112*x**5 + \
+        36*x**4 + 4*x**3) + (24*x**4 + 16*x**3 + 3*x**2 - 6*x - 1)*Dx + (6*x**5 + 5*x**4 + \
+        x**3 + 3*x**2 + x)*Dx**2, x)
+    assert p == r
+    p = HolonomicFunction(Dx**2+1, x).composition(1-x**2)
+    r = HolonomicFunction((4*x**3) - Dx + x*Dx**2, x)
+    assert p == r
+    p = HolonomicFunction(Dx**2+1, x).composition(x - 2/(x**2 + 1))
+    r = HolonomicFunction((x**12 + 6*x**10 + 12*x**9 + 15*x**8 + 48*x**7 + 68*x**6 + \
+        72*x**5 + 111*x**4 + 112*x**3 + 54*x**2 + 12*x + 1) + (12*x**8 + 32*x**6 + \
+        24*x**4 - 4)*Dx + (x**12 + 6*x**10 + 4*x**9 + 15*x**8 + 16*x**7 + 20*x**6 + 24*x**5+ \
+        15*x**4 + 16*x**3 + 6*x**2 + 4*x + 1)*Dx**2, x)
+    assert p == r
+
+
+def test_from_hyper():
+    x = symbols('x')
+    R, Dx = DifferentialOperators(QQ.old_poly_ring(x), 'Dx')
+    p = hyper([1, 1], [Rational(3, 2)], x**2/4)
+    q = HolonomicFunction((4*x) + (5*x**2 - 8)*Dx + (x**3 - 4*x)*Dx**2, x, 1, [2*sqrt(3)*pi/9, -4*sqrt(3)*pi/27 + Rational(4, 3)])
+    r = from_hyper(p)
+    assert r == q
+    p = from_hyper(hyper([1], [Rational(3, 2)], x**2/4))
+    q = HolonomicFunction(-x + (-x**2/2 + 2)*Dx + x*Dx**2, x)
+    # x0 = 1
+    y0 = '[sqrt(pi)*exp(1/4)*erf(1/2), -sqrt(pi)*exp(1/4)*erf(1/2)/2 + 1]'
+    assert sstr(p.y0) == y0
+    assert q.annihilator == p.annihilator
+
+
+def test_from_meijerg():
+    x = symbols('x')
+    R, Dx = DifferentialOperators(QQ.old_poly_ring(x), 'Dx')
+    p = from_meijerg(meijerg(([], [Rational(3, 2)]), ([S.Half], [S.Half, 1]), x))
+    q = HolonomicFunction(x/2 - Rational(1, 4) + (-x**2 + x/4)*Dx + x**2*Dx**2 + x**3*Dx**3, x, 1, \
+        [1/sqrt(pi), 1/(2*sqrt(pi)), -1/(4*sqrt(pi))])
+    assert p == q
+    p = from_meijerg(meijerg(([], []), ([0], []), x))
+    q = HolonomicFunction(1 + Dx, x, 0, [1])
+    assert p == q
+    p = from_meijerg(meijerg(([1], []), ([S.Half], [0]), x))
+    q = HolonomicFunction((x + S.Half)*Dx + x*Dx**2, x, 1, [sqrt(pi)*erf(1), exp(-1)])
+    assert p == q
+    p = from_meijerg(meijerg(([0], [1]), ([0], []), 2*x**2))
+    q = HolonomicFunction((3*x**2 - 1)*Dx + x**3*Dx**2, x, 1, [-exp(Rational(-1, 2)) + 1, -exp(Rational(-1, 2))])
+    assert p == q
+
+
+def test_to_Sequence():
+    x = symbols('x')
+    R, Dx = DifferentialOperators(ZZ.old_poly_ring(x), 'Dx')
+    n = symbols('n', integer=True)
+    _, Sn = RecurrenceOperators(ZZ.old_poly_ring(n), 'Sn')
+    p = HolonomicFunction(x**2*Dx**4 + x + Dx, x).to_sequence()
+    q = [(HolonomicSequence(1 + (n + 2)*Sn**2 + (n**4 + 6*n**3 + 11*n**2 + 6*n)*Sn**3), 0, 1)]
+    assert p == q
+    p = HolonomicFunction(x**2*Dx**4 + x**3 + Dx**2, x).to_sequence()
+    q = [(HolonomicSequence(1 + (n**4 + 14*n**3 + 72*n**2 + 163*n + 140)*Sn**5), 0, 0)]
+    assert p == q
+    p = HolonomicFunction(x**3*Dx**4 + 1 + Dx**2, x).to_sequence()
+    q = [(HolonomicSequence(1 + (n**4 - 2*n**3 - n**2 + 2*n)*Sn + (n**2 + 3*n + 2)*Sn**2), 0, 0)]
+    assert p == q
+    p = HolonomicFunction(3*x**3*Dx**4 + 2*x*Dx + x*Dx**3, x).to_sequence()
+    q = [(HolonomicSequence(2*n + (3*n**4 - 6*n**3 - 3*n**2 + 6*n)*Sn + (n**3 + 3*n**2 + 2*n)*Sn**2), 0, 1)]
+    assert p == q
+
+
+def test_to_Sequence_Initial_Coniditons():
+    x = symbols('x')
+    R, Dx = DifferentialOperators(QQ.old_poly_ring(x), 'Dx')
+    n = symbols('n', integer=True)
+    _, Sn = RecurrenceOperators(QQ.old_poly_ring(n), 'Sn')
+    p = HolonomicFunction(Dx - 1, x, 0, [1]).to_sequence()
+    q = [(HolonomicSequence(-1 + (n + 1)*Sn, 1), 0)]
+    assert p == q
+    p = HolonomicFunction(Dx**2 + 1, x, 0, [0, 1]).to_sequence()
+    q = [(HolonomicSequence(1 + (n**2 + 3*n + 2)*Sn**2, [0, 1]), 0)]
+    assert p == q
+    p = HolonomicFunction(Dx**2 + 1 + x**3*Dx, x, 0, [2, 3]).to_sequence()
+    q = [(HolonomicSequence(n + Sn**2 + (n**2 + 7*n + 12)*Sn**4, [2, 3, -1, Rational(-1, 2), Rational(1, 12)]), 1)]
+    assert p == q
+    p = HolonomicFunction(x**3*Dx**5 + 1 + Dx, x).to_sequence()
+    q = [(HolonomicSequence(1 + (n + 1)*Sn + (n**5 - 5*n**3 + 4*n)*Sn**2), 0, 3)]
+    assert p == q
+    C_0, C_1, C_2, C_3 = symbols('C_0, C_1, C_2, C_3')
+    p = expr_to_holonomic(log(1+x**2))
+    q = [(HolonomicSequence(n**2 + (n**2 + 2*n)*Sn**2, [0, 0, C_2]), 0, 1)]
+    assert p.to_sequence() == q
+    p = p.diff()
+    q = [(HolonomicSequence((n + 2) + (n + 2)*Sn**2, [C_0, 0]), 1, 0)]
+    assert p.to_sequence() == q
+    p = expr_to_holonomic(erf(x) + x).to_sequence()
+    q = [(HolonomicSequence((2*n**2 - 2*n) + (n**3 + 2*n**2 - n - 2)*Sn**2, [0, 1 + 2/sqrt(pi), 0, C_3]), 0, 2)]
+    assert p == q
+
+def test_series():
+    x = symbols('x')
+    R, Dx = DifferentialOperators(ZZ.old_poly_ring(x), 'Dx')
+    p = HolonomicFunction(Dx**2 + 2*x*Dx, x, 0, [0, 1]).series(n=10)
+    q = x - x**3/3 + x**5/10 - x**7/42 + x**9/216 + O(x**10)
+    assert p == q
+    p = HolonomicFunction(Dx - 1, x).composition(x**2, 0, [1])  # e^(x**2)
+    q = HolonomicFunction(Dx**2 + 1, x, 0, [1, 0])  # cos(x)
+    r = (p * q).series(n=10)  # expansion of cos(x) * exp(x**2)
+    s = 1 + x**2/2 + x**4/24 - 31*x**6/720 - 179*x**8/8064 + O(x**10)
+    assert r == s
+    t = HolonomicFunction((1 + x)*Dx**2 + Dx, x, 0, [0, 1])  # log(1 + x)
+    r = (p * t + q).series(n=10)
+    s = 1 + x - x**2 + 4*x**3/3 - 17*x**4/24 + 31*x**5/30 - 481*x**6/720 +\
+     71*x**7/105 - 20159*x**8/40320 + 379*x**9/840 + O(x**10)
+    assert r == s
+    p = HolonomicFunction((6+6*x-3*x**2) - (10*x-3*x**2-3*x**3)*Dx + \
+        (4-6*x**3+2*x**4)*Dx**2, x, 0, [0, 1]).series(n=7)
+    q = x + x**3/6 - 3*x**4/16 + x**5/20 - 23*x**6/960 + O(x**7)
+    assert p == q
+    p = HolonomicFunction((6+6*x-3*x**2) - (10*x-3*x**2-3*x**3)*Dx + \
+        (4-6*x**3+2*x**4)*Dx**2, x, 0, [1, 0]).series(n=7)
+    q = 1 - 3*x**2/4 - x**3/4 - 5*x**4/32 - 3*x**5/40 - 17*x**6/384 + O(x**7)
+    assert p == q
+    p = expr_to_holonomic(erf(x) + x).series(n=10)
+    C_3 = symbols('C_3')
+    q = (erf(x) + x).series(n=10)
+    assert p.subs(C_3, -2/(3*sqrt(pi))) == q
+    assert expr_to_holonomic(sqrt(x**3 + x)).series(n=10) == sqrt(x**3 + x).series(n=10)
+    assert expr_to_holonomic((2*x - 3*x**2)**Rational(1, 3)).series() == ((2*x - 3*x**2)**Rational(1, 3)).series()
+    assert  expr_to_holonomic(sqrt(x**2-x)).series() == (sqrt(x**2-x)).series()
+    assert expr_to_holonomic(cos(x)**2/x**2, y0={-2: [1, 0, -1]}).series(n=10) == (cos(x)**2/x**2).series(n=10)
+    assert expr_to_holonomic(cos(x)**2/x**2, x0=1).series(n=10).together() == (cos(x)**2/x**2).series(n=10, x0=1).together()
+    assert expr_to_holonomic(cos(x-1)**2/(x-1)**2, x0=1, y0={-2: [1, 0, -1]}).series(n=10) \
+        == (cos(x-1)**2/(x-1)**2).series(x0=1, n=10)
+
+def test_evalf_euler():
+    x = symbols('x')
+    R, Dx = DifferentialOperators(QQ.old_poly_ring(x), 'Dx')
+
+    # log(1+x)
+    p = HolonomicFunction((1 + x)*Dx**2 + Dx, x, 0, [0, 1])
+
+    # path taken is a straight line from 0 to 1, on the real axis
+    r = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1]
+    s = '0.699525841805253'  # approx. equal to log(2) i.e. 0.693147180559945
+    assert sstr(p.evalf(r, method='Euler')[-1]) == s
+
+    # path taken is a triangle 0-->1+i-->2
+    r = [0.1 + 0.1*I]
+    for i in range(9):
+        r.append(r[-1]+0.1+0.1*I)
+    for i in range(10):
+        r.append(r[-1]+0.1-0.1*I)
+
+    # close to the exact solution 1.09861228866811
+    # imaginary part also close to zero
+    s = '1.07530466271334 - 0.0251200594793912*I'
+    assert sstr(p.evalf(r, method='Euler')[-1]) == s
+
+    # sin(x)
+    p = HolonomicFunction(Dx**2 + 1, x, 0, [0, 1])
+    s = '0.905546532085401 - 6.93889390390723e-18*I'
+    assert sstr(p.evalf(r, method='Euler')[-1]) == s
+
+    # computing sin(pi/2) using this method
+    # using a linear path from 0 to pi/2
+    r = [0.1]
+    for i in range(14):
+        r.append(r[-1] + 0.1)
+    r.append(pi/2)
+    s = '1.08016557252834' # close to 1.0 (exact solution)
+    assert sstr(p.evalf(r, method='Euler')[-1]) == s
+
+    # trying different path, a rectangle (0-->i-->pi/2 + i-->pi/2)
+    # computing the same value sin(pi/2) using different path
+    r = [0.1*I]
+    for i in range(9):
+        r.append(r[-1]+0.1*I)
+    for i in range(15):
+        r.append(r[-1]+0.1)
+    r.append(pi/2+I)
+    for i in range(10):
+        r.append(r[-1]-0.1*I)
+
+    # close to 1.0
+    s = '0.976882381836257 - 1.65557671738537e-16*I'
+    assert sstr(p.evalf(r, method='Euler')[-1]) == s
+
+    # cos(x)
+    p = HolonomicFunction(Dx**2 + 1, x, 0, [1, 0])
+    # compute cos(pi) along 0-->pi
+    r = [0.05]
+    for i in range(61):
+        r.append(r[-1]+0.05)
+    r.append(pi)
+    # close to -1 (exact answer)
+    s = '-1.08140824719196'
+    assert sstr(p.evalf(r, method='Euler')[-1]) == s
+
+    # a rectangular path (0 -> i -> 2+i -> 2)
+    r = [0.1*I]
+    for i in range(9):
+        r.append(r[-1]+0.1*I)
+    for i in range(20):
+        r.append(r[-1]+0.1)
+    for i in range(10):
+        r.append(r[-1]-0.1*I)
+
+    p = HolonomicFunction(Dx**2 + 1, x, 0, [1,1]).evalf(r, method='Euler')
+    s = '0.501421652861245 - 3.88578058618805e-16*I'
+    assert sstr(p[-1]) == s
+
+def test_evalf_rk4():
+    x = symbols('x')
+    R, Dx = DifferentialOperators(QQ.old_poly_ring(x), 'Dx')
+
+    # log(1+x)
+    p = HolonomicFunction((1 + x)*Dx**2 + Dx, x, 0, [0, 1])
+
+    # path taken is a straight line from 0 to 1, on the real axis
+    r = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1]
+    s = '0.693146363174626'  # approx. equal to log(2) i.e. 0.693147180559945
+    assert sstr(p.evalf(r)[-1]) == s
+
+    # path taken is a triangle 0-->1+i-->2
+    r = [0.1 + 0.1*I]
+    for i in range(9):
+        r.append(r[-1]+0.1+0.1*I)
+    for i in range(10):
+        r.append(r[-1]+0.1-0.1*I)
+
+    # close to the exact solution 1.09861228866811
+    # imaginary part also close to zero
+    s = '1.098616 + 1.36083e-7*I'
+    assert sstr(p.evalf(r)[-1].n(7)) == s
+
+    # sin(x)
+    p = HolonomicFunction(Dx**2 + 1, x, 0, [0, 1])
+    s = '0.90929463522785 + 1.52655665885959e-16*I'
+    assert sstr(p.evalf(r)[-1]) == s
+
+    # computing sin(pi/2) using this method
+    # using a linear path from 0 to pi/2
+    r = [0.1]
+    for i in range(14):
+        r.append(r[-1] + 0.1)
+    r.append(pi/2)
+    s = '0.999999895088917' # close to 1.0 (exact solution)
+    assert sstr(p.evalf(r)[-1]) == s
+
+    # trying different path, a rectangle (0-->i-->pi/2 + i-->pi/2)
+    # computing the same value sin(pi/2) using different path
+    r = [0.1*I]
+    for i in range(9):
+        r.append(r[-1]+0.1*I)
+    for i in range(15):
+        r.append(r[-1]+0.1)
+    r.append(pi/2+I)
+    for i in range(10):
+        r.append(r[-1]-0.1*I)
+
+    # close to 1.0
+    s = '1.00000003415141 + 6.11940487991086e-16*I'
+    assert sstr(p.evalf(r)[-1]) == s
+
+    # cos(x)
+    p = HolonomicFunction(Dx**2 + 1, x, 0, [1, 0])
+    # compute cos(pi) along 0-->pi
+    r = [0.05]
+    for i in range(61):
+        r.append(r[-1]+0.05)
+    r.append(pi)
+    # close to -1 (exact answer)
+    s = '-0.999999993238714'
+    assert sstr(p.evalf(r)[-1]) == s
+
+    # a rectangular path (0 -> i -> 2+i -> 2)
+    r = [0.1*I]
+    for i in range(9):
+        r.append(r[-1]+0.1*I)
+    for i in range(20):
+        r.append(r[-1]+0.1)
+    for i in range(10):
+        r.append(r[-1]-0.1*I)
+
+    p = HolonomicFunction(Dx**2 + 1, x, 0, [1,1]).evalf(r)
+    s = '0.493152791638442 - 1.41553435639707e-15*I'
+    assert sstr(p[-1]) == s
+
+
+def test_expr_to_holonomic():
+    x = symbols('x')
+    R, Dx = DifferentialOperators(QQ.old_poly_ring(x), 'Dx')
+    p = expr_to_holonomic((sin(x)/x)**2)
+    q = HolonomicFunction(8*x + (4*x**2 + 6)*Dx + 6*x*Dx**2 + x**2*Dx**3, x, 0, \
+        [1, 0, Rational(-2, 3)])
+    assert p == q
+    p = expr_to_holonomic(1/(1+x**2)**2)
+    q = HolonomicFunction(4*x + (x**2 + 1)*Dx, x, 0, [1])
+    assert p == q
+    p = expr_to_holonomic(exp(x)*sin(x)+x*log(1+x))
+    q = HolonomicFunction((2*x**3 + 10*x**2 + 20*x + 18) + (-2*x**4 - 10*x**3 - 20*x**2 \
+        - 18*x)*Dx + (2*x**5 + 6*x**4 + 7*x**3 + 8*x**2 + 10*x - 4)*Dx**2 + \
+        (-2*x**5 - 5*x**4 - 2*x**3 + 2*x**2 - x + 4)*Dx**3 + (x**5 + 2*x**4 - x**3 - \
+        7*x**2/2 + x + Rational(5, 2))*Dx**4, x, 0, [0, 1, 4, -1])
+    assert p == q
+    p = expr_to_holonomic(x*exp(x)+cos(x)+1)
+    q = HolonomicFunction((-x - 3)*Dx + (x + 2)*Dx**2 + (-x - 3)*Dx**3 + (x + 2)*Dx**4, x, \
+        0, [2, 1, 1, 3])
+    assert p == q
+    assert (x*exp(x)+cos(x)+1).series(n=10) == p.series(n=10)
+    p = expr_to_holonomic(log(1 + x)**2 + 1)
+    q = HolonomicFunction(Dx + (3*x + 3)*Dx**2 + (x**2 + 2*x + 1)*Dx**3, x, 0, [1, 0, 2])
+    assert p == q
+    p = expr_to_holonomic(erf(x)**2 + x)
+    q = HolonomicFunction((8*x**4 - 2*x**2 + 2)*Dx**2 + (6*x**3 - x/2)*Dx**3 + \
+        (x**2+ Rational(1, 4))*Dx**4, x, 0, [0, 1, 8/pi, 0])
+    assert p == q
+    p = expr_to_holonomic(cosh(x)*x)
+    q = HolonomicFunction((-x**2 + 2) -2*x*Dx + x**2*Dx**2, x, 0, [0, 1])
+    assert p == q
+    p = expr_to_holonomic(besselj(2, x))
+    q = HolonomicFunction((x**2 - 4) + x*Dx + x**2*Dx**2, x, 0, [0, 0])
+    assert p == q
+    p = expr_to_holonomic(besselj(0, x) + exp(x))
+    q = HolonomicFunction((-x**2 - x/2 + S.Half) + (x**2 - x/2 - Rational(3, 2))*Dx + (-x**2 + x/2 + 1)*Dx**2 +\
+        (x**2 + x/2)*Dx**3, x, 0, [2, 1, S.Half])
+    assert p == q
+    p = expr_to_holonomic(sin(x)**2/x)
+    q = HolonomicFunction(4 + 4*x*Dx + 3*Dx**2 + x*Dx**3, x, 0, [0, 1, 0])
+    assert p == q
+    p = expr_to_holonomic(sin(x)**2/x, x0=2)
+    q = HolonomicFunction((4) + (4*x)*Dx + (3)*Dx**2 + (x)*Dx**3, x, 2, [sin(2)**2/2,
+        sin(2)*cos(2) - sin(2)**2/4, -3*sin(2)**2/4 + cos(2)**2 - sin(2)*cos(2)])
+    assert p == q
+    p = expr_to_holonomic(log(x)/2 - Ci(2*x)/2 + Ci(2)/2)
+    q = HolonomicFunction(4*Dx + 4*x*Dx**2 + 3*Dx**3 + x*Dx**4, x, 0, \
+        [-log(2)/2 - EulerGamma/2 + Ci(2)/2, 0, 1, 0])
+    assert p == q
+    p = p.to_expr()
+    q = log(x)/2 - Ci(2*x)/2 + Ci(2)/2
+    assert p == q
+    p = expr_to_holonomic(x**S.Half, x0=1)
+    q = HolonomicFunction(x*Dx - S.Half, x, 1, [1])
+    assert p == q
+    p = expr_to_holonomic(sqrt(1 + x**2))
+    q = HolonomicFunction((-x) + (x**2 + 1)*Dx, x, 0, [1])
+    assert p == q
+    assert (expr_to_holonomic(sqrt(x) + sqrt(2*x)).to_expr()-\
+        (sqrt(x) + sqrt(2*x))).simplify() == 0
+    assert expr_to_holonomic(3*x+2*sqrt(x)).to_expr() == 3*x+2*sqrt(x)
+    p = expr_to_holonomic((x**4+x**3+5*x**2+3*x+2)/x**2, lenics=3)
+    q = HolonomicFunction((-2*x**4 - x**3 + 3*x + 4) + (x**5 + x**4 + 5*x**3 + 3*x**2 + \
+        2*x)*Dx, x, 0, {-2: [2, 3, 5]})
+    assert p == q
+    p = expr_to_holonomic(1/(x-1)**2, lenics=3, x0=1)
+    q = HolonomicFunction((2) + (x - 1)*Dx, x, 1, {-2: [1, 0, 0]})
+    assert p == q
+    a = symbols("a")
+    p = expr_to_holonomic(sqrt(a*x), x=x)
+    assert p.to_expr() == sqrt(a)*sqrt(x)
+
+def test_to_hyper():
+    x = symbols('x')
+    R, Dx = DifferentialOperators(QQ.old_poly_ring(x), 'Dx')
+    p = HolonomicFunction(Dx - 2, x, 0, [3]).to_hyper()
+    q = 3 * hyper([], [], 2*x)
+    assert p == q
+    p = hyperexpand(HolonomicFunction((1 + x) * Dx - 3, x, 0, [2]).to_hyper()).expand()
+    q = 2*x**3 + 6*x**2 + 6*x + 2
+    assert p == q
+    p = HolonomicFunction((1 + x)*Dx**2 + Dx, x, 0, [0, 1]).to_hyper()
+    q = -x**2*hyper((2, 2, 1), (3, 2), -x)/2 + x
+    assert p == q
+    p = HolonomicFunction(2*x*Dx + Dx**2, x, 0, [0, 2/sqrt(pi)]).to_hyper()
+    q = 2*x*hyper((S.Half,), (Rational(3, 2),), -x**2)/sqrt(pi)
+    assert p == q
+    p = hyperexpand(HolonomicFunction(2*x*Dx + Dx**2, x, 0, [1, -2/sqrt(pi)]).to_hyper())
+    q = erfc(x)
+    assert p.rewrite(erfc) == q
+    p =  hyperexpand(HolonomicFunction((x**2 - 1) + x*Dx + x**2*Dx**2,
+        x, 0, [0, S.Half]).to_hyper())
+    q = besselj(1, x)
+    assert p == q
+    p = hyperexpand(HolonomicFunction(x*Dx**2 + Dx + x, x, 0, [1, 0]).to_hyper())
+    q = besselj(0, x)
+    assert p == q
+
+def test_to_expr():
+    x = symbols('x')
+    R, Dx = DifferentialOperators(ZZ.old_poly_ring(x), 'Dx')
+    p = HolonomicFunction(Dx - 1, x, 0, [1]).to_expr()
+    q = exp(x)
+    assert p == q
+    p = HolonomicFunction(Dx**2 + 1, x, 0, [1, 0]).to_expr()
+    q = cos(x)
+    assert p == q
+    p = HolonomicFunction(Dx**2 - 1, x, 0, [1, 0]).to_expr()
+    q = cosh(x)
+    assert p == q
+    p = HolonomicFunction(2 + (4*x - 1)*Dx + \
+        (x**2 - x)*Dx**2, x, 0, [1, 2]).to_expr().expand()
+    q = 1/(x**2 - 2*x + 1)
+    assert p == q
+    p = expr_to_holonomic(sin(x)**2/x).integrate((x, 0, x)).to_expr()
+    q = (sin(x)**2/x).integrate((x, 0, x))
+    assert p == q
+    C_0, C_1, C_2, C_3 = symbols('C_0, C_1, C_2, C_3')
+    p = expr_to_holonomic(log(1+x**2)).to_expr()
+    q = C_2*log(x**2 + 1)
+    assert p == q
+    p = expr_to_holonomic(log(1+x**2)).diff().to_expr()
+    q = C_0*x/(x**2 + 1)
+    assert p == q
+    p = expr_to_holonomic(erf(x) + x).to_expr()
+    q = 3*C_3*x - 3*sqrt(pi)*C_3*erf(x)/2 + x + 2*x/sqrt(pi)
+    assert p == q
+    p = expr_to_holonomic(sqrt(x), x0=1).to_expr()
+    assert p == sqrt(x)
+    assert expr_to_holonomic(sqrt(x)).to_expr() == sqrt(x)
+    p = expr_to_holonomic(sqrt(1 + x**2)).to_expr()
+    assert p == sqrt(1+x**2)
+    p = expr_to_holonomic((2*x**2 + 1)**Rational(2, 3)).to_expr()
+    assert p == (2*x**2 + 1)**Rational(2, 3)
+    p = expr_to_holonomic(sqrt(-x**2+2*x)).to_expr()
+    assert p == sqrt(x)*sqrt(-x + 2)
+    p = expr_to_holonomic((-2*x**3+7*x)**Rational(2, 3)).to_expr()
+    q = x**Rational(2, 3)*(-2*x**2 + 7)**Rational(2, 3)
+    assert p == q
+    p = from_hyper(hyper((-2, -3), (S.Half, ), x))
+    s = hyperexpand(hyper((-2, -3), (S.Half, ), x))
+    D_0 = Symbol('D_0')
+    C_0 = Symbol('C_0')
+    assert (p.to_expr().subs({C_0:1, D_0:0}) - s).simplify() == 0
+    p.y0 = {0: [1], S.Half: [0]}
+    assert p.to_expr() == s
+    assert expr_to_holonomic(x**5).to_expr() == x**5
+    assert expr_to_holonomic(2*x**3-3*x**2).to_expr().expand() == \
+        2*x**3-3*x**2
+    a = symbols("a")
+    p = (expr_to_holonomic(1.4*x)*expr_to_holonomic(a*x, x)).to_expr()
+    q = 1.4*a*x**2
+    assert p == q
+    p = (expr_to_holonomic(1.4*x)+expr_to_holonomic(a*x, x)).to_expr()
+    q = x*(a + 1.4)
+    assert p == q
+    p = (expr_to_holonomic(1.4*x)+expr_to_holonomic(x)).to_expr()
+    assert p == 2.4*x
+
+
+def test_integrate():
+    x = symbols('x')
+    R, Dx = DifferentialOperators(ZZ.old_poly_ring(x), 'Dx')
+    p = expr_to_holonomic(sin(x)**2/x, x0=1).integrate((x, 2, 3))
+    q = '0.166270406994788'
+    assert sstr(p) == q
+    p = expr_to_holonomic(sin(x)).integrate((x, 0, x)).to_expr()
+    q = 1 - cos(x)
+    assert p == q
+    p = expr_to_holonomic(sin(x)).integrate((x, 0, 3))
+    q = 1 - cos(3)
+    assert p == q
+    p = expr_to_holonomic(sin(x)/x, x0=1).integrate((x, 1, 2))
+    q = '0.659329913368450'
+    assert sstr(p) == q
+    p = expr_to_holonomic(sin(x)**2/x, x0=1).integrate((x, 1, 0))
+    q = '-0.423690480850035'
+    assert sstr(p) == q
+    p = expr_to_holonomic(sin(x)/x)
+    assert p.integrate(x).to_expr() == Si(x)
+    assert p.integrate((x, 0, 2)) == Si(2)
+    p = expr_to_holonomic(sin(x)**2/x)
+    q = p.to_expr()
+    assert p.integrate(x).to_expr() == q.integrate((x, 0, x))
+    assert p.integrate((x, 0, 1)) == q.integrate((x, 0, 1))
+    assert expr_to_holonomic(1/x, x0=1).integrate(x).to_expr() == log(x)
+    p = expr_to_holonomic((x + 1)**3*exp(-x), x0=-1).integrate(x).to_expr()
+    q = (-x**3 - 6*x**2 - 15*x + 6*exp(x + 1) - 16)*exp(-x)
+    assert p == q
+    p = expr_to_holonomic(cos(x)**2/x**2, y0={-2: [1, 0, -1]}).integrate(x).to_expr()
+    q = -Si(2*x) - cos(x)**2/x
+    assert p == q
+    p = expr_to_holonomic(sqrt(x**2+x)).integrate(x).to_expr()
+    q = (x**Rational(3, 2)*(2*x**2 + 3*x + 1) - x*sqrt(x + 1)*asinh(sqrt(x)))/(4*x*sqrt(x + 1))
+    assert p == q
+    p = expr_to_holonomic(sqrt(x**2+1)).integrate(x).to_expr()
+    q = (sqrt(x**2+1)).integrate(x)
+    assert (p-q).simplify() == 0
+    p = expr_to_holonomic(1/x**2, y0={-2:[1, 0, 0]})
+    r = expr_to_holonomic(1/x**2, lenics=3)
+    assert p == r
+    q = expr_to_holonomic(cos(x)**2)
+    assert (r*q).integrate(x).to_expr() == -Si(2*x) - cos(x)**2/x
+
+
+def test_diff():
+    x, y = symbols('x, y')
+    R, Dx = DifferentialOperators(ZZ.old_poly_ring(x), 'Dx')
+    p = HolonomicFunction(x*Dx**2 + 1, x, 0, [0, 1])
+    assert p.diff().to_expr() == p.to_expr().diff().simplify()
+    p = HolonomicFunction(Dx**2 - 1, x, 0, [1, 0])
+    assert p.diff(x, 2).to_expr() == p.to_expr()
+    p = expr_to_holonomic(Si(x))
+    assert p.diff().to_expr() == sin(x)/x
+    assert p.diff(y) == 0
+    C_0, C_1, C_2, C_3 = symbols('C_0, C_1, C_2, C_3')
+    q = Si(x)
+    assert p.diff(x).to_expr() == q.diff()
+    assert p.diff(x, 2).to_expr().subs(C_0, Rational(-1, 3)).cancel() == q.diff(x, 2).cancel()
+    assert p.diff(x, 3).series().subs({C_3: Rational(-1, 3), C_0: 0}) == q.diff(x, 3).series()
+
+
+def test_extended_domain_in_expr_to_holonomic():
+    x = symbols('x')
+    p = expr_to_holonomic(1.2*cos(3.1*x))
+    assert p.to_expr() == 1.2*cos(3.1*x)
+    assert sstr(p.integrate(x).to_expr()) == '0.387096774193548*sin(3.1*x)'
+    _, Dx = DifferentialOperators(RR.old_poly_ring(x), 'Dx')
+    p = expr_to_holonomic(1.1329138213*x)
+    q = HolonomicFunction((-1.1329138213) + (1.1329138213*x)*Dx, x, 0, {1: [1.1329138213]})
+    assert p == q
+    assert p.to_expr() == 1.1329138213*x
+    assert sstr(p.integrate((x, 1, 2))) == sstr((1.1329138213*x).integrate((x, 1, 2)))
+    y, z = symbols('y, z')
+    p = expr_to_holonomic(sin(x*y*z), x=x)
+    assert p.to_expr() == sin(x*y*z)
+    assert p.integrate(x).to_expr() == (-cos(x*y*z) + 1)/(y*z)
+    p = expr_to_holonomic(sin(x*y + z), x=x).integrate(x).to_expr()
+    q = (cos(z) - cos(x*y + z))/y
+    assert p == q
+    a = symbols('a')
+    p = expr_to_holonomic(a*x, x)
+    assert p.to_expr() == a*x
+    assert p.integrate(x).to_expr() == a*x**2/2
+    D_2, C_1 = symbols("D_2, C_1")
+    p = expr_to_holonomic(x) + expr_to_holonomic(1.2*cos(x))
+    p = p.to_expr().subs(D_2, 0)
+    assert p - x - 1.2*cos(1.0*x) == 0
+    p = expr_to_holonomic(x) * expr_to_holonomic(1.2*cos(x))
+    p = p.to_expr().subs(C_1, 0)
+    assert p - 1.2*x*cos(1.0*x) == 0
+
+
+def test_to_meijerg():
+    x = symbols('x')
+    assert hyperexpand(expr_to_holonomic(sin(x)).to_meijerg()) == sin(x)
+    assert hyperexpand(expr_to_holonomic(cos(x)).to_meijerg()) == cos(x)
+    assert hyperexpand(expr_to_holonomic(exp(x)).to_meijerg()) == exp(x)
+    assert hyperexpand(expr_to_holonomic(log(x)).to_meijerg()).simplify() == log(x)
+    assert expr_to_holonomic(4*x**2/3 + 7).to_meijerg() == 4*x**2/3 + 7
+    assert hyperexpand(expr_to_holonomic(besselj(2, x), lenics=3).to_meijerg()) == besselj(2, x)
+    p = hyper((Rational(-1, 2), -3), (), x)
+    assert from_hyper(p).to_meijerg() == hyperexpand(p)
+    p = hyper((S.One, S(3)), (S(2), ), x)
+    assert (hyperexpand(from_hyper(p).to_meijerg()) - hyperexpand(p)).expand() == 0
+    p = from_hyper(hyper((-2, -3), (S.Half, ), x))
+    s = hyperexpand(hyper((-2, -3), (S.Half, ), x))
+    C_0 = Symbol('C_0')
+    C_1 = Symbol('C_1')
+    D_0 = Symbol('D_0')
+    assert (hyperexpand(p.to_meijerg()).subs({C_0:1, D_0:0}) - s).simplify() == 0
+    p.y0 = {0: [1], S.Half: [0]}
+    assert (hyperexpand(p.to_meijerg()) - s).simplify() == 0
+    p = expr_to_holonomic(besselj(S.Half, x), initcond=False)
+    assert (p.to_expr() - (D_0*sin(x) + C_0*cos(x) + C_1*sin(x))/sqrt(x)).simplify() == 0
+    p = expr_to_holonomic(besselj(S.Half, x), y0={Rational(-1, 2): [sqrt(2)/sqrt(pi), sqrt(2)/sqrt(pi)]})
+    assert (p.to_expr() - besselj(S.Half, x) - besselj(Rational(-1, 2), x)).simplify() == 0
+
+
+def test_gaussian():
+    mu, x = symbols("mu x")
+    sd = symbols("sd", positive=True)
+    Q = QQ[mu, sd].get_field()
+    e = sqrt(2)*exp(-(-mu + x)**2/(2*sd**2))/(2*sqrt(pi)*sd)
+    h1 = expr_to_holonomic(e, x, domain=Q)
+
+    _, Dx = DifferentialOperators(Q.old_poly_ring(x), 'Dx')
+    h2 = HolonomicFunction((-mu/sd**2 + x/sd**2) + (1)*Dx, x)
+
+    assert h1 == h2
+
+
+def test_beta():
+    a, b, x = symbols("a b x", positive=True)
+    e = x**(a - 1)*(-x + 1)**(b - 1)/beta(a, b)
+    Q = QQ[a, b].get_field()
+    h1 = expr_to_holonomic(e, x, domain=Q)
+
+    _, Dx = DifferentialOperators(Q.old_poly_ring(x), 'Dx')
+    h2 = HolonomicFunction((a + x*(-a - b + 2) - 1) + (x**2 - x)*Dx, x)
+
+    assert h1 == h2
+
+
+def test_gamma():
+    a, b, x = symbols("a b x", positive=True)
+    e = b**(-a)*x**(a - 1)*exp(-x/b)/gamma(a)
+    Q = QQ[a, b].get_field()
+    h1 = expr_to_holonomic(e, x, domain=Q)
+
+    _, Dx = DifferentialOperators(Q.old_poly_ring(x), 'Dx')
+    h2 = HolonomicFunction((-a + 1 + x/b) + (x)*Dx, x)
+
+    assert h1 == h2
+
+
+def test_symbolic_power():
+    x, n = symbols("x n")
+    Q = QQ[n].get_field()
+    _, Dx = DifferentialOperators(Q.old_poly_ring(x), 'Dx')
+    h1 = HolonomicFunction((-1) + (x)*Dx, x) ** -n
+    h2 = HolonomicFunction((n) + (x)*Dx, x)
+
+    assert h1 == h2
+
+
+def test_negative_power():
+    x = symbols("x")
+    _, Dx = DifferentialOperators(QQ.old_poly_ring(x), 'Dx')
+    h1 = HolonomicFunction((-1) + (x)*Dx, x) ** -2
+    h2 = HolonomicFunction((2) + (x)*Dx, x)
+
+    assert h1 == h2
+
+
+def test_expr_in_power():
+    x, n = symbols("x n")
+    Q = QQ[n].get_field()
+    _, Dx = DifferentialOperators(Q.old_poly_ring(x), 'Dx')
+    h1 = HolonomicFunction((-1) + (x)*Dx, x) ** (n - 3)
+    h2 = HolonomicFunction((-n + 3) + (x)*Dx, x)
+
+    assert h1 == h2
+
+
+def test_DifferentialOperatorEqPoly():
+    x = symbols('x', integer=True)
+    R, Dx = DifferentialOperators(QQ.old_poly_ring(x), 'Dx')
+    do = DifferentialOperator([x**2, R.base.zero, R.base.zero], R)
+    do2 = DifferentialOperator([x**2, 1, x], R)
+    assert not do == do2
+
+    # polynomial comparison issue, see https://github.com/sympy/sympy/pull/15799
+    # should work once that is solved
+    # p = do.listofpoly[0]
+    # assert do == p
+
+    p2 = do2.listofpoly[0]
+    assert not do2 == p2
+
+
+def test_DifferentialOperatorPow():
+    x = symbols('x', integer=True)
+    R, _ = DifferentialOperators(QQ.old_poly_ring(x), 'Dx')
+    do = DifferentialOperator([x**2, R.base.zero, R.base.zero], R)
+    a = DifferentialOperator([R.base.one], R)
+    for n in range(10):
+        assert a == do**n
+        a *= do

.venv/lib/python3.12/site-packages/sympy/holonomic/tests/test_recurrence.py

@@ -0,0 +1,41 @@
+from sympy.holonomic.recurrence import RecurrenceOperators, RecurrenceOperator
+from sympy.core.symbol import symbols
+from sympy.polys.domains.rationalfield import QQ
+
+
+def test_RecurrenceOperator():
+    n = symbols('n', integer=True)
+    R, Sn = RecurrenceOperators(QQ.old_poly_ring(n), 'Sn')
+    assert Sn*n == (n + 1)*Sn
+    assert Sn*n**2 == (n**2+1+2*n)*Sn
+    assert Sn**2*n**2 == (n**2 + 4*n + 4)*Sn**2
+    p = (Sn**3*n**2 + Sn*n)**2
+    q = (n**2 + 3*n + 2)*Sn**2 + (2*n**3 + 19*n**2 + 57*n + 52)*Sn**4 + (n**4 + 18*n**3 + \
+        117*n**2 + 324*n + 324)*Sn**6
+    assert p == q
+
+
+def test_RecurrenceOperatorEqPoly():
+    n = symbols('n', integer=True)
+    R, Sn = RecurrenceOperators(QQ.old_poly_ring(n), 'Sn')
+    rr = RecurrenceOperator([n**2, 0, 0], R)
+    rr2 = RecurrenceOperator([n**2, 1, n], R)
+    assert not rr == rr2
+
+    # polynomial comparison issue, see https://github.com/sympy/sympy/pull/15799
+    # should work once that is solved
+    # d = rr.listofpoly[0]
+    # assert rr == d
+
+    d2 = rr2.listofpoly[0]
+    assert not rr2 == d2
+
+
+def test_RecurrenceOperatorPow():
+    n = symbols('n', integer=True)
+    R, _ = RecurrenceOperators(QQ.old_poly_ring(n), 'Sn')
+    rr = RecurrenceOperator([n**2, 0, 0], R)
+    a = RecurrenceOperator([R.base.one], R)
+    for m in range(10):
+        assert a == rr**m
+        a *= rr

.venv/lib/python3.12/site-packages/sympy/integrals/__init__.py

@@ -0,0 +1,45 @@
+"""Integration functions that integrate a SymPy expression.
+
+    Examples
+    ========
+
+    >>> from sympy import integrate, sin
+    >>> from sympy.abc import x
+    >>> integrate(1/x,x)
+    log(x)
+    >>> integrate(sin(x),x)
+    -cos(x)
+"""
+from .integrals import integrate, Integral, line_integrate
+from .transforms import (mellin_transform, inverse_mellin_transform,
+                        MellinTransform, InverseMellinTransform,
+                        laplace_transform, inverse_laplace_transform,
+                        laplace_correspondence, laplace_initial_conds,
+                        LaplaceTransform, InverseLaplaceTransform,
+                        fourier_transform, inverse_fourier_transform,
+                        FourierTransform, InverseFourierTransform,
+                        sine_transform, inverse_sine_transform,
+                        SineTransform, InverseSineTransform,
+                        cosine_transform, inverse_cosine_transform,
+                        CosineTransform, InverseCosineTransform,
+                        hankel_transform, inverse_hankel_transform,
+                        HankelTransform, InverseHankelTransform)
+from .singularityfunctions import singularityintegrate
+
+__all__ = [
+    'integrate', 'Integral', 'line_integrate',
+
+    'mellin_transform', 'inverse_mellin_transform', 'MellinTransform',
+    'InverseMellinTransform', 'laplace_transform',
+    'inverse_laplace_transform', 'LaplaceTransform',
+    'laplace_correspondence', 'laplace_initial_conds',
+    'InverseLaplaceTransform', 'fourier_transform',
+    'inverse_fourier_transform', 'FourierTransform',
+    'InverseFourierTransform', 'sine_transform', 'inverse_sine_transform',
+    'SineTransform', 'InverseSineTransform', 'cosine_transform',
+    'inverse_cosine_transform', 'CosineTransform', 'InverseCosineTransform',
+    'hankel_transform', 'inverse_hankel_transform', 'HankelTransform',
+    'InverseHankelTransform',
+
+    'singularityintegrate',
+]

.venv/lib/python3.12/site-packages/sympy/integrals/__pycache__/laplace.cpython-312.pyc

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

.venv/lib/python3.12/site-packages/sympy/integrals/__pycache__/manualintegrate.cpython-312.pyc

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

.venv/lib/python3.12/site-packages/sympy/integrals/__pycache__/meijerint.cpython-312.pyc

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

.venv/lib/python3.12/site-packages/sympy/integrals/benchmarks/bench_integrate.py

@@ -0,0 +1,21 @@
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.trigonometric import sin
+from sympy.integrals.integrals import integrate
+
+x = Symbol('x')
+
+
+def bench_integrate_sin():
+    integrate(sin(x), x)
+
+
+def bench_integrate_x1sin():
+    integrate(x**1*sin(x), x)
+
+
+def bench_integrate_x2sin():
+    integrate(x**2*sin(x), x)
+
+
+def bench_integrate_x3sin():
+    integrate(x**3*sin(x), x)

.venv/lib/python3.12/site-packages/sympy/integrals/benchmarks/bench_trigintegrate.py

@@ -0,0 +1,13 @@
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.trigonometric import sin
+from sympy.integrals.trigonometry import trigintegrate
+
+x = Symbol('x')
+
+
+def timeit_trigintegrate_sin3x():
+    trigintegrate(sin(x)**3, x)
+
+
+def timeit_trigintegrate_x2():
+    trigintegrate(x**2, x)  # -> None

.venv/lib/python3.12/site-packages/sympy/integrals/deltafunctions.py

@@ -0,0 +1,201 @@
+from sympy.core.mul import Mul
+from sympy.core.singleton import S
+from sympy.core.sorting import default_sort_key
+from sympy.functions import DiracDelta, Heaviside
+from .integrals import Integral, integrate
+
+
+def change_mul(node, x):
+    """change_mul(node, x)
+
+       Rearranges the operands of a product, bringing to front any simple
+       DiracDelta expression.
+
+       Explanation
+       ===========
+
+       If no simple DiracDelta expression was found, then all the DiracDelta
+       expressions are simplified (using DiracDelta.expand(diracdelta=True, wrt=x)).
+
+       Return: (dirac, new node)
+       Where:
+         o dirac is either a simple DiracDelta expression or None (if no simple
+           expression was found);
+         o new node is either a simplified DiracDelta expressions or None (if it
+           could not be simplified).
+
+       Examples
+       ========
+
+       >>> from sympy import DiracDelta, cos
+       >>> from sympy.integrals.deltafunctions import change_mul
+       >>> from sympy.abc import x, y
+       >>> change_mul(x*y*DiracDelta(x)*cos(x), x)
+       (DiracDelta(x), x*y*cos(x))
+       >>> change_mul(x*y*DiracDelta(x**2 - 1)*cos(x), x)
+       (None, x*y*cos(x)*DiracDelta(x - 1)/2 + x*y*cos(x)*DiracDelta(x + 1)/2)
+       >>> change_mul(x*y*DiracDelta(cos(x))*cos(x), x)
+       (None, None)
+
+       See Also
+       ========
+
+       sympy.functions.special.delta_functions.DiracDelta
+       deltaintegrate
+    """
+
+    new_args = []
+    dirac = None
+
+    #Sorting is needed so that we consistently collapse the same delta;
+    #However, we must preserve the ordering of non-commutative terms
+    c, nc = node.args_cnc()
+    sorted_args = sorted(c, key=default_sort_key)
+    sorted_args.extend(nc)
+
+    for arg in sorted_args:
+        if arg.is_Pow and isinstance(arg.base, DiracDelta):
+            new_args.append(arg.func(arg.base, arg.exp - 1))
+            arg = arg.base
+        if dirac is None and (isinstance(arg, DiracDelta) and arg.is_simple(x)):
+            dirac = arg
+        else:
+            new_args.append(arg)
+    if not dirac:  # there was no simple dirac
+        new_args = []
+        for arg in sorted_args:
+            if isinstance(arg, DiracDelta):
+                new_args.append(arg.expand(diracdelta=True, wrt=x))
+            elif arg.is_Pow and isinstance(arg.base, DiracDelta):
+                new_args.append(arg.func(arg.base.expand(diracdelta=True, wrt=x), arg.exp))
+            else:
+                new_args.append(arg)
+        if new_args != sorted_args:
+            nnode = Mul(*new_args).expand()
+        else:  # if the node didn't change there is nothing to do
+            nnode = None
+        return (None, nnode)
+    return (dirac, Mul(*new_args))
+
+
+def deltaintegrate(f, x):
+    """
+    deltaintegrate(f, x)
+
+    Explanation
+    ===========
+
+    The idea for integration is the following:
+
+    - If we are dealing with a DiracDelta expression, i.e. DiracDelta(g(x)),
+      we try to simplify it.
+
+      If we could simplify it, then we integrate the resulting expression.
+      We already know we can integrate a simplified expression, because only
+      simple DiracDelta expressions are involved.
+
+      If we couldn't simplify it, there are two cases:
+
+      1) The expression is a simple expression: we return the integral,
+         taking care if we are dealing with a Derivative or with a proper
+         DiracDelta.
+
+      2) The expression is not simple (i.e. DiracDelta(cos(x))): we can do
+         nothing at all.
+
+    - If the node is a multiplication node having a DiracDelta term:
+
+      First we expand it.
+
+      If the expansion did work, then we try to integrate the expansion.
+
+      If not, we try to extract a simple DiracDelta term, then we have two
+      cases:
+
+      1) We have a simple DiracDelta term, so we return the integral.
+
+      2) We didn't have a simple term, but we do have an expression with
+         simplified DiracDelta terms, so we integrate this expression.
+
+    Examples
+    ========
+
+        >>> from sympy.abc import x, y, z
+        >>> from sympy.integrals.deltafunctions import deltaintegrate
+        >>> from sympy import sin, cos, DiracDelta
+        >>> deltaintegrate(x*sin(x)*cos(x)*DiracDelta(x - 1), x)
+        sin(1)*cos(1)*Heaviside(x - 1)
+        >>> deltaintegrate(y**2*DiracDelta(x - z)*DiracDelta(y - z), y)
+        z**2*DiracDelta(x - z)*Heaviside(y - z)
+
+    See Also
+    ========
+
+    sympy.functions.special.delta_functions.DiracDelta
+    sympy.integrals.integrals.Integral
+    """
+    if not f.has(DiracDelta):
+        return None
+
+    # g(x) = DiracDelta(h(x))
+    if f.func == DiracDelta:
+        h = f.expand(diracdelta=True, wrt=x)
+        if h == f:  # can't simplify the expression
+            #FIXME: the second term tells whether is DeltaDirac or Derivative
+            #For integrating derivatives of DiracDelta we need the chain rule
+            if f.is_simple(x):
+                if (len(f.args) <= 1 or f.args[1] == 0):
+                    return Heaviside(f.args[0])
+                else:
+                    return (DiracDelta(f.args[0], f.args[1] - 1) /
+                        f.args[0].as_poly().LC())
+        else:  # let's try to integrate the simplified expression
+            fh = integrate(h, x)
+            return fh
+    elif f.is_Mul or f.is_Pow:  # g(x) = a*b*c*f(DiracDelta(h(x)))*d*e
+        g = f.expand()
+        if f != g:  # the expansion worked
+            fh = integrate(g, x)
+            if fh is not None and not isinstance(fh, Integral):
+                return fh
+        else:
+            # no expansion performed, try to extract a simple DiracDelta term
+            deltaterm, rest_mult = change_mul(f, x)
+
+            if not deltaterm:
+                if rest_mult:
+                    fh = integrate(rest_mult, x)
+                    return fh
+            else:
+                from sympy.solvers import solve
+                deltaterm = deltaterm.expand(diracdelta=True, wrt=x)
+                if deltaterm.is_Mul:  # Take out any extracted factors
+                    deltaterm, rest_mult_2 = change_mul(deltaterm, x)
+                    rest_mult = rest_mult*rest_mult_2
+                point = solve(deltaterm.args[0], x)[0]
+
+                # Return the largest hyperreal term left after
+                # repeated integration by parts.  For example,
+                #
+                #   integrate(y*DiracDelta(x, 1),x) == y*DiracDelta(x,0),  not 0
+                #
+                # This is so Integral(y*DiracDelta(x).diff(x),x).doit()
+                # will return y*DiracDelta(x) instead of 0 or DiracDelta(x),
+                # both of which are correct everywhere the value is defined
+                # but give wrong answers for nested integration.
+                n = (0 if len(deltaterm.args)==1 else deltaterm.args[1])
+                m = 0
+                while n >= 0:
+                    r = S.NegativeOne**n*rest_mult.diff(x, n).subs(x, point)
+                    if r.is_zero:
+                        n -= 1
+                        m += 1
+                    else:
+                        if m == 0:
+                            return r*Heaviside(x - point)
+                        else:
+                            return r*DiracDelta(x,m-1)
+                # In some very weak sense, x=0 is still a singularity,
+                # but we hope will not be of any practical consequence.
+                return S.Zero
+    return None

.venv/lib/python3.12/site-packages/sympy/integrals/heurisch.py

@@ -0,0 +1,781 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from functools import reduce
+from itertools import permutations
+
+from sympy.core.add import Add
+from sympy.core.basic import Basic
+from sympy.core.mul import Mul
+from sympy.core.symbol import Wild, Dummy, Symbol
+from sympy.core.basic import sympify
+from sympy.core.numbers import Rational, pi, I
+from sympy.core.relational import Eq, Ne
+from sympy.core.singleton import S
+from sympy.core.sorting import ordered
+from sympy.core.traversal import iterfreeargs
+
+from sympy.functions import exp, sin, cos, tan, cot, asin, atan
+from sympy.functions import log, sinh, cosh, tanh, coth, asinh
+from sympy.functions import sqrt, erf, erfi, li, Ei
+from sympy.functions import besselj, bessely, besseli, besselk
+from sympy.functions import hankel1, hankel2, jn, yn
+from sympy.functions.elementary.complexes import Abs, re, im, sign, arg
+from sympy.functions.elementary.exponential import LambertW
+from sympy.functions.elementary.integers import floor, ceiling
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.delta_functions import Heaviside, DiracDelta
+
+from sympy.simplify.radsimp import collect
+
+from sympy.logic.boolalg import And, Or
+from sympy.utilities.iterables import uniq
+
+from sympy.polys import quo, gcd, lcm, factor_list, cancel, PolynomialError
+from sympy.polys.monomials import itermonomials
+from sympy.polys.polyroots import root_factors
+
+from sympy.polys.rings import PolyRing
+from sympy.polys.solvers import solve_lin_sys
+from sympy.polys.constructor import construct_domain
+
+from sympy.integrals.integrals import integrate
+
+
+def components(f, x):
+    """
+    Returns a set of all functional components of the given expression
+    which includes symbols, function applications and compositions and
+    non-integer powers. Fractional powers are collected with
+    minimal, positive exponents.
+
+    Examples
+    ========
+
+    >>> from sympy import cos, sin
+    >>> from sympy.abc import x
+    >>> from sympy.integrals.heurisch import components
+
+    >>> components(sin(x)*cos(x)**2, x)
+    {x, sin(x), cos(x)}
+
+    See Also
+    ========
+
+    heurisch
+    """
+    result = set()
+
+    if f.has_free(x):
+        if f.is_symbol and f.is_commutative:
+            result.add(f)
+        elif f.is_Function or f.is_Derivative:
+            for g in f.args:
+                result |= components(g, x)
+
+            result.add(f)
+        elif f.is_Pow:
+            result |= components(f.base, x)
+
+            if not f.exp.is_Integer:
+                if f.exp.is_Rational:
+                    result.add(f.base**Rational(1, f.exp.q))
+                else:
+                    result |= components(f.exp, x) | {f}
+        else:
+            for g in f.args:
+                result |= components(g, x)
+
+    return result
+
+# name -> [] of symbols
+_symbols_cache: dict[str, list[Dummy]] = {}
+
+
+# NB @cacheit is not convenient here
+def _symbols(name, n):
+    """get vector of symbols local to this module"""
+    try:
+        lsyms = _symbols_cache[name]
+    except KeyError:
+        lsyms = []
+        _symbols_cache[name] = lsyms
+
+    while len(lsyms) < n:
+        lsyms.append( Dummy('%s%i' % (name, len(lsyms))) )
+
+    return lsyms[:n]
+
+
+def heurisch_wrapper(f, x, rewrite=False, hints=None, mappings=None, retries=3,
+                     degree_offset=0, unnecessary_permutations=None,
+                     _try_heurisch=None):
+    """
+    A wrapper around the heurisch integration algorithm.
+
+    Explanation
+    ===========
+
+    This method takes the result from heurisch and checks for poles in the
+    denominator. For each of these poles, the integral is reevaluated, and
+    the final integration result is given in terms of a Piecewise.
+
+    Examples
+    ========
+
+    >>> from sympy import cos, symbols
+    >>> from sympy.integrals.heurisch import heurisch, heurisch_wrapper
+    >>> n, x = symbols('n x')
+    >>> heurisch(cos(n*x), x)
+    sin(n*x)/n
+    >>> heurisch_wrapper(cos(n*x), x)
+    Piecewise((sin(n*x)/n, Ne(n, 0)), (x, True))
+
+    See Also
+    ========
+
+    heurisch
+    """
+    from sympy.solvers.solvers import solve, denoms
+    f = sympify(f)
+    if not f.has_free(x):
+        return f*x
+
+    res = heurisch(f, x, rewrite, hints, mappings, retries, degree_offset,
+                   unnecessary_permutations, _try_heurisch)
+    if not isinstance(res, Basic):
+        return res
+
+    # We consider each denominator in the expression, and try to find
+    # cases where one or more symbolic denominator might be zero. The
+    # conditions for these cases are stored in the list slns.
+    #
+    # Since denoms returns a set we use ordered. This is important because the
+    # ordering of slns determines the order of the resulting Piecewise so we
+    # need a deterministic order here to make the output deterministic.
+    slns = []
+    for d in ordered(denoms(res)):
+        try:
+            slns += solve([d], dict=True, exclude=(x,))
+        except NotImplementedError:
+            pass
+    if not slns:
+        return res
+    slns = list(uniq(slns))
+    # Remove the solutions corresponding to poles in the original expression.
+    slns0 = []
+    for d in denoms(f):
+        try:
+            slns0 += solve([d], dict=True, exclude=(x,))
+        except NotImplementedError:
+            pass
+    slns = [s for s in slns if s not in slns0]
+    if not slns:
+        return res
+    if len(slns) > 1:
+        eqs = []
+        for sub_dict in slns:
+            eqs.extend([Eq(key, value) for key, value in sub_dict.items()])
+        slns = solve(eqs, dict=True, exclude=(x,)) + slns
+    # For each case listed in the list slns, we reevaluate the integral.
+    pairs = []
+    for sub_dict in slns:
+        expr = heurisch(f.subs(sub_dict), x, rewrite, hints, mappings, retries,
+                        degree_offset, unnecessary_permutations,
+                        _try_heurisch)
+        cond = And(*[Eq(key, value) for key, value in sub_dict.items()])
+        generic = Or(*[Ne(key, value) for key, value in sub_dict.items()])
+        if expr is None:
+            expr = integrate(f.subs(sub_dict),x)
+        pairs.append((expr, cond))
+    # If there is one condition, put the generic case first. Otherwise,
+    # doing so may lead to longer Piecewise formulas
+    if len(pairs) == 1:
+        pairs = [(heurisch(f, x, rewrite, hints, mappings, retries,
+                              degree_offset, unnecessary_permutations,
+                              _try_heurisch),
+                              generic),
+                 (pairs[0][0], True)]
+    else:
+        pairs.append((heurisch(f, x, rewrite, hints, mappings, retries,
+                              degree_offset, unnecessary_permutations,
+                              _try_heurisch),
+                              True))
+    return Piecewise(*pairs)
+
+class BesselTable:
+    """
+    Derivatives of Bessel functions of orders n and n-1
+    in terms of each other.
+
+    See the docstring of DiffCache.
+    """
+
+    def __init__(self):
+        self.table = {}
+        self.n = Dummy('n')
+        self.z = Dummy('z')
+        self._create_table()
+
+    def _create_table(t):
+        table, n, z = t.table, t.n, t.z
+        for f in (besselj, bessely, hankel1, hankel2):
+            table[f] = (f(n-1, z) - n*f(n, z)/z,
+                        (n-1)*f(n-1, z)/z - f(n, z))
+
+        f = besseli
+        table[f] = (f(n-1, z) - n*f(n, z)/z,
+                    (n-1)*f(n-1, z)/z + f(n, z))
+        f = besselk
+        table[f] = (-f(n-1, z) - n*f(n, z)/z,
+                    (n-1)*f(n-1, z)/z - f(n, z))
+
+        for f in (jn, yn):
+            table[f] = (f(n-1, z) - (n+1)*f(n, z)/z,
+                        (n-1)*f(n-1, z)/z - f(n, z))
+
+    def diffs(t, f, n, z):
+        if f in t.table:
+            diff0, diff1 = t.table[f]
+            repl = [(t.n, n), (t.z, z)]
+            return (diff0.subs(repl), diff1.subs(repl))
+
+    def has(t, f):
+        return f in t.table
+
+_bessel_table = None
+
+class DiffCache:
+    """
+    Store for derivatives of expressions.
+
+    Explanation
+    ===========
+
+    The standard form of the derivative of a Bessel function of order n
+    contains two Bessel functions of orders n-1 and n+1, respectively.
+    Such forms cannot be used in parallel Risch algorithm, because
+    there is a linear recurrence relation between the three functions
+    while the algorithm expects that functions and derivatives are
+    represented in terms of algebraically independent transcendentals.
+
+    The solution is to take two of the functions, e.g., those of orders
+    n and n-1, and to express the derivatives in terms of the pair.
+    To guarantee that the proper form is used the two derivatives are
+    cached as soon as one is encountered.
+
+    Derivatives of other functions are also cached at no extra cost.
+    All derivatives are with respect to the same variable `x`.
+    """
+
+    def __init__(self, x):
+        self.cache = {}
+        self.x = x
+
+        global _bessel_table
+        if not _bessel_table:
+            _bessel_table = BesselTable()
+
+    def get_diff(self, f):
+        cache = self.cache
+
+        if f in cache:
+            pass
+        elif (not hasattr(f, 'func') or
+            not _bessel_table.has(f.func)):
+            cache[f] = cancel(f.diff(self.x))
+        else:
+            n, z = f.args
+            d0, d1 = _bessel_table.diffs(f.func, n, z)
+            dz = self.get_diff(z)
+            cache[f] = d0*dz
+            cache[f.func(n-1, z)] = d1*dz
+
+        return cache[f]
+
+def heurisch(f, x, rewrite=False, hints=None, mappings=None, retries=3,
+             degree_offset=0, unnecessary_permutations=None,
+             _try_heurisch=None):
+    """
+    Compute indefinite integral using heuristic Risch algorithm.
+
+    Explanation
+    ===========
+
+    This is a heuristic approach to indefinite integration in finite
+    terms using the extended heuristic (parallel) Risch algorithm, based
+    on Manuel Bronstein's "Poor Man's Integrator".
+
+    The algorithm supports various classes of functions including
+    transcendental elementary or special functions like Airy,
+    Bessel, Whittaker and Lambert.
+
+    Note that this algorithm is not a decision procedure. If it isn't
+    able to compute the antiderivative for a given function, then this is
+    not a proof that such a functions does not exist.  One should use
+    recursive Risch algorithm in such case.  It's an open question if
+    this algorithm can be made a full decision procedure.
+
+    This is an internal integrator procedure. You should use top level
+    'integrate' function in most cases, as this procedure needs some
+    preprocessing steps and otherwise may fail.
+
+    Specification
+    =============
+
+     heurisch(f, x, rewrite=False, hints=None)
+
+       where
+         f : expression
+         x : symbol
+
+         rewrite -> force rewrite 'f' in terms of 'tan' and 'tanh'
+         hints   -> a list of functions that may appear in anti-derivate
+
+          - hints = None          --> no suggestions at all
+          - hints = [ ]           --> try to figure out
+          - hints = [f1, ..., fn] --> we know better
+
+    Examples
+    ========
+
+    >>> from sympy import tan
+    >>> from sympy.integrals.heurisch import heurisch
+    >>> from sympy.abc import x, y
+
+    >>> heurisch(y*tan(x), x)
+    y*log(tan(x)**2 + 1)/2
+
+    See Manuel Bronstein's "Poor Man's Integrator":
+
+    References
+    ==========
+
+    .. [1] https://www-sop.inria.fr/cafe/Manuel.Bronstein/pmint/index.html
+
+    For more information on the implemented algorithm refer to:
+
+    .. [2] K. Geddes, L. Stefanus, On the Risch-Norman Integration
+       Method and its Implementation in Maple, Proceedings of
+       ISSAC'89, ACM Press, 212-217.
+
+    .. [3] J. H. Davenport, On the Parallel Risch Algorithm (I),
+       Proceedings of EUROCAM'82, LNCS 144, Springer, 144-157.
+
+    .. [4] J. H. Davenport, On the Parallel Risch Algorithm (III):
+       Use of Tangents, SIGSAM Bulletin 16 (1982), 3-6.
+
+    .. [5] J. H. Davenport, B. M. Trager, On the Parallel Risch
+       Algorithm (II), ACM Transactions on Mathematical
+       Software 11 (1985), 356-362.
+
+    See Also
+    ========
+
+    sympy.integrals.integrals.Integral.doit
+    sympy.integrals.integrals.Integral
+    sympy.integrals.heurisch.components
+    """
+    f = sympify(f)
+
+    # There are some functions that Heurisch cannot currently handle,
+    # so do not even try.
+    # Set _try_heurisch=True to skip this check
+    if _try_heurisch is not True:
+        if f.has(Abs, re, im, sign, Heaviside, DiracDelta, floor, ceiling, arg):
+            return
+
+    if not f.has_free(x):
+        return f*x
+
+    if not f.is_Add:
+        indep, f = f.as_independent(x)
+    else:
+        indep = S.One
+
+    rewritables = {
+        (sin, cos, cot): tan,
+        (sinh, cosh, coth): tanh,
+    }
+
+    if rewrite:
+        for candidates, rule in rewritables.items():
+            f = f.rewrite(candidates, rule)
+    else:
+        for candidates in rewritables.keys():
+            if f.has(*candidates):
+                break
+        else:
+            rewrite = True
+
+    terms = components(f, x)
+    dcache = DiffCache(x)
+
+    if hints is not None:
+        if not hints:
+            a = Wild('a', exclude=[x])
+            b = Wild('b', exclude=[x])
+            c = Wild('c', exclude=[x])
+
+            for g in set(terms):  # using copy of terms
+                if g.is_Function:
+                    if isinstance(g, li):
+                        M = g.args[0].match(a*x**b)
+
+                        if M is not None:
+                            terms.add( x*(li(M[a]*x**M[b]) - (M[a]*x**M[b])**(-1/M[b])*Ei((M[b]+1)*log(M[a]*x**M[b])/M[b])) )
+                            #terms.add( x*(li(M[a]*x**M[b]) - (x**M[b])**(-1/M[b])*Ei((M[b]+1)*log(M[a]*x**M[b])/M[b])) )
+                            #terms.add( x*(li(M[a]*x**M[b]) - x*Ei((M[b]+1)*log(M[a]*x**M[b])/M[b])) )
+                            #terms.add( li(M[a]*x**M[b]) - Ei((M[b]+1)*log(M[a]*x**M[b])/M[b]) )
+
+                    elif isinstance(g, exp):
+                        M = g.args[0].match(a*x**2)
+
+                        if M is not None:
+                            if M[a].is_positive:
+                                terms.add(erfi(sqrt(M[a])*x))
+                            else: # M[a].is_negative or unknown
+                                terms.add(erf(sqrt(-M[a])*x))
+
+                        M = g.args[0].match(a*x**2 + b*x + c)
+
+                        if M is not None:
+                            if M[a].is_positive:
+                                terms.add(sqrt(pi/4*(-M[a]))*exp(M[c] - M[b]**2/(4*M[a]))*
+                                          erfi(sqrt(M[a])*x + M[b]/(2*sqrt(M[a]))))
+                            elif M[a].is_negative:
+                                terms.add(sqrt(pi/4*(-M[a]))*exp(M[c] - M[b]**2/(4*M[a]))*
+                                          erf(sqrt(-M[a])*x - M[b]/(2*sqrt(-M[a]))))
+
+                        M = g.args[0].match(a*log(x)**2)
+
+                        if M is not None:
+                            if M[a].is_positive:
+                                terms.add(erfi(sqrt(M[a])*log(x) + 1/(2*sqrt(M[a]))))
+                            if M[a].is_negative:
+                                terms.add(erf(sqrt(-M[a])*log(x) - 1/(2*sqrt(-M[a]))))
+
+                elif g.is_Pow:
+                    if g.exp.is_Rational and g.exp.q == 2:
+                        M = g.base.match(a*x**2 + b)
+
+                        if M is not None and M[b].is_positive:
+                            if M[a].is_positive:
+                                terms.add(asinh(sqrt(M[a]/M[b])*x))
+                            elif M[a].is_negative:
+                                terms.add(asin(sqrt(-M[a]/M[b])*x))
+
+                        M = g.base.match(a*x**2 - b)
+
+                        if M is not None and M[b].is_positive:
+                            if M[a].is_positive:
+                                dF = 1/sqrt(M[a]*x**2 - M[b])
+                                F = log(2*sqrt(M[a])*sqrt(M[a]*x**2 - M[b]) + 2*M[a]*x)/sqrt(M[a])
+                                dcache.cache[F] = dF  # hack: F.diff(x) doesn't automatically simplify to f
+                                terms.add(F)
+                            elif M[a].is_negative:
+                                terms.add(-M[b]/2*sqrt(-M[a])*
+                                           atan(sqrt(-M[a])*x/sqrt(M[a]*x**2 - M[b])))
+
+        else:
+            terms |= set(hints)
+
+    for g in set(terms):  # using copy of terms
+        terms |= components(dcache.get_diff(g), x)
+
+    # XXX: The commented line below makes heurisch more deterministic wrt
+    # PYTHONHASHSEED and the iteration order of sets. There are other places
+    # where sets are iterated over but this one is possibly the most important.
+    # Theoretically the order here should not matter but different orderings
+    # can expose potential bugs in the different code paths so potentially it
+    # is better to keep the non-determinism.
+    #
+    # terms = list(ordered(terms))
+
+    # TODO: caching is significant factor for why permutations work at all. Change this.
+    V = _symbols('x', len(terms))
+
+
+    # sort mapping expressions from largest to smallest (last is always x).
+    mapping = list(reversed(list(zip(*ordered(                          #
+        [(a[0].as_independent(x)[1], a) for a in zip(terms, V)])))[1])) #
+    rev_mapping = {v: k for k, v in mapping}                            #
+    if mappings is None:                                                #
+        # optimizing the number of permutations of mapping              #
+        assert mapping[-1][0] == x # if not, find it and correct this comment
+        unnecessary_permutations = [mapping.pop(-1)]
+        # permute types of objects
+        types = defaultdict(list)
+        for i in mapping:
+            e, _ = i
+            types[type(e)].append(i)
+        mapping = [types[i] for i in types]
+        def _iter_mappings():
+            for i in permutations(mapping):
+                # make the expression of a given type be ordered
+                yield [j for i in i for j in ordered(i)]
+        mappings = _iter_mappings()
+    else:
+        unnecessary_permutations = unnecessary_permutations or []
+
+    def _substitute(expr):
+        return expr.subs(mapping)
+
+    for mapping in mappings:
+        mapping = list(mapping)
+        mapping = mapping + unnecessary_permutations
+        diffs = [ _substitute(dcache.get_diff(g)) for g in terms ]
+        denoms = [ g.as_numer_denom()[1] for g in diffs ]
+        if all(h.is_polynomial(*V) for h in denoms) and _substitute(f).is_rational_function(*V):
+            denom = reduce(lambda p, q: lcm(p, q, *V), denoms)
+            break
+    else:
+        if not rewrite:
+            result = heurisch(f, x, rewrite=True, hints=hints,
+                unnecessary_permutations=unnecessary_permutations)
+
+            if result is not None:
+                return indep*result
+        return None
+
+    numers = [ cancel(denom*g) for g in diffs ]
+    def _derivation(h):
+        return Add(*[ d * h.diff(v) for d, v in zip(numers, V) ])
+
+    def _deflation(p):
+        for y in V:
+            if not p.has(y):
+                continue
+
+            if _derivation(p) is not S.Zero:
+                c, q = p.as_poly(y).primitive()
+                return _deflation(c)*gcd(q, q.diff(y)).as_expr()
+
+        return p
+
+    def _splitter(p):
+        for y in V:
+            if not p.has(y):
+                continue
+
+            if _derivation(y) is not S.Zero:
+                c, q = p.as_poly(y).primitive()
+
+                q = q.as_expr()
+
+                h = gcd(q, _derivation(q), y)
+                s = quo(h, gcd(q, q.diff(y), y), y)
+
+                c_split = _splitter(c)
+
+                if s.as_poly(y).degree() == 0:
+                    return (c_split[0], q * c_split[1])
+
+                q_split = _splitter(cancel(q / s))
+
+                return (c_split[0]*q_split[0]*s, c_split[1]*q_split[1])
+
+        return (S.One, p)
+
+    special = {}
+
+    for term in terms:
+        if term.is_Function:
+            if isinstance(term, tan):
+                special[1 + _substitute(term)**2] = False
+            elif isinstance(term, tanh):
+                special[1 + _substitute(term)] = False
+                special[1 - _substitute(term)] = False
+            elif isinstance(term, LambertW):
+                special[_substitute(term)] = True
+
+    F = _substitute(f)
+
+    P, Q = F.as_numer_denom()
+
+    u_split = _splitter(denom)
+    v_split = _splitter(Q)
+
+    polys = set(list(v_split) + [ u_split[0] ] + list(special.keys()))
+
+    s = u_split[0] * Mul(*[ k for k, v in special.items() if v ])
+    polified = [ p.as_poly(*V) for p in [s, P, Q] ]
+
+    if None in polified:
+        return None
+
+    #--- definitions for _integrate
+    a, b, c = [ p.total_degree() for p in polified ]
+
+    poly_denom = (s * v_split[0] * _deflation(v_split[1])).as_expr()
+
+    def _exponent(g):
+        if g.is_Pow:
+            if g.exp.is_Rational and g.exp.q != 1:
+                if g.exp.p > 0:
+                    return g.exp.p + g.exp.q - 1
+                else:
+                    return abs(g.exp.p + g.exp.q)
+            else:
+                return 1
+        elif not g.is_Atom and g.args:
+            return max(_exponent(h) for h in g.args)
+        else:
+            return 1
+
+    A, B = _exponent(f), a + max(b, c)
+
+    if A > 1 and B > 1:
+        monoms = tuple(ordered(itermonomials(V, A + B - 1 + degree_offset)))
+    else:
+        monoms = tuple(ordered(itermonomials(V, A + B + degree_offset)))
+
+    poly_coeffs = _symbols('A', len(monoms))
+
+    poly_part = Add(*[ poly_coeffs[i]*monomial
+        for i, monomial in enumerate(monoms) ])
+
+    reducibles = set()
+
+    for poly in ordered(polys):
+        coeff, factors = factor_list(poly, *V)
+        reducibles.add(coeff)
+        reducibles.update(fact for fact, mul in factors)
+
+    def _integrate(field=None):
+        atans = set()
+        pairs = set()
+
+        if field == 'Q':
+            irreducibles = set(reducibles)
+        else:
+            setV = set(V)
+            irreducibles = set()
+            for poly in ordered(reducibles):
+                zV = setV & set(iterfreeargs(poly))
+                for z in ordered(zV):
+                    s = set(root_factors(poly, z, filter=field))
+                    irreducibles |= s
+                    break
+
+        log_part, atan_part = [], []
+
+        for poly in ordered(irreducibles):
+            m = collect(poly, I, evaluate=False)
+            y = m.get(I, S.Zero)
+            if y:
+                x = m.get(S.One, S.Zero)
+                if x.has(I) or y.has(I):
+                    continue  # nontrivial x + I*y
+                pairs.add((x, y))
+                irreducibles.remove(poly)
+
+        while pairs:
+            x, y = pairs.pop()
+            if (x, -y) in pairs:
+                pairs.remove((x, -y))
+                # Choosing b with no minus sign
+                if y.could_extract_minus_sign():
+                    y = -y
+                irreducibles.add(x*x + y*y)
+                atans.add(atan(x/y))
+            else:
+                irreducibles.add(x + I*y)
+
+
+        B = _symbols('B', len(irreducibles))
+        C = _symbols('C', len(atans))
+
+        # Note: the ordering matters here
+        for poly, b in reversed(list(zip(ordered(irreducibles), B))):
+            if poly.has(*V):
+                poly_coeffs.append(b)
+                log_part.append(b * log(poly))
+
+        for poly, c in reversed(list(zip(ordered(atans), C))):
+            if poly.has(*V):
+                poly_coeffs.append(c)
+                atan_part.append(c * poly)
+
+        # TODO: Currently it's better to use symbolic expressions here instead
+        # of rational functions, because it's simpler and FracElement doesn't
+        # give big speed improvement yet. This is because cancellation is slow
+        # due to slow polynomial GCD algorithms. If this gets improved then
+        # revise this code.
+        candidate = poly_part/poly_denom + Add(*log_part) + Add(*atan_part)
+        h = F - _derivation(candidate) / denom
+        raw_numer = h.as_numer_denom()[0]
+
+        # Rewrite raw_numer as a polynomial in K[coeffs][V] where K is a field
+        # that we have to determine. We can't use simply atoms() because log(3),
+        # sqrt(y) and similar expressions can appear, leading to non-trivial
+        # domains.
+        syms = set(poly_coeffs) | set(V)
+        non_syms = set()
+
+        def find_non_syms(expr):
+            if expr.is_Integer or expr.is_Rational:
+                pass # ignore trivial numbers
+            elif expr in syms:
+                pass # ignore variables
+            elif not expr.has_free(*syms):
+                non_syms.add(expr)
+            elif expr.is_Add or expr.is_Mul or expr.is_Pow:
+                list(map(find_non_syms, expr.args))
+            else:
+                # TODO: Non-polynomial expression. This should have been
+                # filtered out at an earlier stage.
+                raise PolynomialError
+
+        try:
+            find_non_syms(raw_numer)
+        except PolynomialError:
+            return None
+        else:
+            ground, _ = construct_domain(non_syms, field=True)
+
+        coeff_ring = PolyRing(poly_coeffs, ground)
+        ring = PolyRing(V, coeff_ring)
+        try:
+            numer = ring.from_expr(raw_numer)
+        except ValueError:
+            raise PolynomialError
+        solution = solve_lin_sys(numer.coeffs(), coeff_ring, _raw=False)
+
+        if solution is None:
+            return None
+        else:
+            return candidate.xreplace(solution).xreplace(
+                dict(zip(poly_coeffs, [S.Zero]*len(poly_coeffs))))
+
+    if all(isinstance(_, Symbol) for _ in V):
+        more_free = F.free_symbols - set(V)
+    else:
+        Fd = F.as_dummy()
+        more_free = Fd.xreplace(dict(zip(V, (Dummy() for _ in V)))
+            ).free_symbols & Fd.free_symbols
+    if not more_free:
+        # all free generators are identified in V
+        solution = _integrate('Q')
+
+        if solution is None:
+            solution = _integrate()
+    else:
+        solution = _integrate()
+
+    if solution is not None:
+        antideriv = solution.subs(rev_mapping)
+        antideriv = cancel(antideriv).expand()
+
+        if antideriv.is_Add:
+            antideriv = antideriv.as_independent(x)[1]
+
+        return indep*antideriv
+    else:
+        if retries >= 0:
+            result = heurisch(f, x, mappings=mappings, rewrite=rewrite, hints=hints, retries=retries - 1, unnecessary_permutations=unnecessary_permutations)
+
+            if result is not None:
+                return indep*result
+
+        return None

.venv/lib/python3.12/site-packages/sympy/integrals/integrals.py

@@ -0,0 +1,1640 @@
+from __future__ import annotations
+
+from sympy.concrete.expr_with_limits import AddWithLimits
+from sympy.core.add import Add
+from sympy.core.basic import Basic
+from sympy.core.containers import Tuple
+from sympy.core.expr import Expr
+from sympy.core.exprtools import factor_terms
+from sympy.core.function import diff
+from sympy.core.logic import fuzzy_bool
+from sympy.core.mul import Mul
+from sympy.core.numbers import oo, pi
+from sympy.core.relational import Ne
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, Wild)
+from sympy.core.sympify import sympify
+from sympy.functions import Piecewise, sqrt, piecewise_fold, tan, cot, atan
+from sympy.functions.elementary.exponential import log
+from sympy.functions.elementary.integers import floor
+from sympy.functions.elementary.complexes import Abs, sign
+from sympy.functions.elementary.miscellaneous import Min, Max
+from sympy.functions.special.singularity_functions import Heaviside
+from .rationaltools import ratint
+from sympy.matrices import MatrixBase
+from sympy.polys import Poly, PolynomialError
+from sympy.series.formal import FormalPowerSeries
+from sympy.series.limits import limit
+from sympy.series.order import Order
+from sympy.tensor.functions import shape
+from sympy.utilities.exceptions import sympy_deprecation_warning
+from sympy.utilities.iterables import is_sequence
+from sympy.utilities.misc import filldedent
+
+
+class Integral(AddWithLimits):
+    """Represents unevaluated integral."""
+
+    __slots__ = ()
+
+    args: tuple[Expr, Tuple] # type: ignore
+
+    def __new__(cls, function, *symbols, **assumptions) -> Integral:
+        """Create an unevaluated integral.
+
+        Explanation
+        ===========
+
+        Arguments are an integrand followed by one or more limits.
+
+        If no limits are given and there is only one free symbol in the
+        expression, that symbol will be used, otherwise an error will be
+        raised.
+
+        >>> from sympy import Integral
+        >>> from sympy.abc import x, y
+        >>> Integral(x)
+        Integral(x, x)
+        >>> Integral(y)
+        Integral(y, y)
+
+        When limits are provided, they are interpreted as follows (using
+        ``x`` as though it were the variable of integration):
+
+            (x,) or x - indefinite integral
+            (x, a) - "evaluate at" integral is an abstract antiderivative
+            (x, a, b) - definite integral
+
+        The ``as_dummy`` method can be used to see which symbols cannot be
+        targeted by subs: those with a prepended underscore cannot be
+        changed with ``subs``. (Also, the integration variables themselves --
+        the first element of a limit -- can never be changed by subs.)
+
+        >>> i = Integral(x, x)
+        >>> at = Integral(x, (x, x))
+        >>> i.as_dummy()
+        Integral(x, x)
+        >>> at.as_dummy()
+        Integral(_0, (_0, x))
+
+        """
+
+        #This will help other classes define their own definitions
+        #of behaviour with Integral.
+        if hasattr(function, '_eval_Integral'):
+            return function._eval_Integral(*symbols, **assumptions)
+
+        if isinstance(function, Poly):
+            sympy_deprecation_warning(
+                """
+                integrate(Poly) and Integral(Poly) are deprecated. Instead,
+                use the Poly.integrate() method, or convert the Poly to an
+                Expr first with the Poly.as_expr() method.
+                """,
+                deprecated_since_version="1.6",
+                active_deprecations_target="deprecated-integrate-poly")
+
+        obj = AddWithLimits.__new__(cls, function, *symbols, **assumptions)
+        return obj
+
+    def __getnewargs__(self):
+        return (self.function,) + tuple([tuple(xab) for xab in self.limits])
+
+    @property
+    def free_symbols(self):
+        """
+        This method returns the symbols that will exist when the
+        integral is evaluated. This is useful if one is trying to
+        determine whether an integral depends on a certain
+        symbol or not.
+
+        Examples
+        ========
+
+        >>> from sympy import Integral
+        >>> from sympy.abc import x, y
+        >>> Integral(x, (x, y, 1)).free_symbols
+        {y}
+
+        See Also
+        ========
+
+        sympy.concrete.expr_with_limits.ExprWithLimits.function
+        sympy.concrete.expr_with_limits.ExprWithLimits.limits
+        sympy.concrete.expr_with_limits.ExprWithLimits.variables
+        """
+        return super().free_symbols
+
+    def _eval_is_zero(self):
+        # This is a very naive and quick test, not intended to do the integral to
+        # answer whether it is zero or not, e.g. Integral(sin(x), (x, 0, 2*pi))
+        # is zero but this routine should return None for that case. But, like
+        # Mul, there are trivial situations for which the integral will be
+        # zero so we check for those.
+        if self.function.is_zero:
+            return True
+        got_none = False
+        for l in self.limits:
+            if len(l) == 3:
+                z = (l[1] == l[2]) or (l[1] - l[2]).is_zero
+                if z:
+                    return True
+                elif z is None:
+                    got_none = True
+        free = self.function.free_symbols
+        for xab in self.limits:
+            if len(xab) == 1:
+                free.add(xab[0])
+                continue
+            if len(xab) == 2 and xab[0] not in free:
+                if xab[1].is_zero:
+                    return True
+                elif xab[1].is_zero is None:
+                    got_none = True
+            # take integration symbol out of free since it will be replaced
+            # with the free symbols in the limits
+            free.discard(xab[0])
+            # add in the new symbols
+            for i in xab[1:]:
+                free.update(i.free_symbols)
+        if self.function.is_zero is False and got_none is False:
+            return False
+
+    def transform(self, x, u):
+        r"""
+        Performs a change of variables from `x` to `u` using the relationship
+        given by `x` and `u` which will define the transformations `f` and `F`
+        (which are inverses of each other) as follows:
+
+        1) If `x` is a Symbol (which is a variable of integration) then `u`
+           will be interpreted as some function, f(u), with inverse F(u).
+           This, in effect, just makes the substitution of x with f(x).
+
+        2) If `u` is a Symbol then `x` will be interpreted as some function,
+           F(x), with inverse f(u). This is commonly referred to as
+           u-substitution.
+
+        Once f and F have been identified, the transformation is made as
+        follows:
+
+        .. math:: \int_a^b x \mathrm{d}x \rightarrow \int_{F(a)}^{F(b)} f(x)
+                  \frac{\mathrm{d}}{\mathrm{d}x}
+
+        where `F(x)` is the inverse of `f(x)` and the limits and integrand have
+        been corrected so as to retain the same value after integration.
+
+        Notes
+        =====
+
+        The mappings, F(x) or f(u), must lead to a unique integral. Linear
+        or rational linear expression, ``2*x``, ``1/x`` and ``sqrt(x)``, will
+        always work; quadratic expressions like ``x**2 - 1`` are acceptable
+        as long as the resulting integrand does not depend on the sign of
+        the solutions (see examples).
+
+        The integral will be returned unchanged if ``x`` is not a variable of
+        integration.
+
+        ``x`` must be (or contain) only one of of the integration variables. If
+        ``u`` has more than one free symbol then it should be sent as a tuple
+        (``u``, ``uvar``) where ``uvar`` identifies which variable is replacing
+        the integration variable.
+        XXX can it contain another integration variable?
+
+        Examples
+        ========
+
+        >>> from sympy.abc import a, x, u
+        >>> from sympy import Integral, cos, sqrt
+
+        >>> i = Integral(x*cos(x**2 - 1), (x, 0, 1))
+
+        transform can change the variable of integration
+
+        >>> i.transform(x, u)
+        Integral(u*cos(u**2 - 1), (u, 0, 1))
+
+        transform can perform u-substitution as long as a unique
+        integrand is obtained:
+
+        >>> ui = i.transform(x**2 - 1, u)
+        >>> ui
+        Integral(cos(u)/2, (u, -1, 0))
+
+        This attempt fails because x = +/-sqrt(u + 1) and the
+        sign does not cancel out of the integrand:
+
+        >>> Integral(cos(x**2 - 1), (x, 0, 1)).transform(x**2 - 1, u)
+        Traceback (most recent call last):
+        ...
+        ValueError:
+        The mapping between F(x) and f(u) did not give a unique integrand.
+
+        transform can do a substitution. Here, the previous
+        result is transformed back into the original expression
+        using "u-substitution":
+
+        >>> ui.transform(sqrt(u + 1), x) == i
+        True
+
+        We can accomplish the same with a regular substitution:
+
+        >>> ui.transform(u, x**2 - 1) == i
+        True
+
+        If the `x` does not contain a symbol of integration then
+        the integral will be returned unchanged. Integral `i` does
+        not have an integration variable `a` so no change is made:
+
+        >>> i.transform(a, x) == i
+        True
+
+        When `u` has more than one free symbol the symbol that is
+        replacing `x` must be identified by passing `u` as a tuple:
+
+        >>> Integral(x, (x, 0, 1)).transform(x, (u + a, u))
+        Integral(a + u, (u, -a, 1 - a))
+        >>> Integral(x, (x, 0, 1)).transform(x, (u + a, a))
+        Integral(a + u, (a, -u, 1 - u))
+
+        See Also
+        ========
+
+        sympy.concrete.expr_with_limits.ExprWithLimits.variables : Lists the integration variables
+        as_dummy : Replace integration variables with dummy ones
+        """
+        d = Dummy('d')
+
+        xfree = x.free_symbols.intersection(self.variables)
+        if len(xfree) > 1:
+            raise ValueError(
+                'F(x) can only contain one of: %s' % self.variables)
+        xvar = xfree.pop() if xfree else d
+
+        if xvar not in self.variables:
+            return self
+
+        u = sympify(u)
+        if isinstance(u, Expr):
+            ufree = u.free_symbols
+            if len(ufree) == 0:
+                raise ValueError(filldedent('''
+                f(u) cannot be a constant'''))
+            if len(ufree) > 1:
+                raise ValueError(filldedent('''
+                When f(u) has more than one free symbol, the one replacing x
+                must be identified: pass f(u) as (f(u), u)'''))
+            uvar = ufree.pop()
+        else:
+            u, uvar = u
+            if uvar not in u.free_symbols:
+                raise ValueError(filldedent('''
+                Expecting a tuple (expr, symbol) where symbol identified
+                a free symbol in expr, but symbol is not in expr's free
+                symbols.'''))
+            if not isinstance(uvar, Symbol):
+                # This probably never evaluates to True
+                raise ValueError(filldedent('''
+                Expecting a tuple (expr, symbol) but didn't get
+                a symbol; got %s''' % uvar))
+
+        if x.is_Symbol and u.is_Symbol:
+            return self.xreplace({x: u})
+
+        if not x.is_Symbol and not u.is_Symbol:
+            raise ValueError('either x or u must be a symbol')
+
+        if uvar == xvar:
+            return self.transform(x, (u.subs(uvar, d), d)).xreplace({d: uvar})
+
+        if uvar in self.limits:
+            raise ValueError(filldedent('''
+            u must contain the same variable as in x
+            or a variable that is not already an integration variable'''))
+
+        from sympy.solvers.solvers import solve
+        if not x.is_Symbol:
+            F = [x.subs(xvar, d)]
+            soln = solve(u - x, xvar, check=False)
+            if not soln:
+                raise ValueError('no solution for solve(F(x) - f(u), x)')
+            f = [fi.subs(uvar, d) for fi in soln]
+        else:
+            f = [u.subs(uvar, d)]
+            from sympy.simplify.simplify import posify
+            pdiff, reps = posify(u - x)
+            puvar = uvar.subs([(v, k) for k, v in reps.items()])
+            soln = [s.subs(reps) for s in solve(pdiff, puvar)]
+            if not soln:
+                raise ValueError('no solution for solve(F(x) - f(u), u)')
+            F = [fi.subs(xvar, d) for fi in soln]
+
+        newfuncs = {(self.function.subs(xvar, fi)*fi.diff(d)
+                        ).subs(d, uvar) for fi in f}
+        if len(newfuncs) > 1:
+            raise ValueError(filldedent('''
+            The mapping between F(x) and f(u) did not give
+            a unique integrand.'''))
+        newfunc = newfuncs.pop()
+
+        def _calc_limit_1(F, a, b):
+            """
+            replace d with a, using subs if possible, otherwise limit
+            where sign of b is considered
+            """
+            wok = F.subs(d, a)
+            if wok is S.NaN or wok.is_finite is False and a.is_finite:
+                return limit(sign(b)*F, d, a)
+            return wok
+
+        def _calc_limit(a, b):
+            """
+            replace d with a, using subs if possible, otherwise limit
+            where sign of b is considered
+            """
+            avals = list({_calc_limit_1(Fi, a, b) for Fi in F})
+            if len(avals) > 1:
+                raise ValueError(filldedent('''
+                The mapping between F(x) and f(u) did not
+                give a unique limit.'''))
+            return avals[0]
+
+        newlimits = []
+        for xab in self.limits:
+            sym = xab[0]
+            if sym == xvar:
+                if len(xab) == 3:
+                    a, b = xab[1:]
+                    a, b = _calc_limit(a, b), _calc_limit(b, a)
+                    if fuzzy_bool(a - b > 0):
+                        a, b = b, a
+                        newfunc = -newfunc
+                    newlimits.append((uvar, a, b))
+                elif len(xab) == 2:
+                    a = _calc_limit(xab[1], 1)
+                    newlimits.append((uvar, a))
+                else:
+                    newlimits.append(uvar)
+            else:
+                newlimits.append(xab)
+
+        return self.func(newfunc, *newlimits)
+
+    def doit(self, **hints):
+        """
+        Perform the integration using any hints given.
+
+        Examples
+        ========
+
+        >>> from sympy import Piecewise, S
+        >>> from sympy.abc import x, t
+        >>> p = x**2 + Piecewise((0, x/t < 0), (1, True))
+        >>> p.integrate((t, S(4)/5, 1), (x, -1, 1))
+        1/3
+
+        See Also
+        ========
+
+        sympy.integrals.trigonometry.trigintegrate
+        sympy.integrals.heurisch.heurisch
+        sympy.integrals.rationaltools.ratint
+        as_sum : Approximate the integral using a sum
+        """
+        if not hints.get('integrals', True):
+            return self
+
+        deep = hints.get('deep', True)
+        meijerg = hints.get('meijerg', None)
+        conds = hints.get('conds', 'piecewise')
+        risch = hints.get('risch', None)
+        heurisch = hints.get('heurisch', None)
+        manual = hints.get('manual', None)
+        if len(list(filter(None, (manual, meijerg, risch, heurisch)))) > 1:
+            raise ValueError("At most one of manual, meijerg, risch, heurisch can be True")
+        elif manual:
+            meijerg = risch = heurisch = False
+        elif meijerg:
+            manual = risch = heurisch = False
+        elif risch:
+            manual = meijerg = heurisch = False
+        elif heurisch:
+            manual = meijerg = risch = False
+        eval_kwargs = {"meijerg": meijerg, "risch": risch, "manual": manual, "heurisch": heurisch,
+            "conds": conds}
+
+        if conds not in ('separate', 'piecewise', 'none'):
+            raise ValueError('conds must be one of "separate", "piecewise", '
+                             '"none", got: %s' % conds)
+
+        if risch and any(len(xab) > 1 for xab in self.limits):
+            raise ValueError('risch=True is only allowed for indefinite integrals.')
+
+        # check for the trivial zero
+        if self.is_zero:
+            return S.Zero
+
+        # hacks to handle integrals of
+        # nested summations
+        from sympy.concrete.summations import Sum
+        if isinstance(self.function, Sum):
+            if any(v in self.function.limits[0] for v in self.variables):
+                raise ValueError('Limit of the sum cannot be an integration variable.')
+            if any(l.is_infinite for l in self.function.limits[0][1:]):
+                return self
+            _i = self
+            _sum = self.function
+            return _sum.func(_i.func(_sum.function, *_i.limits).doit(), *_sum.limits).doit()
+
+        # now compute and check the function
+        function = self.function
+
+        # hack to use a consistent Heaviside(x, 1/2)
+        function = function.replace(
+            lambda x: isinstance(x, Heaviside) and x.args[1]*2 != 1,
+            lambda x: Heaviside(x.args[0]))
+
+        if deep:
+            function = function.doit(**hints)
+        if function.is_zero:
+            return S.Zero
+
+        # hacks to handle special cases
+        if isinstance(function, MatrixBase):
+            return function.applyfunc(
+                lambda f: self.func(f, *self.limits).doit(**hints))
+
+        if isinstance(function, FormalPowerSeries):
+            if len(self.limits) > 1:
+                raise NotImplementedError
+            xab = self.limits[0]
+            if len(xab) > 1:
+                return function.integrate(xab, **eval_kwargs)
+            else:
+                return function.integrate(xab[0], **eval_kwargs)
+
+        # There is no trivial answer and special handling
+        # is done so continue
+
+        # first make sure any definite limits have integration
+        # variables with matching assumptions
+        reps = {}
+        for xab in self.limits:
+            if len(xab) != 3:
+                # it makes sense to just make
+                # all x real but in practice with the
+                # current state of integration...this
+                # doesn't work out well
+                # x = xab[0]
+                # if x not in reps and not x.is_real:
+                #     reps[x] = Dummy(real=True)
+                continue
+            x, a, b = xab
+            l = (a, b)
+            if all(i.is_nonnegative for i in l) and not x.is_nonnegative:
+                d = Dummy(positive=True)
+            elif all(i.is_nonpositive for i in l) and not x.is_nonpositive:
+                d = Dummy(negative=True)
+            elif all(i.is_real for i in l) and not x.is_real:
+                d = Dummy(real=True)
+            else:
+                d = None
+            if d:
+                reps[x] = d
+        if reps:
+            undo = {v: k for k, v in reps.items()}
+            did = self.xreplace(reps).doit(**hints)
+            if isinstance(did, tuple):  # when separate=True
+                did = tuple([i.xreplace(undo) for i in did])
+            else:
+                did = did.xreplace(undo)
+            return did
+
+        # continue with existing assumptions
+        undone_limits = []
+        # ulj = free symbols of any undone limits' upper and lower limits
+        ulj = set()
+        for xab in self.limits:
+            # compute uli, the free symbols in the
+            # Upper and Lower limits of limit I
+            if len(xab) == 1:
+                uli = set(xab[:1])
+            elif len(xab) == 2:
+                uli = xab[1].free_symbols
+            elif len(xab) == 3:
+                uli = xab[1].free_symbols.union(xab[2].free_symbols)
+            # this integral can be done as long as there is no blocking
+            # limit that has been undone. An undone limit is blocking if
+            # it contains an integration variable that is in this limit's
+            # upper or lower free symbols or vice versa
+            if xab[0] in ulj or any(v[0] in uli for v in undone_limits):
+                undone_limits.append(xab)
+                ulj.update(uli)
+                function = self.func(*([function] + [xab]))
+                factored_function = function.factor()
+                if not isinstance(factored_function, Integral):
+                    function = factored_function
+                continue
+
+            if function.has(Abs, sign) and (
+                (len(xab) < 3 and all(x.is_extended_real for x in xab)) or
+                (len(xab) == 3 and all(x.is_extended_real and not x.is_infinite for
+                 x in xab[1:]))):
+                    # some improper integrals are better off with Abs
+                    xr = Dummy("xr", real=True)
+                    function = (function.xreplace({xab[0]: xr})
+                        .rewrite(Piecewise).xreplace({xr: xab[0]}))
+            elif function.has(Min, Max):
+                function = function.rewrite(Piecewise)
+            if (function.has(Piecewise) and
+                not isinstance(function, Piecewise)):
+                    function = piecewise_fold(function)
+            if isinstance(function, Piecewise):
+                if len(xab) == 1:
+                    antideriv = function._eval_integral(xab[0],
+                        **eval_kwargs)
+                else:
+                    antideriv = self._eval_integral(
+                        function, xab[0], **eval_kwargs)
+            else:
+                # There are a number of tradeoffs in using the
+                # Meijer G method. It can sometimes be a lot faster
+                # than other methods, and sometimes slower. And
+                # there are certain types of integrals for which it
+                # is more likely to work than others. These
+                # heuristics are incorporated in deciding what
+                # integration methods to try, in what order. See the
+                # integrate() docstring for details.
+                def try_meijerg(function, xab):
+                    ret = None
+                    if len(xab) == 3 and meijerg is not False:
+                        x, a, b = xab
+                        try:
+                            res = meijerint_definite(function, x, a, b)
+                        except NotImplementedError:
+                            _debug('NotImplementedError '
+                                'from meijerint_definite')
+                            res = None
+                        if res is not None:
+                            f, cond = res
+                            if conds == 'piecewise':
+                                u = self.func(function, (x, a, b))
+                                # if Piecewise modifies cond too
+                                # much it may not be recognized by
+                                # _condsimp pattern matching so just
+                                # turn off all evaluation
+                                return Piecewise((f, cond), (u, True),
+                                    evaluate=False)
+                            elif conds == 'separate':
+                                if len(self.limits) != 1:
+                                    raise ValueError(filldedent('''
+                                        conds=separate not supported in
+                                        multiple integrals'''))
+                                ret = f, cond
+                            else:
+                                ret = f
+                    return ret
+
+                meijerg1 = meijerg
+                if (meijerg is not False and
+                        len(xab) == 3 and xab[1].is_extended_real and xab[2].is_extended_real
+                        and not function.is_Poly and
+                        (xab[1].has(oo, -oo) or xab[2].has(oo, -oo))):
+                    ret = try_meijerg(function, xab)
+                    if ret is not None:
+                        function = ret
+                        continue
+                    meijerg1 = False
+                # If the special meijerg code did not succeed in
+                # finding a definite integral, then the code using
+                # meijerint_indefinite will not either (it might
+                # find an antiderivative, but the answer is likely
+                # to be nonsensical). Thus if we are requested to
+                # only use Meijer G-function methods, we give up at
+                # this stage. Otherwise we just disable G-function
+                # methods.
+                if meijerg1 is False and meijerg is True:
+                    antideriv = None
+                else:
+                    antideriv = self._eval_integral(
+                        function, xab[0], **eval_kwargs)
+                    if antideriv is None and meijerg is True:
+                        ret = try_meijerg(function, xab)
+                        if ret is not None:
+                            function = ret
+                            continue
+
+            final = hints.get('final', True)
+            # dotit may be iterated but floor terms making atan and acot
+            # continuous should only be added in the final round
+            if (final and not isinstance(antideriv, Integral) and
+                antideriv is not None):
+                for atan_term in antideriv.atoms(atan):
+                    atan_arg = atan_term.args[0]
+                    # Checking `atan_arg` to be linear combination of `tan` or `cot`
+                    for tan_part in atan_arg.atoms(tan):
+                        x1 = Dummy('x1')
+                        tan_exp1 = atan_arg.subs(tan_part, x1)
+                        # The coefficient of `tan` should be constant
+                        coeff = tan_exp1.diff(x1)
+                        if x1 not in coeff.free_symbols:
+                            a = tan_part.args[0]
+                            antideriv = antideriv.subs(atan_term, Add(atan_term,
+                                sign(coeff)*pi*floor((a-pi/2)/pi)))
+                    for cot_part in atan_arg.atoms(cot):
+                        x1 = Dummy('x1')
+                        cot_exp1 = atan_arg.subs(cot_part, x1)
+                        # The coefficient of `cot` should be constant
+                        coeff = cot_exp1.diff(x1)
+                        if x1 not in coeff.free_symbols:
+                            a = cot_part.args[0]
+                            antideriv = antideriv.subs(atan_term, Add(atan_term,
+                                sign(coeff)*pi*floor((a)/pi)))
+
+            if antideriv is None:
+                undone_limits.append(xab)
+                function = self.func(*([function] + [xab])).factor()
+                factored_function = function.factor()
+                if not isinstance(factored_function, Integral):
+                    function = factored_function
+                continue
+            else:
+                if len(xab) == 1:
+                    function = antideriv
+                else:
+                    if len(xab) == 3:
+                        x, a, b = xab
+                    elif len(xab) == 2:
+                        x, b = xab
+                        a = None
+                    else:
+                        raise NotImplementedError
+
+                    if deep:
+                        if isinstance(a, Basic):
+                            a = a.doit(**hints)
+                        if isinstance(b, Basic):
+                            b = b.doit(**hints)
+
+                    if antideriv.is_Poly:
+                        gens = list(antideriv.gens)
+                        gens.remove(x)
+
+                        antideriv = antideriv.as_expr()
+
+                        function = antideriv._eval_interval(x, a, b)
+                        function = Poly(function, *gens)
+                    else:
+                        def is_indef_int(g, x):
+                            return (isinstance(g, Integral) and
+                                    any(i == (x,) for i in g.limits))
+
+                        def eval_factored(f, x, a, b):
+                            # _eval_interval for integrals with
+                            # (constant) factors
+                            # a single indefinite integral is assumed
+                            args = []
+                            for g in Mul.make_args(f):
+                                if is_indef_int(g, x):
+                                    args.append(g._eval_interval(x, a, b))
+                                else:
+                                    args.append(g)
+                            return Mul(*args)
+
+                        integrals, others, piecewises = [], [], []
+                        for f in Add.make_args(antideriv):
+                            if any(is_indef_int(g, x)
+                                   for g in Mul.make_args(f)):
+                                integrals.append(f)
+                            elif any(isinstance(g, Piecewise)
+                                     for g in Mul.make_args(f)):
+                                piecewises.append(piecewise_fold(f))
+                            else:
+                                others.append(f)
+                        uneval = Add(*[eval_factored(f, x, a, b)
+                                       for f in integrals])
+                        try:
+                            evalued = Add(*others)._eval_interval(x, a, b)
+                            evalued_pw = piecewise_fold(Add(*piecewises))._eval_interval(x, a, b)
+                            function = uneval + evalued + evalued_pw
+                        except NotImplementedError:
+                            # This can happen if _eval_interval depends in a
+                            # complicated way on limits that cannot be computed
+                            undone_limits.append(xab)
+                            function = self.func(*([function] + [xab]))
+                            factored_function = function.factor()
+                            if not isinstance(factored_function, Integral):
+                                function = factored_function
+        return function
+
+    def _eval_derivative(self, sym):
+        """Evaluate the derivative of the current Integral object by
+        differentiating under the integral sign [1], using the Fundamental
+        Theorem of Calculus [2] when possible.
+
+        Explanation
+        ===========
+
+        Whenever an Integral is encountered that is equivalent to zero or
+        has an integrand that is independent of the variable of integration
+        those integrals are performed. All others are returned as Integral
+        instances which can be resolved with doit() (provided they are integrable).
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Differentiation_under_the_integral_sign
+        .. [2] https://en.wikipedia.org/wiki/Fundamental_theorem_of_calculus
+
+        Examples
+        ========
+
+        >>> from sympy import Integral
+        >>> from sympy.abc import x, y
+        >>> i = Integral(x + y, y, (y, 1, x))
+        >>> i.diff(x)
+        Integral(x + y, (y, x)) + Integral(1, y, (y, 1, x))
+        >>> i.doit().diff(x) == i.diff(x).doit()
+        True
+        >>> i.diff(y)
+        0
+
+        The previous must be true since there is no y in the evaluated integral:
+
+        >>> i.free_symbols
+        {x}
+        >>> i.doit()
+        2*x**3/3 - x/2 - 1/6
+
+        """
+
+        # differentiate under the integral sign; we do not
+        # check for regularity conditions (TODO), see issue 4215
+
+        # get limits and the function
+        f, limits = self.function, list(self.limits)
+
+        # the order matters if variables of integration appear in the limits
+        # so work our way in from the outside to the inside.
+        limit = limits.pop(-1)
+        if len(limit) == 3:
+            x, a, b = limit
+        elif len(limit) == 2:
+            x, b = limit
+            a = None
+        else:
+            a = b = None
+            x = limit[0]
+
+        if limits:  # f is the argument to an integral
+            f = self.func(f, *tuple(limits))
+
+        # assemble the pieces
+        def _do(f, ab):
+            dab_dsym = diff(ab, sym)
+            if not dab_dsym:
+                return S.Zero
+            if isinstance(f, Integral):
+                limits = [(x, x) if (len(l) == 1 and l[0] == x) else l
+                          for l in f.limits]
+                f = self.func(f.function, *limits)
+            return f.subs(x, ab)*dab_dsym
+
+        rv = S.Zero
+        if b is not None:
+            rv += _do(f, b)
+        if a is not None:
+            rv -= _do(f, a)
+        if len(limit) == 1 and sym == x:
+            # the dummy variable *is* also the real-world variable
+            arg = f
+            rv += arg
+        else:
+            # the dummy variable might match sym but it's
+            # only a dummy and the actual variable is determined
+            # by the limits, so mask off the variable of integration
+            # while differentiating
+            u = Dummy('u')
+            arg = f.subs(x, u).diff(sym).subs(u, x)
+            if arg:
+                rv += self.func(arg, (x, a, b))
+        return rv
+
+    def _eval_integral(self, f, x, meijerg=None, risch=None, manual=None,
+                       heurisch=None, conds='piecewise',final=None):
+        """
+        Calculate the anti-derivative to the function f(x).
+
+        Explanation
+        ===========
+
+        The following algorithms are applied (roughly in this order):
+
+        1. Simple heuristics (based on pattern matching and integral table):
+
+           - most frequently used functions (e.g. polynomials, products of
+             trig functions)
+
+        2. Integration of rational functions:
+
+           - A complete algorithm for integrating rational functions is
+             implemented (the Lazard-Rioboo-Trager algorithm).  The algorithm
+             also uses the partial fraction decomposition algorithm
+             implemented in apart() as a preprocessor to make this process
+             faster.  Note that the integral of a rational function is always
+             elementary, but in general, it may include a RootSum.
+
+        3. Full Risch algorithm:
+
+           - The Risch algorithm is a complete decision
+             procedure for integrating elementary functions, which means that
+             given any elementary function, it will either compute an
+             elementary antiderivative, or else prove that none exists.
+             Currently, part of transcendental case is implemented, meaning
+             elementary integrals containing exponentials, logarithms, and
+             (soon!) trigonometric functions can be computed.  The algebraic
+             case, e.g., functions containing roots, is much more difficult
+             and is not implemented yet.
+
+           - If the routine fails (because the integrand is not elementary, or
+             because a case is not implemented yet), it continues on to the
+             next algorithms below.  If the routine proves that the integrals
+             is nonelementary, it still moves on to the algorithms below,
+             because we might be able to find a closed-form solution in terms
+             of special functions.  If risch=True, however, it will stop here.
+
+        4. The Meijer G-Function algorithm:
+
+           - This algorithm works by first rewriting the integrand in terms of
+             very general Meijer G-Function (meijerg in SymPy), integrating
+             it, and then rewriting the result back, if possible.  This
+             algorithm is particularly powerful for definite integrals (which
+             is actually part of a different method of Integral), since it can
+             compute closed-form solutions of definite integrals even when no
+             closed-form indefinite integral exists.  But it also is capable
+             of computing many indefinite integrals as well.
+
+           - Another advantage of this method is that it can use some results
+             about the Meijer G-Function to give a result in terms of a
+             Piecewise expression, which allows to express conditionally
+             convergent integrals.
+
+           - Setting meijerg=True will cause integrate() to use only this
+             method.
+
+        5. The "manual integration" algorithm:
+
+           - This algorithm tries to mimic how a person would find an
+             antiderivative by hand, for example by looking for a
+             substitution or applying integration by parts. This algorithm
+             does not handle as many integrands but can return results in a
+             more familiar form.
+
+           - Sometimes this algorithm can evaluate parts of an integral; in
+             this case integrate() will try to evaluate the rest of the
+             integrand using the other methods here.
+
+           - Setting manual=True will cause integrate() to use only this
+             method.
+
+        6. The Heuristic Risch algorithm:
+
+           - This is a heuristic version of the Risch algorithm, meaning that
+             it is not deterministic.  This is tried as a last resort because
+             it can be very slow.  It is still used because not enough of the
+             full Risch algorithm is implemented, so that there are still some
+             integrals that can only be computed using this method.  The goal
+             is to implement enough of the Risch and Meijer G-function methods
+             so that this can be deleted.
+
+             Setting heurisch=True will cause integrate() to use only this
+             method. Set heurisch=False to not use it.
+
+        """
+
+        from sympy.integrals.risch import risch_integrate, NonElementaryIntegral
+        from sympy.integrals.manualintegrate import manualintegrate
+
+        if risch:
+            try:
+                return risch_integrate(f, x, conds=conds)
+            except NotImplementedError:
+                return None
+
+        if manual:
+            try:
+                result = manualintegrate(f, x)
+                if result is not None and result.func != Integral:
+                    return result
+            except (ValueError, PolynomialError):
+                pass
+
+        eval_kwargs = {"meijerg": meijerg, "risch": risch, "manual": manual,
+            "heurisch": heurisch, "conds": conds}
+
+        # if it is a poly(x) then let the polynomial integrate itself (fast)
+        #
+        # It is important to make this check first, otherwise the other code
+        # will return a SymPy expression instead of a Polynomial.
+        #
+        # see Polynomial for details.
+        if isinstance(f, Poly) and not (manual or meijerg or risch):
+            # Note: this is deprecated, but the deprecation warning is already
+            # issued in the Integral constructor.
+            return f.integrate(x)
+
+        # Piecewise antiderivatives need to call special integrate.
+        if isinstance(f, Piecewise):
+            return f.piecewise_integrate(x, **eval_kwargs)
+
+        # let's cut it short if `f` does not depend on `x`; if
+        # x is only a dummy, that will be handled below
+        if not f.has(x):
+            return f*x
+
+        # try to convert to poly(x) and then integrate if successful (fast)
+        poly = f.as_poly(x)
+        if poly is not None and not (manual or meijerg or risch):
+            return poly.integrate().as_expr()
+
+        if risch is not False:
+            try:
+                result, i = risch_integrate(f, x, separate_integral=True,
+                    conds=conds)
+            except NotImplementedError:
+                pass
+            else:
+                if i:
+                    # There was a nonelementary integral. Try integrating it.
+
+                    # if no part of the NonElementaryIntegral is integrated by
+                    # the Risch algorithm, then use the original function to
+                    # integrate, instead of re-written one
+                    if result == 0:
+                        return NonElementaryIntegral(f, x).doit(risch=False)
+                    else:
+                        return result + i.doit(risch=False)
+                else:
+                    return result
+
+        # since Integral(f=g1+g2+...) == Integral(g1) + Integral(g2) + ...
+        # we are going to handle Add terms separately,
+        # if `f` is not Add -- we only have one term
+
+        # Note that in general, this is a bad idea, because Integral(g1) +
+        # Integral(g2) might not be computable, even if Integral(g1 + g2) is.
+        # For example, Integral(x**x + x**x*log(x)).  But many heuristics only
+        # work term-wise.  So we compute this step last, after trying
+        # risch_integrate.  We also try risch_integrate again in this loop,
+        # because maybe the integral is a sum of an elementary part and a
+        # nonelementary part (like erf(x) + exp(x)).  risch_integrate() is
+        # quite fast, so this is acceptable.
+        from sympy.simplify.fu import sincos_to_sum
+        parts = []
+        args = Add.make_args(f)
+        for g in args:
+            coeff, g = g.as_independent(x)
+
+            # g(x) = const
+            if g is S.One and not meijerg:
+                parts.append(coeff*x)
+                continue
+
+            # g(x) = expr + O(x**n)
+            order_term = g.getO()
+
+            if order_term is not None:
+                h = self._eval_integral(g.removeO(), x, **eval_kwargs)
+
+                if h is not None:
+                    h_order_expr = self._eval_integral(order_term.expr, x, **eval_kwargs)
+
+                    if h_order_expr is not None:
+                        h_order_term = order_term.func(
+                            h_order_expr, *order_term.variables)
+                        parts.append(coeff*(h + h_order_term))
+                        continue
+
+                # NOTE: if there is O(x**n) and we fail to integrate then
+                # there is no point in trying other methods because they
+                # will fail, too.
+                return None
+
+            #               c
+            # g(x) = (a*x+b)
+            if g.is_Pow and not g.exp.has(x) and not meijerg:
+                a = Wild('a', exclude=[x])
+                b = Wild('b', exclude=[x])
+
+                M = g.base.match(a*x + b)
+
+                if M is not None:
+                    if g.exp == -1:
+                        h = log(g.base)
+                    elif conds != 'piecewise':
+                        h = g.base**(g.exp + 1) / (g.exp + 1)
+                    else:
+                        h1 = log(g.base)
+                        h2 = g.base**(g.exp + 1) / (g.exp + 1)
+                        h = Piecewise((h2, Ne(g.exp, -1)), (h1, True))
+
+                    parts.append(coeff * h / M[a])
+                    continue
+
+            #        poly(x)
+            # g(x) = -------
+            #        poly(x)
+            if g.is_rational_function(x) and not (manual or meijerg or risch):
+                parts.append(coeff * ratint(g, x))
+                continue
+
+            if not (manual or meijerg or risch):
+                # g(x) = Mul(trig)
+                h = trigintegrate(g, x, conds=conds)
+                if h is not None:
+                    parts.append(coeff * h)
+                    continue
+
+                # g(x) has at least a DiracDelta term
+                h = deltaintegrate(g, x)
+                if h is not None:
+                    parts.append(coeff * h)
+                    continue
+
+                from .singularityfunctions import singularityintegrate
+                # g(x) has at least a Singularity Function term
+                h = singularityintegrate(g, x)
+                if h is not None:
+                    parts.append(coeff * h)
+                    continue
+
+                # Try risch again.
+                if risch is not False:
+                    try:
+                        h, i = risch_integrate(g, x,
+                            separate_integral=True, conds=conds)
+                    except NotImplementedError:
+                        h = None
+                    else:
+                        if i:
+                            h = h + i.doit(risch=False)
+
+                        parts.append(coeff*h)
+                        continue
+
+                # fall back to heurisch
+                if heurisch is not False:
+                    from sympy.integrals.heurisch import (heurisch as heurisch_,
+                                                          heurisch_wrapper)
+                    try:
+                        if conds == 'piecewise':
+                            h = heurisch_wrapper(g, x, hints=[])
+                        else:
+                            h = heurisch_(g, x, hints=[])
+                    except PolynomialError:
+                        # XXX: this exception means there is a bug in the
+                        # implementation of heuristic Risch integration
+                        # algorithm.
+                        h = None
+            else:
+                h = None
+
+            if meijerg is not False and h is None:
+                # rewrite using G functions
+                try:
+                    h = meijerint_indefinite(g, x)
+                except NotImplementedError:
+                    _debug('NotImplementedError from meijerint_definite')
+                if h is not None:
+                    parts.append(coeff * h)
+                    continue
+
+            if h is None and manual is not False:
+                try:
+                    result = manualintegrate(g, x)
+                    if result is not None and not isinstance(result, Integral):
+                        if result.has(Integral) and not manual:
+                            # Try to have other algorithms do the integrals
+                            # manualintegrate can't handle,
+                            # unless we were asked to use manual only.
+                            # Keep the rest of eval_kwargs in case another
+                            # method was set to False already
+                            new_eval_kwargs = eval_kwargs
+                            new_eval_kwargs["manual"] = False
+                            new_eval_kwargs["final"] = False
+                            result = result.func(*[
+                                arg.doit(**new_eval_kwargs) if
+                                arg.has(Integral) else arg
+                                for arg in result.args
+                            ]).expand(multinomial=False,
+                                      log=False,
+                                      power_exp=False,
+                                      power_base=False)
+                        if not result.has(Integral):
+                            parts.append(coeff * result)
+                            continue
+                except (ValueError, PolynomialError):
+                    # can't handle some SymPy expressions
+                    pass
+
+            # if we failed maybe it was because we had
+            # a product that could have been expanded,
+            # so let's try an expansion of the whole
+            # thing before giving up; we don't try this
+            # at the outset because there are things
+            # that cannot be solved unless they are
+            # NOT expanded e.g., x**x*(1+log(x)). There
+            # should probably be a checker somewhere in this
+            # routine to look for such cases and try to do
+            # collection on the expressions if they are already
+            # in an expanded form
+            if not h and len(args) == 1:
+                f = sincos_to_sum(f).expand(mul=True, deep=False)
+                if f.is_Add:
+                    # Note: risch will be identical on the expanded
+                    # expression, but maybe it will be able to pick out parts,
+                    # like x*(exp(x) + erf(x)).
+                    return self._eval_integral(f, x, **eval_kwargs)
+
+            if h is not None:
+                parts.append(coeff * h)
+            else:
+                return None
+
+        return Add(*parts)
+
+    def _eval_lseries(self, x, logx=None, cdir=0):
+        expr = self.as_dummy()
+        symb = x
+        for l in expr.limits:
+            if x in l[1:]:
+                symb = l[0]
+                break
+        for term in expr.function.lseries(symb, logx):
+            yield integrate(term, *expr.limits)
+
+    def _eval_nseries(self, x, n, logx=None, cdir=0):
+        symb = x
+        for l in self.limits:
+            if x in l[1:]:
+                symb = l[0]
+                break
+        terms, order = self.function.nseries(
+            x=symb, n=n, logx=logx).as_coeff_add(Order)
+        order = [o.subs(symb, x) for o in order]
+        return integrate(terms, *self.limits) + Add(*order)*x
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        series_gen = self.args[0].lseries(x)
+        for leading_term in series_gen:
+            if leading_term != 0:
+                break
+        return integrate(leading_term, *self.args[1:])
+
+    def _eval_simplify(self, **kwargs):
+        expr = factor_terms(self)
+        if isinstance(expr, Integral):
+            from sympy.simplify.simplify import simplify
+            return expr.func(*[simplify(i, **kwargs) for i in expr.args])
+        return expr.simplify(**kwargs)
+
+    def as_sum(self, n=None, method="midpoint", evaluate=True):
+        """
+        Approximates a definite integral by a sum.
+
+        Parameters
+        ==========
+
+        n :
+            The number of subintervals to use, optional.
+        method :
+            One of: 'left', 'right', 'midpoint', 'trapezoid'.
+        evaluate : bool
+            If False, returns an unevaluated Sum expression. The default
+            is True, evaluate the sum.
+
+        Notes
+        =====
+
+        These methods of approximate integration are described in [1].
+
+        Examples
+        ========
+
+        >>> from sympy import Integral, sin, sqrt
+        >>> from sympy.abc import x, n
+        >>> e = Integral(sin(x), (x, 3, 7))
+        >>> e
+        Integral(sin(x), (x, 3, 7))
+
+        For demonstration purposes, this interval will only be split into 2
+        regions, bounded by [3, 5] and [5, 7].
+
+        The left-hand rule uses function evaluations at the left of each
+        interval:
+
+        >>> e.as_sum(2, 'left')
+        2*sin(5) + 2*sin(3)
+
+        The midpoint rule uses evaluations at the center of each interval:
+
+        >>> e.as_sum(2, 'midpoint')
+        2*sin(4) + 2*sin(6)
+
+        The right-hand rule uses function evaluations at the right of each
+        interval:
+
+        >>> e.as_sum(2, 'right')
+        2*sin(5) + 2*sin(7)
+
+        The trapezoid rule uses function evaluations on both sides of the
+        intervals. This is equivalent to taking the average of the left and
+        right hand rule results:
+
+        >>> s = e.as_sum(2, 'trapezoid')
+        >>> s
+        2*sin(5) + sin(3) + sin(7)
+        >>> (e.as_sum(2, 'left') + e.as_sum(2, 'right'))/2 == s
+        True
+
+        Here, the discontinuity at x = 0 can be avoided by using the
+        midpoint or right-hand method:
+
+        >>> e = Integral(1/sqrt(x), (x, 0, 1))
+        >>> e.as_sum(5).n(4)
+        1.730
+        >>> e.as_sum(10).n(4)
+        1.809
+        >>> e.doit().n(4)  # the actual value is 2
+        2.000
+
+        The left- or trapezoid method will encounter the discontinuity and
+        return infinity:
+
+        >>> e.as_sum(5, 'left')
+        zoo
+
+        The number of intervals can be symbolic. If omitted, a dummy symbol
+        will be used for it.
+
+        >>> e = Integral(x**2, (x, 0, 2))
+        >>> e.as_sum(n, 'right').expand()
+        8/3 + 4/n + 4/(3*n**2)
+
+        This shows that the midpoint rule is more accurate, as its error
+        term decays as the square of n:
+
+        >>> e.as_sum(method='midpoint').expand()
+        8/3 - 2/(3*_n**2)
+
+        A symbolic sum is returned with evaluate=False:
+
+        >>> e.as_sum(n, 'midpoint', evaluate=False)
+        2*Sum((2*_k/n - 1/n)**2, (_k, 1, n))/n
+
+        See Also
+        ========
+
+        Integral.doit : Perform the integration using any hints
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Riemann_sum#Riemann_summation_methods
+        """
+
+        from sympy.concrete.summations import Sum
+        limits = self.limits
+        if len(limits) > 1:
+            raise NotImplementedError(
+                "Multidimensional midpoint rule not implemented yet")
+        else:
+            limit = limits[0]
+            if (len(limit) != 3 or limit[1].is_finite is False or
+                limit[2].is_finite is False):
+                raise ValueError("Expecting a definite integral over "
+                                  "a finite interval.")
+        if n is None:
+            n = Dummy('n', integer=True, positive=True)
+        else:
+            n = sympify(n)
+        if (n.is_positive is False or n.is_integer is False or
+            n.is_finite is False):
+            raise ValueError("n must be a positive integer, got %s" % n)
+        x, a, b = limit
+        dx = (b - a)/n
+        k = Dummy('k', integer=True, positive=True)
+        f = self.function
+
+        if method == "left":
+            result = dx*Sum(f.subs(x, a + (k-1)*dx), (k, 1, n))
+        elif method == "right":
+            result = dx*Sum(f.subs(x, a + k*dx), (k, 1, n))
+        elif method == "midpoint":
+            result = dx*Sum(f.subs(x, a + k*dx - dx/2), (k, 1, n))
+        elif method == "trapezoid":
+            result = dx*((f.subs(x, a) + f.subs(x, b))/2 +
+                Sum(f.subs(x, a + k*dx), (k, 1, n - 1)))
+        else:
+            raise ValueError("Unknown method %s" % method)
+        return result.doit() if evaluate else result
+
+    def principal_value(self, **kwargs):
+        """
+        Compute the Cauchy Principal Value of the definite integral of a real function in the given interval
+        on the real axis.
+
+        Explanation
+        ===========
+
+        In mathematics, the Cauchy principal value, is a method for assigning values to certain improper
+        integrals which would otherwise be undefined.
+
+        Examples
+        ========
+
+        >>> from sympy import Integral, oo
+        >>> from sympy.abc import x
+        >>> Integral(x+1, (x, -oo, oo)).principal_value()
+        oo
+        >>> f = 1 / (x**3)
+        >>> Integral(f, (x, -oo, oo)).principal_value()
+        0
+        >>> Integral(f, (x, -10, 10)).principal_value()
+        0
+        >>> Integral(f, (x, -10, oo)).principal_value() + Integral(f, (x, -oo, 10)).principal_value()
+        0
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Cauchy_principal_value
+        .. [2] https://mathworld.wolfram.com/CauchyPrincipalValue.html
+        """
+        if len(self.limits) != 1 or len(list(self.limits[0])) != 3:
+            raise ValueError("You need to insert a variable, lower_limit, and upper_limit correctly to calculate "
+                             "cauchy's principal value")
+        x, a, b = self.limits[0]
+        if not (a.is_comparable and b.is_comparable and a <= b):
+            raise ValueError("The lower_limit must be smaller than or equal to the upper_limit to calculate "
+                             "cauchy's principal value. Also, a and b need to be comparable.")
+        if a == b:
+            return S.Zero
+
+        from sympy.calculus.singularities import singularities
+
+        r = Dummy('r')
+        f = self.function
+        singularities_list = [s for s in singularities(f, x) if s.is_comparable and a <= s <= b]
+        for i in singularities_list:
+            if i in (a, b):
+                raise ValueError(
+                    'The principal value is not defined in the given interval due to singularity at %d.' % (i))
+        F = integrate(f, x, **kwargs)
+        if F.has(Integral):
+            return self
+        if a is -oo and b is oo:
+            I = limit(F - F.subs(x, -x), x, oo)
+        else:
+            I = limit(F, x, b, '-') - limit(F, x, a, '+')
+        for s in singularities_list:
+            I += limit(((F.subs(x, s - r)) - F.subs(x, s + r)), r, 0, '+')
+        return I
+
+
+
+def integrate(*args, meijerg=None, conds='piecewise', risch=None, heurisch=None, manual=None, **kwargs):
+    """integrate(f, var, ...)
+
+    .. deprecated:: 1.6
+
+       Using ``integrate()`` with :class:`~.Poly` is deprecated. Use
+       :meth:`.Poly.integrate` instead. See :ref:`deprecated-integrate-poly`.
+
+    Explanation
+    ===========
+
+    Compute definite or indefinite integral of one or more variables
+    using Risch-Norman algorithm and table lookup. This procedure is
+    able to handle elementary algebraic and transcendental functions
+    and also a huge class of special functions, including Airy,
+    Bessel, Whittaker and Lambert.
+
+    var can be:
+
+    - a symbol                   -- indefinite integration
+    - a tuple (symbol, a)        -- indefinite integration with result
+                                    given with ``a`` replacing ``symbol``
+    - a tuple (symbol, a, b)     -- definite integration
+
+    Several variables can be specified, in which case the result is
+    multiple integration. (If var is omitted and the integrand is
+    univariate, the indefinite integral in that variable will be performed.)
+
+    Indefinite integrals are returned without terms that are independent
+    of the integration variables. (see examples)
+
+    Definite improper integrals often entail delicate convergence
+    conditions. Pass conds='piecewise', 'separate' or 'none' to have
+    these returned, respectively, as a Piecewise function, as a separate
+    result (i.e. result will be a tuple), or not at all (default is
+    'piecewise').
+
+    **Strategy**
+
+    SymPy uses various approaches to definite integration. One method is to
+    find an antiderivative for the integrand, and then use the fundamental
+    theorem of calculus. Various functions are implemented to integrate
+    polynomial, rational and trigonometric functions, and integrands
+    containing DiracDelta terms.
+
+    SymPy also implements the part of the Risch algorithm, which is a decision
+    procedure for integrating elementary functions, i.e., the algorithm can
+    either find an elementary antiderivative, or prove that one does not
+    exist.  There is also a (very successful, albeit somewhat slow) general
+    implementation of the heuristic Risch algorithm.  This algorithm will
+    eventually be phased out as more of the full Risch algorithm is
+    implemented. See the docstring of Integral._eval_integral() for more
+    details on computing the antiderivative using algebraic methods.
+
+    The option risch=True can be used to use only the (full) Risch algorithm.
+    This is useful if you want to know if an elementary function has an
+    elementary antiderivative.  If the indefinite Integral returned by this
+    function is an instance of NonElementaryIntegral, that means that the
+    Risch algorithm has proven that integral to be non-elementary.  Note that
+    by default, additional methods (such as the Meijer G method outlined
+    below) are tried on these integrals, as they may be expressible in terms
+    of special functions, so if you only care about elementary answers, use
+    risch=True.  Also note that an unevaluated Integral returned by this
+    function is not necessarily a NonElementaryIntegral, even with risch=True,
+    as it may just be an indication that the particular part of the Risch
+    algorithm needed to integrate that function is not yet implemented.
+
+    Another family of strategies comes from re-writing the integrand in
+    terms of so-called Meijer G-functions. Indefinite integrals of a
+    single G-function can always be computed, and the definite integral
+    of a product of two G-functions can be computed from zero to
+    infinity. Various strategies are implemented to rewrite integrands
+    as G-functions, and use this information to compute integrals (see
+    the ``meijerint`` module).
+
+    The option manual=True can be used to use only an algorithm that tries
+    to mimic integration by hand. This algorithm does not handle as many
+    integrands as the other algorithms implemented but may return results in
+    a more familiar form. The ``manualintegrate`` module has functions that
+    return the steps used (see the module docstring for more information).
+
+    In general, the algebraic methods work best for computing
+    antiderivatives of (possibly complicated) combinations of elementary
+    functions. The G-function methods work best for computing definite
+    integrals from zero to infinity of moderately complicated
+    combinations of special functions, or indefinite integrals of very
+    simple combinations of special functions.
+
+    The strategy employed by the integration code is as follows:
+
+    - If computing a definite integral, and both limits are real,
+      and at least one limit is +- oo, try the G-function method of
+      definite integration first.
+
+    - Try to find an antiderivative, using all available methods, ordered
+      by performance (that is try fastest method first, slowest last; in
+      particular polynomial integration is tried first, Meijer
+      G-functions second to last, and heuristic Risch last).
+
+    - If still not successful, try G-functions irrespective of the
+      limits.
+
+    The option meijerg=True, False, None can be used to, respectively:
+    always use G-function methods and no others, never use G-function
+    methods, or use all available methods (in order as described above).
+    It defaults to None.
+
+    Examples
+    ========
+
+    >>> from sympy import integrate, log, exp, oo
+    >>> from sympy.abc import a, x, y
+
+    >>> integrate(x*y, x)
+    x**2*y/2
+
+    >>> integrate(log(x), x)
+    x*log(x) - x
+
+    >>> integrate(log(x), (x, 1, a))
+    a*log(a) - a + 1
+
+    >>> integrate(x)
+    x**2/2
+
+    Terms that are independent of x are dropped by indefinite integration:
+
+    >>> from sympy import sqrt
+    >>> integrate(sqrt(1 + x), (x, 0, x))
+    2*(x + 1)**(3/2)/3 - 2/3
+    >>> integrate(sqrt(1 + x), x)
+    2*(x + 1)**(3/2)/3
+
+    >>> integrate(x*y)
+    Traceback (most recent call last):
+    ...
+    ValueError: specify integration variables to integrate x*y
+
+    Note that ``integrate(x)`` syntax is meant only for convenience
+    in interactive sessions and should be avoided in library code.
+
+    >>> integrate(x**a*exp(-x), (x, 0, oo)) # same as conds='piecewise'
+    Piecewise((gamma(a + 1), re(a) > -1),
+        (Integral(x**a*exp(-x), (x, 0, oo)), True))
+
+    >>> integrate(x**a*exp(-x), (x, 0, oo), conds='none')
+    gamma(a + 1)
+
+    >>> integrate(x**a*exp(-x), (x, 0, oo), conds='separate')
+    (gamma(a + 1), re(a) > -1)
+
+    See Also
+    ========
+
+    Integral, Integral.doit
+
+    """
+    doit_flags = {
+        'deep': False,
+        'meijerg': meijerg,
+        'conds': conds,
+        'risch': risch,
+        'heurisch': heurisch,
+        'manual': manual
+        }
+
+    integral = Integral(*args, **kwargs)
+
+    if isinstance(integral, Integral):
+        return integral.doit(**doit_flags)
+    else:
+        new_args = [a.doit(**doit_flags) if isinstance(a, Integral) else a
+            for a in integral.args]
+        return integral.func(*new_args)
+
+def line_integrate(field, curve, vars):
+    """line_integrate(field, Curve, variables)
+
+    Compute the line integral.
+
+    Examples
+    ========
+
+    >>> from sympy import Curve, line_integrate, E, ln
+    >>> from sympy.abc import x, y, t
+    >>> C = Curve([E**t + 1, E**t - 1], (t, 0, ln(2)))
+    >>> line_integrate(x + y, C, [x, y])
+    3*sqrt(2)
+
+    See Also
+    ========
+
+    sympy.integrals.integrals.integrate, Integral
+    """
+    from sympy.geometry import Curve
+    F = sympify(field)
+    if not F:
+        raise ValueError(
+            "Expecting function specifying field as first argument.")
+    if not isinstance(curve, Curve):
+        raise ValueError("Expecting Curve entity as second argument.")
+    if not is_sequence(vars):
+        raise ValueError("Expecting ordered iterable for variables.")
+    if len(curve.functions) != len(vars):
+        raise ValueError("Field variable size does not match curve dimension.")
+
+    if curve.parameter in vars:
+        raise ValueError("Curve parameter clashes with field parameters.")
+
+    # Calculate derivatives for line parameter functions
+    # F(r) -> F(r(t)) and finally F(r(t)*r'(t))
+    Ft = F
+    dldt = 0
+    for i, var in enumerate(vars):
+        _f = curve.functions[i]
+        _dn = diff(_f, curve.parameter)
+        # ...arc length
+        dldt = dldt + (_dn * _dn)
+        Ft = Ft.subs(var, _f)
+    Ft = Ft * sqrt(dldt)
+
+    integral = Integral(Ft, curve.limits).doit(deep=False)
+    return integral
+
+
+### Property function dispatching ###
+
+@shape.register(Integral)
+def _(expr):
+    return shape(expr.function)
+
+# Delayed imports
+from .deltafunctions import deltaintegrate
+from .meijerint import meijerint_definite, meijerint_indefinite, _debug
+from .trigonometry import trigintegrate

.venv/lib/python3.12/site-packages/sympy/integrals/intpoly.py

@@ -0,0 +1,1302 @@
+"""
+Module to implement integration of uni/bivariate polynomials over
+2D Polytopes and uni/bi/trivariate polynomials over 3D Polytopes.
+
+Uses evaluation techniques as described in Chin et al. (2015) [1].
+
+
+References
+===========
+
+.. [1] Chin, Eric B., Jean B. Lasserre, and N. Sukumar. "Numerical integration
+of homogeneous functions on convex and nonconvex polygons and polyhedra."
+Computational Mechanics 56.6 (2015): 967-981
+
+PDF link : http://dilbert.engr.ucdavis.edu/~suku/quadrature/cls-integration.pdf
+"""
+
+from functools import cmp_to_key
+
+from sympy.abc import x, y, z
+from sympy.core import S, diff, Expr, Symbol
+from sympy.core.sympify import _sympify
+from sympy.geometry import Segment2D, Polygon, Point, Point2D
+from sympy.polys.polytools import LC, gcd_list, degree_list, Poly
+from sympy.simplify.simplify import nsimplify
+
+
+def polytope_integrate(poly, expr=None, *, clockwise=False, max_degree=None):
+    """Integrates polynomials over 2/3-Polytopes.
+
+    Explanation
+    ===========
+
+    This function accepts the polytope in ``poly`` and the function in ``expr``
+    (uni/bi/trivariate polynomials are implemented) and returns
+    the exact integral of ``expr`` over ``poly``.
+
+    Parameters
+    ==========
+
+    poly : The input Polygon.
+
+    expr : The input polynomial.
+
+    clockwise : Binary value to sort input points of 2-Polytope clockwise.(Optional)
+
+    max_degree : The maximum degree of any monomial of the input polynomial.(Optional)
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y
+    >>> from sympy import Point, Polygon
+    >>> from sympy.integrals.intpoly import polytope_integrate
+    >>> polygon = Polygon(Point(0, 0), Point(0, 1), Point(1, 1), Point(1, 0))
+    >>> polys = [1, x, y, x*y, x**2*y, x*y**2]
+    >>> expr = x*y
+    >>> polytope_integrate(polygon, expr)
+    1/4
+    >>> polytope_integrate(polygon, polys, max_degree=3)
+    {1: 1, x: 1/2, y: 1/2, x*y: 1/4, x*y**2: 1/6, x**2*y: 1/6}
+    """
+    if clockwise:
+        if isinstance(poly, Polygon):
+            poly = Polygon(*point_sort(poly.vertices), evaluate=False)
+        else:
+            raise TypeError("clockwise=True works for only 2-Polytope"
+                            "V-representation input")
+
+    if isinstance(poly, Polygon):
+        # For Vertex Representation(2D case)
+        hp_params = hyperplane_parameters(poly)
+        facets = poly.sides
+    elif len(poly[0]) == 2:
+        # For Hyperplane Representation(2D case)
+        plen = len(poly)
+        if len(poly[0][0]) == 2:
+            intersections = [intersection(poly[(i - 1) % plen], poly[i],
+                                          "plane2D")
+                             for i in range(0, plen)]
+            hp_params = poly
+            lints = len(intersections)
+            facets = [Segment2D(intersections[i],
+                                intersections[(i + 1) % lints])
+                      for i in range(lints)]
+        else:
+            raise NotImplementedError("Integration for H-representation 3D"
+                                      "case not implemented yet.")
+    else:
+        # For Vertex Representation(3D case)
+        vertices = poly[0]
+        facets = poly[1:]
+        hp_params = hyperplane_parameters(facets, vertices)
+
+        if max_degree is None:
+            if expr is None:
+                raise TypeError('Input expression must be a valid SymPy expression')
+            return main_integrate3d(expr, facets, vertices, hp_params)
+
+    if max_degree is not None:
+        result = {}
+        if expr is not None:
+            f_expr = []
+            for e in expr:
+                _ = decompose(e)
+                if len(_) == 1 and not _.popitem()[0]:
+                    f_expr.append(e)
+                elif Poly(e).total_degree() <= max_degree:
+                    f_expr.append(e)
+            expr = f_expr
+
+        if not isinstance(expr, list) and expr is not None:
+            raise TypeError('Input polynomials must be list of expressions')
+
+        if len(hp_params[0][0]) == 3:
+            result_dict = main_integrate3d(0, facets, vertices, hp_params,
+                                           max_degree)
+        else:
+            result_dict = main_integrate(0, facets, hp_params, max_degree)
+
+        if expr is None:
+            return result_dict
+
+        for poly in expr:
+            poly = _sympify(poly)
+            if poly not in result:
+                if poly.is_zero:
+                    result[S.Zero] = S.Zero
+                    continue
+                integral_value = S.Zero
+                monoms = decompose(poly, separate=True)
+                for monom in monoms:
+                    monom = nsimplify(monom)
+                    coeff, m = strip(monom)
+                    integral_value += result_dict[m] * coeff
+                result[poly] = integral_value
+        return result
+
+    if expr is None:
+        raise TypeError('Input expression must be a valid SymPy expression')
+
+    return main_integrate(expr, facets, hp_params)
+
+
+def strip(monom):
+    if monom.is_zero:
+        return S.Zero, S.Zero
+    elif monom.is_number:
+        return monom, S.One
+    else:
+        coeff = LC(monom)
+        return coeff, monom / coeff
+
+def _polynomial_integrate(polynomials, facets, hp_params):
+    dims = (x, y)
+    dim_length = len(dims)
+    integral_value = S.Zero
+    for deg in polynomials:
+        poly_contribute = S.Zero
+        facet_count = 0
+        for hp in hp_params:
+            value_over_boundary = integration_reduction(facets,
+                                                        facet_count,
+                                                        hp[0], hp[1],
+                                                        polynomials[deg],
+                                                        dims, deg)
+            poly_contribute += value_over_boundary * (hp[1] / norm(hp[0]))
+            facet_count += 1
+        poly_contribute /= (dim_length + deg)
+        integral_value += poly_contribute
+
+    return integral_value
+
+
+def main_integrate3d(expr, facets, vertices, hp_params, max_degree=None):
+    """Function to translate the problem of integrating uni/bi/tri-variate
+    polynomials over a 3-Polytope to integrating over its faces.
+    This is done using Generalized Stokes' Theorem and Euler's Theorem.
+
+    Parameters
+    ==========
+
+    expr :
+        The input polynomial.
+    facets :
+        Faces of the 3-Polytope(expressed as indices of `vertices`).
+    vertices :
+        Vertices that constitute the Polytope.
+    hp_params :
+        Hyperplane Parameters of the facets.
+    max_degree : optional
+        Max degree of constituent monomial in given list of polynomial.
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.intpoly import main_integrate3d, \
+    hyperplane_parameters
+    >>> cube = [[(0, 0, 0), (0, 0, 5), (0, 5, 0), (0, 5, 5), (5, 0, 0),\
+                (5, 0, 5), (5, 5, 0), (5, 5, 5)],\
+                [2, 6, 7, 3], [3, 7, 5, 1], [7, 6, 4, 5], [1, 5, 4, 0],\
+                [3, 1, 0, 2], [0, 4, 6, 2]]
+    >>> vertices = cube[0]
+    >>> faces = cube[1:]
+    >>> hp_params = hyperplane_parameters(faces, vertices)
+    >>> main_integrate3d(1, faces, vertices, hp_params)
+    -125
+    """
+    result = {}
+    dims = (x, y, z)
+    dim_length = len(dims)
+    if max_degree:
+        grad_terms = gradient_terms(max_degree, 3)
+        flat_list = [term for z_terms in grad_terms
+                     for x_term in z_terms
+                     for term in x_term]
+
+        for term in flat_list:
+            result[term[0]] = 0
+
+        for facet_count, hp in enumerate(hp_params):
+            a, b = hp[0], hp[1]
+            x0 = vertices[facets[facet_count][0]]
+
+            for i, monom in enumerate(flat_list):
+                #  Every monomial is a tuple :
+                #  (term, x_degree, y_degree, z_degree, value over boundary)
+                expr, x_d, y_d, z_d, z_index, y_index, x_index, _ = monom
+                degree = x_d + y_d + z_d
+                if b.is_zero:
+                    value_over_face = S.Zero
+                else:
+                    value_over_face = \
+                        integration_reduction_dynamic(facets, facet_count, a,
+                                                      b, expr, degree, dims,
+                                                      x_index, y_index,
+                                                      z_index, x0, grad_terms,
+                                                      i, vertices, hp)
+                monom[7] = value_over_face
+                result[expr] += value_over_face * \
+                    (b / norm(a)) / (dim_length + x_d + y_d + z_d)
+        return result
+    else:
+        integral_value = S.Zero
+        polynomials = decompose(expr)
+        for deg in polynomials:
+            poly_contribute = S.Zero
+            facet_count = 0
+            for i, facet in enumerate(facets):
+                hp = hp_params[i]
+                if hp[1].is_zero:
+                    continue
+                pi = polygon_integrate(facet, hp, i, facets, vertices, expr, deg)
+                poly_contribute += pi *\
+                    (hp[1] / norm(tuple(hp[0])))
+                facet_count += 1
+            poly_contribute /= (dim_length + deg)
+            integral_value += poly_contribute
+    return integral_value
+
+
+def main_integrate(expr, facets, hp_params, max_degree=None):
+    """Function to translate the problem of integrating univariate/bivariate
+    polynomials over a 2-Polytope to integrating over its boundary facets.
+    This is done using Generalized Stokes's Theorem and Euler's Theorem.
+
+    Parameters
+    ==========
+
+    expr :
+        The input polynomial.
+    facets :
+        Facets(Line Segments) of the 2-Polytope.
+    hp_params :
+        Hyperplane Parameters of the facets.
+    max_degree : optional
+        The maximum degree of any monomial of the input polynomial.
+
+    >>> from sympy.abc import x, y
+    >>> from sympy.integrals.intpoly import main_integrate,\
+    hyperplane_parameters
+    >>> from sympy import Point, Polygon
+    >>> triangle = Polygon(Point(0, 3), Point(5, 3), Point(1, 1))
+    >>> facets = triangle.sides
+    >>> hp_params = hyperplane_parameters(triangle)
+    >>> main_integrate(x**2 + y**2, facets, hp_params)
+    325/6
+    """
+    dims = (x, y)
+    dim_length = len(dims)
+    result = {}
+
+    if max_degree:
+        grad_terms = [[0, 0, 0, 0]] + gradient_terms(max_degree)
+
+        for facet_count, hp in enumerate(hp_params):
+            a, b = hp[0], hp[1]
+            x0 = facets[facet_count].points[0]
+
+            for i, monom in enumerate(grad_terms):
+                #  Every monomial is a tuple :
+                #  (term, x_degree, y_degree, value over boundary)
+                m, x_d, y_d, _ = monom
+                value = result.get(m, None)
+                degree = S.Zero
+                if b.is_zero:
+                    value_over_boundary = S.Zero
+                else:
+                    degree = x_d + y_d
+                    value_over_boundary = \
+                        integration_reduction_dynamic(facets, facet_count, a,
+                                                      b, m, degree, dims, x_d,
+                                                      y_d, max_degree, x0,
+                                                      grad_terms, i)
+                monom[3] = value_over_boundary
+                if value is not None:
+                    result[m] += value_over_boundary * \
+                                        (b / norm(a)) / (dim_length + degree)
+                else:
+                    result[m] = value_over_boundary * \
+                                (b / norm(a)) / (dim_length + degree)
+        return result
+    else:
+        if not isinstance(expr, list):
+            polynomials = decompose(expr)
+            return _polynomial_integrate(polynomials, facets, hp_params)
+        else:
+            return {e: _polynomial_integrate(decompose(e), facets, hp_params) for e in expr}
+
+
+def polygon_integrate(facet, hp_param, index, facets, vertices, expr, degree):
+    """Helper function to integrate the input uni/bi/trivariate polynomial
+    over a certain face of the 3-Polytope.
+
+    Parameters
+    ==========
+
+    facet :
+        Particular face of the 3-Polytope over which ``expr`` is integrated.
+    index :
+        The index of ``facet`` in ``facets``.
+    facets :
+        Faces of the 3-Polytope(expressed as indices of `vertices`).
+    vertices :
+        Vertices that constitute the facet.
+    expr :
+        The input polynomial.
+    degree :
+        Degree of ``expr``.
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.intpoly import polygon_integrate
+    >>> cube = [[(0, 0, 0), (0, 0, 5), (0, 5, 0), (0, 5, 5), (5, 0, 0),\
+                 (5, 0, 5), (5, 5, 0), (5, 5, 5)],\
+                 [2, 6, 7, 3], [3, 7, 5, 1], [7, 6, 4, 5], [1, 5, 4, 0],\
+                 [3, 1, 0, 2], [0, 4, 6, 2]]
+    >>> facet = cube[1]
+    >>> facets = cube[1:]
+    >>> vertices = cube[0]
+    >>> polygon_integrate(facet, [(0, 1, 0), 5], 0, facets, vertices, 1, 0)
+    -25
+    """
+    expr = S(expr)
+    if expr.is_zero:
+        return S.Zero
+    result = S.Zero
+    x0 = vertices[facet[0]]
+    facet_len = len(facet)
+    for i, fac in enumerate(facet):
+        side = (vertices[fac], vertices[facet[(i + 1) % facet_len]])
+        result += distance_to_side(x0, side, hp_param[0]) *\
+            lineseg_integrate(facet, i, side, expr, degree)
+    if not expr.is_number:
+        expr = diff(expr, x) * x0[0] + diff(expr, y) * x0[1] +\
+            diff(expr, z) * x0[2]
+        result += polygon_integrate(facet, hp_param, index, facets, vertices,
+                                    expr, degree - 1)
+    result /= (degree + 2)
+    return result
+
+
+def distance_to_side(point, line_seg, A):
+    """Helper function to compute the signed distance between given 3D point
+    and a line segment.
+
+    Parameters
+    ==========
+
+    point : 3D Point
+    line_seg : Line Segment
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.intpoly import distance_to_side
+    >>> point = (0, 0, 0)
+    >>> distance_to_side(point, [(0, 0, 1), (0, 1, 0)], (1, 0, 0))
+    -sqrt(2)/2
+    """
+    x1, x2 = line_seg
+    rev_normal = [-1 * S(i)/norm(A) for i in A]
+    vector = [x2[i] - x1[i] for i in range(0, 3)]
+    vector = [vector[i]/norm(vector) for i in range(0, 3)]
+
+    n_side = cross_product((0, 0, 0), rev_normal, vector)
+    vectorx0 = [line_seg[0][i] - point[i] for i in range(0, 3)]
+    dot_product = sum(vectorx0[i] * n_side[i] for i in range(0, 3))
+
+    return dot_product
+
+
+def lineseg_integrate(polygon, index, line_seg, expr, degree):
+    """Helper function to compute the line integral of ``expr`` over ``line_seg``.
+
+    Parameters
+    ===========
+
+    polygon :
+        Face of a 3-Polytope.
+    index :
+        Index of line_seg in polygon.
+    line_seg :
+        Line Segment.
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.intpoly import lineseg_integrate
+    >>> polygon = [(0, 5, 0), (5, 5, 0), (5, 5, 5), (0, 5, 5)]
+    >>> line_seg = [(0, 5, 0), (5, 5, 0)]
+    >>> lineseg_integrate(polygon, 0, line_seg, 1, 0)
+    5
+    """
+    expr = _sympify(expr)
+    if expr.is_zero:
+        return S.Zero
+    result = S.Zero
+    x0 = line_seg[0]
+    distance = norm(tuple([line_seg[1][i] - line_seg[0][i] for i in
+                           range(3)]))
+    if isinstance(expr, Expr):
+        expr_dict = {x: line_seg[1][0],
+                     y: line_seg[1][1],
+                     z: line_seg[1][2]}
+        result += distance * expr.subs(expr_dict)
+    else:
+        result += distance * expr
+
+    expr = diff(expr, x) * x0[0] + diff(expr, y) * x0[1] +\
+        diff(expr, z) * x0[2]
+
+    result += lineseg_integrate(polygon, index, line_seg, expr, degree - 1)
+    result /= (degree + 1)
+    return result
+
+
+def integration_reduction(facets, index, a, b, expr, dims, degree):
+    """Helper method for main_integrate. Returns the value of the input
+    expression evaluated over the polytope facet referenced by a given index.
+
+    Parameters
+    ===========
+
+    facets :
+        List of facets of the polytope.
+    index :
+        Index referencing the facet to integrate the expression over.
+    a :
+        Hyperplane parameter denoting direction.
+    b :
+        Hyperplane parameter denoting distance.
+    expr :
+        The expression to integrate over the facet.
+    dims :
+        List of symbols denoting axes.
+    degree :
+        Degree of the homogeneous polynomial.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y
+    >>> from sympy.integrals.intpoly import integration_reduction,\
+    hyperplane_parameters
+    >>> from sympy import Point, Polygon
+    >>> triangle = Polygon(Point(0, 3), Point(5, 3), Point(1, 1))
+    >>> facets = triangle.sides
+    >>> a, b = hyperplane_parameters(triangle)[0]
+    >>> integration_reduction(facets, 0, a, b, 1, (x, y), 0)
+    5
+    """
+    expr = _sympify(expr)
+    if expr.is_zero:
+        return expr
+
+    value = S.Zero
+    x0 = facets[index].points[0]
+    m = len(facets)
+    gens = (x, y)
+
+    inner_product = diff(expr, gens[0]) * x0[0] + diff(expr, gens[1]) * x0[1]
+
+    if inner_product != 0:
+        value += integration_reduction(facets, index, a, b,
+                                       inner_product, dims, degree - 1)
+
+    value += left_integral2D(m, index, facets, x0, expr, gens)
+
+    return value/(len(dims) + degree - 1)
+
+
+def left_integral2D(m, index, facets, x0, expr, gens):
+    """Computes the left integral of Eq 10 in Chin et al.
+    For the 2D case, the integral is just an evaluation of the polynomial
+    at the intersection of two facets which is multiplied by the distance
+    between the first point of facet and that intersection.
+
+    Parameters
+    ==========
+
+    m :
+        No. of hyperplanes.
+    index :
+        Index of facet to find intersections with.
+    facets :
+        List of facets(Line Segments in 2D case).
+    x0 :
+        First point on facet referenced by index.
+    expr :
+        Input polynomial
+    gens :
+        Generators which generate the polynomial
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y
+    >>> from sympy.integrals.intpoly import left_integral2D
+    >>> from sympy import Point, Polygon
+    >>> triangle = Polygon(Point(0, 3), Point(5, 3), Point(1, 1))
+    >>> facets = triangle.sides
+    >>> left_integral2D(3, 0, facets, facets[0].points[0], 1, (x, y))
+    5
+    """
+    value = S.Zero
+    for j in range(m):
+        intersect = ()
+        if j in ((index - 1) % m, (index + 1) % m):
+            intersect = intersection(facets[index], facets[j], "segment2D")
+        if intersect:
+            distance_origin = norm(tuple(map(lambda x, y: x - y,
+                                             intersect, x0)))
+            if is_vertex(intersect):
+                if isinstance(expr, Expr):
+                    if len(gens) == 3:
+                        expr_dict = {gens[0]: intersect[0],
+                                     gens[1]: intersect[1],
+                                     gens[2]: intersect[2]}
+                    else:
+                        expr_dict = {gens[0]: intersect[0],
+                                     gens[1]: intersect[1]}
+                    value += distance_origin * expr.subs(expr_dict)
+                else:
+                    value += distance_origin * expr
+    return value
+
+
+def integration_reduction_dynamic(facets, index, a, b, expr, degree, dims,
+                                  x_index, y_index, max_index, x0,
+                                  monomial_values, monom_index, vertices=None,
+                                  hp_param=None):
+    """The same integration_reduction function which uses a dynamic
+    programming approach to compute terms by using the values of the integral
+    of previously computed terms.
+
+    Parameters
+    ==========
+
+    facets :
+        Facets of the Polytope.
+    index :
+        Index of facet to find intersections with.(Used in left_integral()).
+    a, b :
+        Hyperplane parameters.
+    expr :
+        Input monomial.
+    degree :
+        Total degree of ``expr``.
+    dims :
+        Tuple denoting axes variables.
+    x_index :
+        Exponent of 'x' in ``expr``.
+    y_index :
+        Exponent of 'y' in ``expr``.
+    max_index :
+        Maximum exponent of any monomial in ``monomial_values``.
+    x0 :
+        First point on ``facets[index]``.
+    monomial_values :
+        List of monomial values constituting the polynomial.
+    monom_index :
+        Index of monomial whose integration is being found.
+    vertices : optional
+        Coordinates of vertices constituting the 3-Polytope.
+    hp_param : optional
+        Hyperplane Parameter of the face of the facets[index].
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y
+    >>> from sympy.integrals.intpoly import (integration_reduction_dynamic, \
+            hyperplane_parameters)
+    >>> from sympy import Point, Polygon
+    >>> triangle = Polygon(Point(0, 3), Point(5, 3), Point(1, 1))
+    >>> facets = triangle.sides
+    >>> a, b = hyperplane_parameters(triangle)[0]
+    >>> x0 = facets[0].points[0]
+    >>> monomial_values = [[0, 0, 0, 0], [1, 0, 0, 5],\
+                           [y, 0, 1, 15], [x, 1, 0, None]]
+    >>> integration_reduction_dynamic(facets, 0, a, b, x, 1, (x, y), 1, 0, 1,\
+                                      x0, monomial_values, 3)
+    25/2
+    """
+    value = S.Zero
+    m = len(facets)
+
+    if expr == S.Zero:
+        return expr
+
+    if len(dims) == 2:
+        if not expr.is_number:
+            _, x_degree, y_degree, _ = monomial_values[monom_index]
+            x_index = monom_index - max_index + \
+                x_index - 2 if x_degree > 0 else 0
+            y_index = monom_index - 1 if y_degree > 0 else 0
+            x_value, y_value =\
+                monomial_values[x_index][3], monomial_values[y_index][3]
+
+            value += x_degree * x_value * x0[0] + y_degree * y_value * x0[1]
+
+        value += left_integral2D(m, index, facets, x0, expr, dims)
+    else:
+        # For 3D use case the max_index contains the z_degree of the term
+        z_index = max_index
+        if not expr.is_number:
+            x_degree, y_degree, z_degree = y_index,\
+                                           z_index - x_index - y_index, x_index
+            x_value = monomial_values[z_index - 1][y_index - 1][x_index][7]\
+                if x_degree > 0 else 0
+            y_value = monomial_values[z_index - 1][y_index][x_index][7]\
+                if y_degree > 0 else 0
+            z_value = monomial_values[z_index - 1][y_index][x_index - 1][7]\
+                if z_degree > 0 else 0
+
+            value += x_degree * x_value * x0[0] + y_degree * y_value * x0[1] \
+                + z_degree * z_value * x0[2]
+
+        value += left_integral3D(facets, index, expr,
+                                 vertices, hp_param, degree)
+    return value / (len(dims) + degree - 1)
+
+
+def left_integral3D(facets, index, expr, vertices, hp_param, degree):
+    """Computes the left integral of Eq 10 in Chin et al.
+
+    Explanation
+    ===========
+
+    For the 3D case, this is the sum of the integral values over constituting
+    line segments of the face (which is accessed by facets[index]) multiplied
+    by the distance between the first point of facet and that line segment.
+
+    Parameters
+    ==========
+
+    facets :
+        List of faces of the 3-Polytope.
+    index :
+        Index of face over which integral is to be calculated.
+    expr :
+        Input polynomial.
+    vertices :
+        List of vertices that constitute the 3-Polytope.
+    hp_param :
+        The hyperplane parameters of the face.
+    degree :
+        Degree of the ``expr``.
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.intpoly import left_integral3D
+    >>> cube = [[(0, 0, 0), (0, 0, 5), (0, 5, 0), (0, 5, 5), (5, 0, 0),\
+                 (5, 0, 5), (5, 5, 0), (5, 5, 5)],\
+                 [2, 6, 7, 3], [3, 7, 5, 1], [7, 6, 4, 5], [1, 5, 4, 0],\
+                 [3, 1, 0, 2], [0, 4, 6, 2]]
+    >>> facets = cube[1:]
+    >>> vertices = cube[0]
+    >>> left_integral3D(facets, 3, 1, vertices, ([0, -1, 0], -5), 0)
+    -50
+    """
+    value = S.Zero
+    facet = facets[index]
+    x0 = vertices[facet[0]]
+    facet_len = len(facet)
+    for i, fac in enumerate(facet):
+        side = (vertices[fac], vertices[facet[(i + 1) % facet_len]])
+        value += distance_to_side(x0, side, hp_param[0]) * \
+            lineseg_integrate(facet, i, side, expr, degree)
+    return value
+
+
+def gradient_terms(binomial_power=0, no_of_gens=2):
+    """Returns a list of all the possible monomials between
+    0 and y**binomial_power for 2D case and z**binomial_power
+    for 3D case.
+
+    Parameters
+    ==========
+
+    binomial_power :
+        Power upto which terms are generated.
+    no_of_gens :
+        Denotes whether terms are being generated for 2D or 3D case.
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.intpoly import gradient_terms
+    >>> gradient_terms(2)
+    [[1, 0, 0, 0], [y, 0, 1, 0], [y**2, 0, 2, 0], [x, 1, 0, 0],
+    [x*y, 1, 1, 0], [x**2, 2, 0, 0]]
+    >>> gradient_terms(2, 3)
+    [[[[1, 0, 0, 0, 0, 0, 0, 0]]], [[[y, 0, 1, 0, 1, 0, 0, 0],
+    [z, 0, 0, 1, 1, 0, 1, 0]], [[x, 1, 0, 0, 1, 1, 0, 0]]],
+    [[[y**2, 0, 2, 0, 2, 0, 0, 0], [y*z, 0, 1, 1, 2, 0, 1, 0],
+    [z**2, 0, 0, 2, 2, 0, 2, 0]], [[x*y, 1, 1, 0, 2, 1, 0, 0],
+    [x*z, 1, 0, 1, 2, 1, 1, 0]], [[x**2, 2, 0, 0, 2, 2, 0, 0]]]]
+    """
+    if no_of_gens == 2:
+        count = 0
+        terms = [None] * int((binomial_power ** 2 + 3 * binomial_power + 2) / 2)
+        for x_count in range(0, binomial_power + 1):
+            for y_count in range(0, binomial_power - x_count + 1):
+                terms[count] = [x**x_count*y**y_count,
+                                x_count, y_count, 0]
+                count += 1
+    else:
+        terms = [[[[x ** x_count * y ** y_count *
+                    z ** (z_count - y_count - x_count),
+                    x_count, y_count, z_count - y_count - x_count,
+                    z_count, x_count, z_count - y_count - x_count, 0]
+                 for y_count in range(z_count - x_count, -1, -1)]
+                 for x_count in range(0, z_count + 1)]
+                 for z_count in range(0, binomial_power + 1)]
+    return terms
+
+
+def hyperplane_parameters(poly, vertices=None):
+    """A helper function to return the hyperplane parameters
+    of which the facets of the polytope are a part of.
+
+    Parameters
+    ==========
+
+    poly :
+        The input 2/3-Polytope.
+    vertices :
+        Vertex indices of 3-Polytope.
+
+    Examples
+    ========
+
+    >>> from sympy import Point, Polygon
+    >>> from sympy.integrals.intpoly import hyperplane_parameters
+    >>> hyperplane_parameters(Polygon(Point(0, 3), Point(5, 3), Point(1, 1)))
+    [((0, 1), 3), ((1, -2), -1), ((-2, -1), -3)]
+    >>> cube = [[(0, 0, 0), (0, 0, 5), (0, 5, 0), (0, 5, 5), (5, 0, 0),\
+                (5, 0, 5), (5, 5, 0), (5, 5, 5)],\
+                [2, 6, 7, 3], [3, 7, 5, 1], [7, 6, 4, 5], [1, 5, 4, 0],\
+                [3, 1, 0, 2], [0, 4, 6, 2]]
+    >>> hyperplane_parameters(cube[1:], cube[0])
+    [([0, -1, 0], -5), ([0, 0, -1], -5), ([-1, 0, 0], -5),
+    ([0, 1, 0], 0), ([1, 0, 0], 0), ([0, 0, 1], 0)]
+    """
+    if isinstance(poly, Polygon):
+        vertices = list(poly.vertices) + [poly.vertices[0]]  # Close the polygon
+        params = [None] * (len(vertices) - 1)
+
+        for i in range(len(vertices) - 1):
+            v1 = vertices[i]
+            v2 = vertices[i + 1]
+
+            a1 = v1[1] - v2[1]
+            a2 = v2[0] - v1[0]
+            b = v2[0] * v1[1] - v2[1] * v1[0]
+
+            factor = gcd_list([a1, a2, b])
+
+            b = S(b) / factor
+            a = (S(a1) / factor, S(a2) / factor)
+            params[i] = (a, b)
+    else:
+        params = [None] * len(poly)
+        for i, polygon in enumerate(poly):
+            v1, v2, v3 = [vertices[vertex] for vertex in polygon[:3]]
+            normal = cross_product(v1, v2, v3)
+            b = sum(normal[j] * v1[j] for j in range(0, 3))
+            fac = gcd_list(normal)
+            if fac.is_zero:
+                fac = 1
+            normal = [j / fac for j in normal]
+            b = b / fac
+            params[i] = (normal, b)
+    return params
+
+
+def cross_product(v1, v2, v3):
+    """Returns the cross-product of vectors (v2 - v1) and (v3 - v1)
+    That is : (v2 - v1) X (v3 - v1)
+    """
+    v2 = [v2[j] - v1[j] for j in range(0, 3)]
+    v3 = [v3[j] - v1[j] for j in range(0, 3)]
+    return [v3[2] * v2[1] - v3[1] * v2[2],
+            v3[0] * v2[2] - v3[2] * v2[0],
+            v3[1] * v2[0] - v3[0] * v2[1]]
+
+
+def best_origin(a, b, lineseg, expr):
+    """Helper method for polytope_integrate. Currently not used in the main
+    algorithm.
+
+    Explanation
+    ===========
+
+    Returns a point on the lineseg whose vector inner product with the
+    divergence of `expr` yields an expression with the least maximum
+    total power.
+
+    Parameters
+    ==========
+
+    a :
+        Hyperplane parameter denoting direction.
+    b :
+        Hyperplane parameter denoting distance.
+    lineseg :
+        Line segment on which to find the origin.
+    expr :
+        The expression which determines the best point.
+
+    Algorithm(currently works only for 2D use case)
+    ===============================================
+
+    1 > Firstly, check for edge cases. Here that would refer to vertical
+        or horizontal lines.
+
+    2 > If input expression is a polynomial containing more than one generator
+        then find out the total power of each of the generators.
+
+        x**2 + 3 + x*y + x**4*y**5 ---> {x: 7, y: 6}
+
+        If expression is a constant value then pick the first boundary point
+        of the line segment.
+
+    3 > First check if a point exists on the line segment where the value of
+        the highest power generator becomes 0. If not check if the value of
+        the next highest becomes 0. If none becomes 0 within line segment
+        constraints then pick the first boundary point of the line segment.
+        Actually, any point lying on the segment can be picked as best origin
+        in the last case.
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.intpoly import best_origin
+    >>> from sympy.abc import x, y
+    >>> from sympy import Point, Segment2D
+    >>> l = Segment2D(Point(0, 3), Point(1, 1))
+    >>> expr = x**3*y**7
+    >>> best_origin((2, 1), 3, l, expr)
+    (0, 3.0)
+    """
+    a1, b1 = lineseg.points[0]
+
+    def x_axis_cut(ls):
+        """Returns the point where the input line segment
+        intersects the x-axis.
+
+        Parameters
+        ==========
+
+        ls :
+            Line segment
+        """
+        p, q = ls.points
+        if p.y.is_zero:
+            return tuple(p)
+        elif q.y.is_zero:
+            return tuple(q)
+        elif p.y/q.y < S.Zero:
+            return p.y * (p.x - q.x)/(q.y - p.y) + p.x, S.Zero
+        else:
+            return ()
+
+    def y_axis_cut(ls):
+        """Returns the point where the input line segment
+        intersects the y-axis.
+
+        Parameters
+        ==========
+
+        ls :
+            Line segment
+        """
+        p, q = ls.points
+        if p.x.is_zero:
+            return tuple(p)
+        elif q.x.is_zero:
+            return tuple(q)
+        elif p.x/q.x < S.Zero:
+            return S.Zero, p.x * (p.y - q.y)/(q.x - p.x) + p.y
+        else:
+            return ()
+
+    gens = (x, y)
+    power_gens = {}
+
+    for i in gens:
+        power_gens[i] = S.Zero
+
+    if len(gens) > 1:
+        # Special case for vertical and horizontal lines
+        if len(gens) == 2:
+            if a[0] == 0:
+                if y_axis_cut(lineseg):
+                    return S.Zero, b/a[1]
+                else:
+                    return a1, b1
+            elif a[1] == 0:
+                if x_axis_cut(lineseg):
+                    return b/a[0], S.Zero
+                else:
+                    return a1, b1
+
+        if isinstance(expr, Expr):  # Find the sum total of power of each
+            if expr.is_Add:         # generator and store in a dictionary.
+                for monomial in expr.args:
+                    if monomial.is_Pow:
+                        if monomial.args[0] in gens:
+                            power_gens[monomial.args[0]] += monomial.args[1]
+                    else:
+                        for univariate in monomial.args:
+                            term_type = len(univariate.args)
+                            if term_type == 0 and univariate in gens:
+                                power_gens[univariate] += 1
+                            elif term_type == 2 and univariate.args[0] in gens:
+                                power_gens[univariate.args[0]] +=\
+                                           univariate.args[1]
+            elif expr.is_Mul:
+                for term in expr.args:
+                    term_type = len(term.args)
+                    if term_type == 0 and term in gens:
+                        power_gens[term] += 1
+                    elif term_type == 2 and term.args[0] in gens:
+                        power_gens[term.args[0]] += term.args[1]
+            elif expr.is_Pow:
+                power_gens[expr.args[0]] = expr.args[1]
+            elif expr.is_Symbol:
+                power_gens[expr] += 1
+        else:  # If `expr` is a constant take first vertex of the line segment.
+            return a1, b1
+
+        #  TODO : This part is quite hacky. Should be made more robust with
+        #  TODO : respect to symbol names and scalable w.r.t higher dimensions.
+        power_gens = sorted(power_gens.items(), key=lambda k: str(k[0]))
+        if power_gens[0][1] >= power_gens[1][1]:
+            if y_axis_cut(lineseg):
+                x0 = (S.Zero, b / a[1])
+            elif x_axis_cut(lineseg):
+                x0 = (b / a[0], S.Zero)
+            else:
+                x0 = (a1, b1)
+        else:
+            if x_axis_cut(lineseg):
+                x0 = (b/a[0], S.Zero)
+            elif y_axis_cut(lineseg):
+                x0 = (S.Zero, b/a[1])
+            else:
+                x0 = (a1, b1)
+    else:
+        x0 = (b/a[0])
+    return x0
+
+
+def decompose(expr, separate=False):
+    """Decomposes an input polynomial into homogeneous ones of
+    smaller or equal degree.
+
+    Explanation
+    ===========
+
+    Returns a dictionary with keys as the degree of the smaller
+    constituting polynomials. Values are the constituting polynomials.
+
+    Parameters
+    ==========
+
+    expr : Expr
+        Polynomial(SymPy expression).
+    separate : bool
+        If True then simply return a list of the constituent monomials
+        If not then break up the polynomial into constituent homogeneous
+        polynomials.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y
+    >>> from sympy.integrals.intpoly import decompose
+    >>> decompose(x**2 + x*y + x + y + x**3*y**2 + y**5)
+    {1: x + y, 2: x**2 + x*y, 5: x**3*y**2 + y**5}
+    >>> decompose(x**2 + x*y + x + y + x**3*y**2 + y**5, True)
+    {x, x**2, y, y**5, x*y, x**3*y**2}
+    """
+    poly_dict = {}
+
+    if isinstance(expr, Expr) and not expr.is_number:
+        if expr.is_Symbol:
+            poly_dict[1] = expr
+        elif expr.is_Add:
+            symbols = expr.atoms(Symbol)
+            degrees = [(sum(degree_list(monom, *symbols)), monom)
+                       for monom in expr.args]
+            if separate:
+                return {monom[1] for monom in degrees}
+            else:
+                for monom in degrees:
+                    degree, term = monom
+                    if poly_dict.get(degree):
+                        poly_dict[degree] += term
+                    else:
+                        poly_dict[degree] = term
+        elif expr.is_Pow:
+            _, degree = expr.args
+            poly_dict[degree] = expr
+        else:  # Now expr can only be of `Mul` type
+            degree = 0
+            for term in expr.args:
+                term_type = len(term.args)
+                if term_type == 0 and term.is_Symbol:
+                    degree += 1
+                elif term_type == 2:
+                    degree += term.args[1]
+            poly_dict[degree] = expr
+    else:
+        poly_dict[0] = expr
+
+    if separate:
+        return set(poly_dict.values())
+    return poly_dict
+
+
+def point_sort(poly, normal=None, clockwise=True):
+    """Returns the same polygon with points sorted in clockwise or
+    anti-clockwise order.
+
+    Note that it's necessary for input points to be sorted in some order
+    (clockwise or anti-clockwise) for the integration algorithm to work.
+    As a convention algorithm has been implemented keeping clockwise
+    orientation in mind.
+
+    Parameters
+    ==========
+
+    poly:
+        2D or 3D Polygon.
+    normal : optional
+        The normal of the plane which the 3-Polytope is a part of.
+    clockwise : bool, optional
+        Returns points sorted in clockwise order if True and
+        anti-clockwise if False.
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.intpoly import point_sort
+    >>> from sympy import Point
+    >>> point_sort([Point(0, 0), Point(1, 0), Point(1, 1)])
+    [Point2D(1, 1), Point2D(1, 0), Point2D(0, 0)]
+    """
+    pts = poly.vertices if isinstance(poly, Polygon) else poly
+    n = len(pts)
+    if n < 2:
+        return list(pts)
+
+    order = S.One if clockwise else S.NegativeOne
+    dim = len(pts[0])
+    if dim == 2:
+        center = Point(sum((vertex.x for vertex in pts)) / n,
+                        sum((vertex.y for vertex in pts)) / n)
+    else:
+        center = Point(sum((vertex.x for vertex in pts)) / n,
+                        sum((vertex.y for vertex in pts)) / n,
+                        sum((vertex.z for vertex in pts)) / n)
+
+    def compare(a, b):
+        if a.x - center.x >= S.Zero and b.x - center.x < S.Zero:
+            return -order
+        elif a.x - center.x < 0 and b.x - center.x >= 0:
+            return order
+        elif a.x - center.x == 0 and b.x - center.x == 0:
+            if a.y - center.y >= 0 or b.y - center.y >= 0:
+                return -order if a.y > b.y else order
+            return -order if b.y > a.y else order
+
+        det = (a.x - center.x) * (b.y - center.y) -\
+              (b.x - center.x) * (a.y - center.y)
+        if det < 0:
+            return -order
+        elif det > 0:
+            return order
+
+        first = (a.x - center.x) * (a.x - center.x) +\
+                (a.y - center.y) * (a.y - center.y)
+        second = (b.x - center.x) * (b.x - center.x) +\
+                 (b.y - center.y) * (b.y - center.y)
+        return -order if first > second else order
+
+    def compare3d(a, b):
+        det = cross_product(center, a, b)
+        dot_product = sum(det[i] * normal[i] for i in range(0, 3))
+        if dot_product < 0:
+            return -order
+        elif dot_product > 0:
+            return order
+
+    return sorted(pts, key=cmp_to_key(compare if dim==2 else compare3d))
+
+
+def norm(point):
+    """Returns the Euclidean norm of a point from origin.
+
+    Parameters
+    ==========
+
+    point:
+        This denotes a point in the dimension_al spac_e.
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.intpoly import norm
+    >>> from sympy import Point
+    >>> norm(Point(2, 7))
+    sqrt(53)
+    """
+    half = S.Half
+    if isinstance(point, (list, tuple)):
+        return sum(coord ** 2 for coord in point) ** half
+    elif isinstance(point, Point):
+        if isinstance(point, Point2D):
+            return (point.x ** 2 + point.y ** 2) ** half
+        else:
+            return (point.x ** 2 + point.y ** 2 + point.z) ** half
+    elif isinstance(point, dict):
+        return sum(i**2 for i in point.values()) ** half
+
+
+def intersection(geom_1, geom_2, intersection_type):
+    """Returns intersection between geometric objects.
+
+    Explanation
+    ===========
+
+    Note that this function is meant for use in integration_reduction and
+    at that point in the calling function the lines denoted by the segments
+    surely intersect within segment boundaries. Coincident lines are taken
+    to be non-intersecting. Also, the hyperplane intersection for 2D case is
+    also implemented.
+
+    Parameters
+    ==========
+
+    geom_1, geom_2:
+        The input line segments.
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.intpoly import intersection
+    >>> from sympy import Point, Segment2D
+    >>> l1 = Segment2D(Point(1, 1), Point(3, 5))
+    >>> l2 = Segment2D(Point(2, 0), Point(2, 5))
+    >>> intersection(l1, l2, "segment2D")
+    (2, 3)
+    >>> p1 = ((-1, 0), 0)
+    >>> p2 = ((0, 1), 1)
+    >>> intersection(p1, p2, "plane2D")
+    (0, 1)
+    """
+    if intersection_type[:-2] == "segment":
+        if intersection_type == "segment2D":
+            x1, y1 = geom_1.points[0]
+            x2, y2 = geom_1.points[1]
+            x3, y3 = geom_2.points[0]
+            x4, y4 = geom_2.points[1]
+        elif intersection_type == "segment3D":
+            x1, y1, z1 = geom_1.points[0]
+            x2, y2, z2 = geom_1.points[1]
+            x3, y3, z3 = geom_2.points[0]
+            x4, y4, z4 = geom_2.points[1]
+
+        denom = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4)
+        if denom:
+            t1 = x1 * y2 - y1 * x2
+            t2 = x3 * y4 - x4 * y3
+            return (S(t1 * (x3 - x4) - t2 * (x1 - x2)) / denom,
+                    S(t1 * (y3 - y4) - t2 * (y1 - y2)) / denom)
+    if intersection_type[:-2] == "plane":
+        if intersection_type == "plane2D":  # Intersection of hyperplanes
+            a1x, a1y = geom_1[0]
+            a2x, a2y = geom_2[0]
+            b1, b2 = geom_1[1], geom_2[1]
+
+            denom = a1x * a2y - a2x * a1y
+            if denom:
+                return (S(b1 * a2y - b2 * a1y) / denom,
+                        S(b2 * a1x - b1 * a2x) / denom)
+
+
+def is_vertex(ent):
+    """If the input entity is a vertex return True.
+
+    Parameter
+    =========
+
+    ent :
+        Denotes a geometric entity representing a point.
+
+    Examples
+    ========
+
+    >>> from sympy import Point
+    >>> from sympy.integrals.intpoly import is_vertex
+    >>> is_vertex((2, 3))
+    True
+    >>> is_vertex((2, 3, 6))
+    True
+    >>> is_vertex(Point(2, 3))
+    True
+    """
+    if isinstance(ent, tuple):
+        if len(ent) in [2, 3]:
+            return True
+    elif isinstance(ent, Point):
+        return True
+    return False
+
+
+def plot_polytope(poly):
+    """Plots the 2D polytope using the functions written in plotting
+    module which in turn uses matplotlib backend.
+
+    Parameter
+    =========
+
+    poly:
+        Denotes a 2-Polytope.
+    """
+    from sympy.plotting.plot import Plot, List2DSeries
+
+    xl = [vertex.x for vertex in poly.vertices]
+    yl = [vertex.y for vertex in poly.vertices]
+
+    xl.append(poly.vertices[0].x)  # Closing the polygon
+    yl.append(poly.vertices[0].y)
+
+    l2ds = List2DSeries(xl, yl)
+    p = Plot(l2ds, axes='label_axes=True')
+    p.show()
+
+
+def plot_polynomial(expr):
+    """Plots the polynomial using the functions written in
+    plotting module which in turn uses matplotlib backend.
+
+    Parameter
+    =========
+
+    expr:
+        Denotes a polynomial(SymPy expression).
+    """
+    from sympy.plotting.plot import plot3d, plot
+    gens = expr.free_symbols
+    if len(gens) == 2:
+        plot3d(expr)
+    else:
+        plot(expr)

.venv/lib/python3.12/site-packages/sympy/integrals/laplace.py

@@ -0,0 +1,2377 @@
+"""Laplace Transforms"""
+import sys
+import sympy
+from sympy.core import S, pi, I
+from sympy.core.add import Add
+from sympy.core.cache import cacheit
+from sympy.core.expr import Expr
+from sympy.core.function import (
+    AppliedUndef, Derivative, expand, expand_complex, expand_mul, expand_trig,
+    Lambda, WildFunction, diff, Subs)
+from sympy.core.mul import Mul, prod
+from sympy.core.relational import (
+    _canonical, Ge, Gt, Lt, Unequality, Eq, Ne, Relational)
+from sympy.core.sorting import ordered
+from sympy.core.symbol import Dummy, symbols, Wild
+from sympy.functions.elementary.complexes import (
+    re, im, arg, Abs, polar_lift, periodic_argument)
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.elementary.hyperbolic import cosh, coth, sinh, asinh
+from sympy.functions.elementary.miscellaneous import Max, Min, sqrt
+from sympy.functions.elementary.piecewise import (
+    Piecewise, piecewise_exclusive)
+from sympy.functions.elementary.trigonometric import cos, sin, atan, sinc
+from sympy.functions.special.bessel import besseli, besselj, besselk, bessely
+from sympy.functions.special.delta_functions import DiracDelta, Heaviside
+from sympy.functions.special.error_functions import erf, erfc, Ei
+from sympy.functions.special.gamma_functions import (
+    digamma, gamma, lowergamma, uppergamma)
+from sympy.functions.special.singularity_functions import SingularityFunction
+from sympy.integrals import integrate, Integral
+from sympy.integrals.transforms import (
+    _simplify, IntegralTransform, IntegralTransformError)
+from sympy.logic.boolalg import to_cnf, conjuncts, disjuncts, Or, And
+from sympy.matrices.matrixbase import MatrixBase
+from sympy.polys.matrices.linsolve import _lin_eq2dict
+from sympy.polys.polyerrors import PolynomialError
+from sympy.polys.polyroots import roots
+from sympy.polys.polytools import Poly
+from sympy.polys.rationaltools import together
+from sympy.polys.rootoftools import RootSum
+from sympy.utilities.exceptions import (
+    sympy_deprecation_warning, SymPyDeprecationWarning, ignore_warnings)
+from sympy.utilities.misc import debugf
+
+_LT_level = 0
+
+
+def DEBUG_WRAP(func):
+    def wrap(*args, **kwargs):
+        from sympy import SYMPY_DEBUG
+        global _LT_level
+
+        if not SYMPY_DEBUG:
+            return func(*args, **kwargs)
+
+        if _LT_level == 0:
+            print('\n' + '-'*78, file=sys.stderr)
+        print('-LT- %s%s%s' % ('  '*_LT_level, func.__name__, args),
+              file=sys.stderr)
+        _LT_level += 1
+        if (
+                func.__name__ == '_laplace_transform_integration' or
+                func.__name__ == '_inverse_laplace_transform_integration'):
+            sympy.SYMPY_DEBUG = False
+            print('**** %sIntegrating ...' % ('  '*_LT_level), file=sys.stderr)
+            result = func(*args, **kwargs)
+            sympy.SYMPY_DEBUG = True
+        else:
+            result = func(*args, **kwargs)
+        _LT_level -= 1
+        print('-LT- %s---> %s' % ('  '*_LT_level, result), file=sys.stderr)
+        if _LT_level == 0:
+            print('-'*78 + '\n', file=sys.stderr)
+        return result
+    return wrap
+
+
+def _debug(text):
+    from sympy import SYMPY_DEBUG
+
+    if SYMPY_DEBUG:
+        print('-LT- %s%s' % ('  '*_LT_level, text), file=sys.stderr)
+
+
+def _simplifyconds(expr, s, a):
+    r"""
+    Naively simplify some conditions occurring in ``expr``,
+    given that `\operatorname{Re}(s) > a`.
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.laplace import _simplifyconds
+    >>> from sympy.abc import x
+    >>> from sympy import sympify as S
+    >>> _simplifyconds(abs(x**2) < 1, x, 1)
+    False
+    >>> _simplifyconds(abs(x**2) < 1, x, 2)
+    False
+    >>> _simplifyconds(abs(x**2) < 1, x, 0)
+    Abs(x**2) < 1
+    >>> _simplifyconds(abs(1/x**2) < 1, x, 1)
+    True
+    >>> _simplifyconds(S(1) < abs(x), x, 1)
+    True
+    >>> _simplifyconds(S(1) < abs(1/x), x, 1)
+    False
+
+    >>> from sympy import Ne
+    >>> _simplifyconds(Ne(1, x**3), x, 1)
+    True
+    >>> _simplifyconds(Ne(1, x**3), x, 2)
+    True
+    >>> _simplifyconds(Ne(1, x**3), x, 0)
+    Ne(1, x**3)
+    """
+
+    def power(ex):
+        if ex == s:
+            return 1
+        if ex.is_Pow and ex.base == s:
+            return ex.exp
+        return None
+
+    def bigger(ex1, ex2):
+        """ Return True only if |ex1| > |ex2|, False only if |ex1| < |ex2|.
+            Else return None. """
+        if ex1.has(s) and ex2.has(s):
+            return None
+        if isinstance(ex1, Abs):
+            ex1 = ex1.args[0]
+        if isinstance(ex2, Abs):
+            ex2 = ex2.args[0]
+        if ex1.has(s):
+            return bigger(1/ex2, 1/ex1)
+        n = power(ex2)
+        if n is None:
+            return None
+        try:
+            if n > 0 and (Abs(ex1) <= Abs(a)**n) == S.true:
+                return False
+            if n < 0 and (Abs(ex1) >= Abs(a)**n) == S.true:
+                return True
+        except TypeError:
+            return None
+
+    def replie(x, y):
+        """ simplify x < y """
+        if (not (x.is_positive or isinstance(x, Abs))
+                or not (y.is_positive or isinstance(y, Abs))):
+            return (x < y)
+        r = bigger(x, y)
+        if r is not None:
+            return not r
+        return (x < y)
+
+    def replue(x, y):
+        b = bigger(x, y)
+        if b in (True, False):
+            return True
+        return Unequality(x, y)
+
+    def repl(ex, *args):
+        if ex in (True, False):
+            return bool(ex)
+        return ex.replace(*args)
+
+    from sympy.simplify.radsimp import collect_abs
+    expr = collect_abs(expr)
+    expr = repl(expr, Lt, replie)
+    expr = repl(expr, Gt, lambda x, y: replie(y, x))
+    expr = repl(expr, Unequality, replue)
+    return S(expr)
+
+
+@DEBUG_WRAP
+def expand_dirac_delta(expr):
+    """
+    Expand an expression involving DiractDelta to get it as a linear
+    combination of DiracDelta functions.
+    """
+    return _lin_eq2dict(expr, expr.atoms(DiracDelta))
+
+
+@DEBUG_WRAP
+def _laplace_transform_integration(f, t, s_, *, simplify):
+    """ The backend function for doing Laplace transforms by integration.
+
+    This backend assumes that the frontend has already split sums
+    such that `f` is to an addition anymore.
+    """
+    s = Dummy('s')
+
+    if f.has(DiracDelta):
+        return None
+
+    F = integrate(f*exp(-s*t), (t, S.Zero, S.Infinity))
+
+    if not F.has(Integral):
+        return _simplify(F.subs(s, s_), simplify), S.NegativeInfinity, S.true
+
+    if not F.is_Piecewise:
+        return None
+
+    F, cond = F.args[0]
+    if F.has(Integral):
+        return None
+
+    def process_conds(conds):
+        """ Turn ``conds`` into a strip and auxiliary conditions. """
+        from sympy.solvers.inequalities import _solve_inequality
+        a = S.NegativeInfinity
+        aux = S.true
+        conds = conjuncts(to_cnf(conds))
+        p, q, w1, w2, w3, w4, w5 = symbols(
+            'p q w1 w2 w3 w4 w5', cls=Wild, exclude=[s])
+        patterns = (
+            p*Abs(arg((s + w3)*q)) < w2,
+            p*Abs(arg((s + w3)*q)) <= w2,
+            Abs(periodic_argument((s + w3)**p*q, w1)) < w2,
+            Abs(periodic_argument((s + w3)**p*q, w1)) <= w2,
+            Abs(periodic_argument((polar_lift(s + w3))**p*q, w1)) < w2,
+            Abs(periodic_argument((polar_lift(s + w3))**p*q, w1)) <= w2)
+        for c in conds:
+            a_ = S.Infinity
+            aux_ = []
+            for d in disjuncts(c):
+                if d.is_Relational and s in d.rhs.free_symbols:
+                    d = d.reversed
+                if d.is_Relational and isinstance(d, (Ge, Gt)):
+                    d = d.reversedsign
+                for pat in patterns:
+                    m = d.match(pat)
+                    if m:
+                        break
+                if m and m[q].is_positive and m[w2]/m[p] == pi/2:
+                    d = -re(s + m[w3]) < 0
+                m = d.match(p - cos(w1*Abs(arg(s*w5))*w2)*Abs(s**w3)**w4 < 0)
+                if not m:
+                    m = d.match(
+                        cos(p - Abs(periodic_argument(s**w1*w5, q))*w2) *
+                        Abs(s**w3)**w4 < 0)
+                if not m:
+                    m = d.match(
+                        p - cos(
+                            Abs(periodic_argument(polar_lift(s)**w1*w5, q))*w2
+                            )*Abs(s**w3)**w4 < 0)
+                if m and all(m[wild].is_positive for wild in [
+                        w1, w2, w3, w4, w5]):
+                    d = re(s) > m[p]
+                d_ = d.replace(
+                    re, lambda x: x.expand().as_real_imag()[0]).subs(re(s), t)
+                if (
+                        not d.is_Relational or d.rel_op in ('==', '!=')
+                        or d_.has(s) or not d_.has(t)):
+                    aux_ += [d]
+                    continue
+                soln = _solve_inequality(d_, t)
+                if not soln.is_Relational or soln.rel_op in ('==', '!='):
+                    aux_ += [d]
+                    continue
+                if soln.lts == t:
+                    return None
+                else:
+                    a_ = Min(soln.lts, a_)
+            if a_ is not S.Infinity:
+                a = Max(a_, a)
+            else:
+                aux = And(aux, Or(*aux_))
+        return a, aux.canonical if aux.is_Relational else aux
+
+    conds = [process_conds(c) for c in disjuncts(cond)]
+    conds2 = [x for x in conds if x[1] !=
+              S.false and x[0] is not S.NegativeInfinity]
+    if not conds2:
+        conds2 = [x for x in conds if x[1] != S.false]
+    conds = list(ordered(conds2))
+
+    def cnt(expr):
+        if expr in (True, False):
+            return 0
+        return expr.count_ops()
+    conds.sort(key=lambda x: (-x[0], cnt(x[1])))
+
+    if not conds:
+        return None
+    a, aux = conds[0]  # XXX is [0] always the right one?
+
+    def sbs(expr):
+        return expr.subs(s, s_)
+    if simplify:
+        F = _simplifyconds(F, s, a)
+        aux = _simplifyconds(aux, s, a)
+    return _simplify(F.subs(s, s_), simplify), sbs(a), _canonical(sbs(aux))
+
+
+@DEBUG_WRAP
+def _laplace_deep_collect(f, t):
+    """
+    This is an internal helper function that traverses through the expression
+    tree of `f(t)` and collects arguments. The purpose of it is that
+    anything like `f(w*t-1*t-c)` will be written as `f((w-1)*t-c)` such that
+    it can match `f(a*t+b)`.
+    """
+    if not isinstance(f, Expr):
+        return f
+    if (p := f.as_poly(t)) is not None:
+        return p.as_expr()
+    func = f.func
+    args = [_laplace_deep_collect(arg, t) for arg in f.args]
+    return func(*args)
+
+
+@cacheit
+def _laplace_build_rules():
+    """
+    This is an internal helper function that returns the table of Laplace
+    transform rules in terms of the time variable `t` and the frequency
+    variable `s`.  It is used by ``_laplace_apply_rules``.  Each entry is a
+    tuple containing:
+
+        (time domain pattern,
+         frequency-domain replacement,
+         condition for the rule to be applied,
+         convergence plane,
+         preparation function)
+
+    The preparation function is a function with one argument that is applied
+    to the expression before matching. For most rules it should be
+    ``_laplace_deep_collect``.
+    """
+    t = Dummy('t')
+    s = Dummy('s')
+    a = Wild('a', exclude=[t])
+    b = Wild('b', exclude=[t])
+    n = Wild('n', exclude=[t])
+    tau = Wild('tau', exclude=[t])
+    omega = Wild('omega', exclude=[t])
+    def dco(f): return _laplace_deep_collect(f, t)
+    _debug('_laplace_build_rules is building rules')
+
+    laplace_transform_rules = [
+        (a, a/s,
+         S.true, S.Zero, dco),  # 4.2.1
+        (DiracDelta(a*t-b), exp(-s*b/a)/Abs(a),
+         Or(And(a > 0, b >= 0), And(a < 0, b <= 0)),
+         S.NegativeInfinity, dco),  # Not in Bateman54
+        (DiracDelta(a*t-b), S(0),
+         Or(And(a < 0, b >= 0), And(a > 0, b <= 0)),
+         S.NegativeInfinity, dco),  # Not in Bateman54
+        (Heaviside(a*t-b), exp(-s*b/a)/s,
+         And(a > 0, b > 0), S.Zero, dco),  # 4.4.1
+        (Heaviside(a*t-b), (1-exp(-s*b/a))/s,
+         And(a < 0, b < 0), S.Zero, dco),  # 4.4.1
+        (Heaviside(a*t-b), 1/s,
+         And(a > 0, b <= 0), S.Zero, dco),  # 4.4.1
+        (Heaviside(a*t-b), 0,
+         And(a < 0, b > 0), S.Zero, dco),  # 4.4.1
+        (t, 1/s**2,
+         S.true, S.Zero, dco),  # 4.2.3
+        (1/(a*t+b), -exp(-b/a*s)*Ei(-b/a*s)/a,
+         Abs(arg(b/a)) < pi, S.Zero, dco),  # 4.2.6
+        (1/sqrt(a*t+b), sqrt(a*pi/s)*exp(b/a*s)*erfc(sqrt(b/a*s))/a,
+         Abs(arg(b/a)) < pi, S.Zero, dco),  # 4.2.18
+        ((a*t+b)**(-S(3)/2),
+         2*b**(-S(1)/2)-2*(pi*s/a)**(S(1)/2)*exp(b/a*s) * erfc(sqrt(b/a*s))/a,
+         Abs(arg(b/a)) < pi, S.Zero, dco),  # 4.2.20
+        (sqrt(t)/(t+b), sqrt(pi/s)-pi*sqrt(b)*exp(b*s)*erfc(sqrt(b*s)),
+         Abs(arg(b)) < pi, S.Zero, dco),  # 4.2.22
+        (1/(a*sqrt(t) + t**(3/2)), pi*a**(S(1)/2)*exp(a*s)*erfc(sqrt(a*s)),
+         S.true, S.Zero, dco),  # Not in Bateman54
+        (t**n, gamma(n+1)/s**(n+1),
+         n > -1, S.Zero, dco),  # 4.3.1
+        ((a*t+b)**n, uppergamma(n+1, b/a*s)*exp(-b/a*s)/s**(n+1)/a,
+         And(n > -1, Abs(arg(b/a)) < pi), S.Zero, dco),  # 4.3.4
+        (t**n/(t+a), a**n*gamma(n+1)*uppergamma(-n, a*s),
+         And(n > -1, Abs(arg(a)) < pi), S.Zero, dco),  # 4.3.7
+        (exp(a*t-tau), exp(-tau)/(s-a),
+         S.true, re(a), dco),  # 4.5.1
+        (t*exp(a*t-tau), exp(-tau)/(s-a)**2,
+         S.true, re(a), dco),  # 4.5.2
+        (t**n*exp(a*t), gamma(n+1)/(s-a)**(n+1),
+         re(n) > -1, re(a), dco),  # 4.5.3
+        (exp(-a*t**2), sqrt(pi/4/a)*exp(s**2/4/a)*erfc(s/sqrt(4*a)),
+         re(a) > 0, S.Zero, dco),  # 4.5.21
+        (t*exp(-a*t**2),
+         1/(2*a)-2/sqrt(pi)/(4*a)**(S(3)/2)*s*erfc(s/sqrt(4*a)),
+         re(a) > 0, S.Zero, dco),  # 4.5.22
+        (exp(-a/t), 2*sqrt(a/s)*besselk(1, 2*sqrt(a*s)),
+         re(a) >= 0, S.Zero, dco),  # 4.5.25
+        (sqrt(t)*exp(-a/t),
+         S(1)/2*sqrt(pi/s**3)*(1+2*sqrt(a*s))*exp(-2*sqrt(a*s)),
+         re(a) >= 0, S.Zero, dco),  # 4.5.26
+        (exp(-a/t)/sqrt(t), sqrt(pi/s)*exp(-2*sqrt(a*s)),
+         re(a) >= 0, S.Zero, dco),  # 4.5.27
+        (exp(-a/t)/(t*sqrt(t)), sqrt(pi/a)*exp(-2*sqrt(a*s)),
+         re(a) > 0, S.Zero, dco),  # 4.5.28
+        (t**n*exp(-a/t), 2*(a/s)**((n+1)/2)*besselk(n+1, 2*sqrt(a*s)),
+         re(a) > 0, S.Zero, dco),  # 4.5.29
+        # TODO: rules with sqrt(a*t) and sqrt(a/t) have stopped working after
+        #       changes to as_base_exp
+        # (exp(-2*sqrt(a*t)),
+        #  s**(-1)-sqrt(pi*a)*s**(-S(3)/2)*exp(a/s) * erfc(sqrt(a/s)),
+        #  Abs(arg(a)) < pi, S.Zero, dco),  # 4.5.31
+        # (exp(-2*sqrt(a*t))/sqrt(t), (pi/s)**(S(1)/2)*exp(a/s)*erfc(sqrt(a/s)),
+        #  Abs(arg(a)) < pi, S.Zero, dco),  # 4.5.33
+        (exp(-a*exp(-t)), a**(-s)*lowergamma(s, a),
+         S.true, S.Zero, dco),  # 4.5.36
+        (exp(-a*exp(t)), a**s*uppergamma(-s, a),
+         re(a) > 0, S.Zero, dco),  # 4.5.37
+        (log(a*t), -log(exp(S.EulerGamma)*s/a)/s,
+         a > 0, S.Zero, dco),  # 4.6.1
+        (log(1+a*t), -exp(s/a)/s*Ei(-s/a),
+         Abs(arg(a)) < pi, S.Zero, dco),  # 4.6.4
+        (log(a*t+b), (log(b)-exp(s/b/a)/s*a*Ei(-s/b))/s*a,
+         And(a > 0, Abs(arg(b)) < pi), S.Zero, dco),  # 4.6.5
+        (log(t)/sqrt(t), -sqrt(pi/s)*log(4*s*exp(S.EulerGamma)),
+         S.true, S.Zero, dco),  # 4.6.9
+        (t**n*log(t), gamma(n+1)*s**(-n-1)*(digamma(n+1)-log(s)),
+         re(n) > -1, S.Zero, dco),  # 4.6.11
+        (log(a*t)**2, (log(exp(S.EulerGamma)*s/a)**2+pi**2/6)/s,
+         a > 0, S.Zero, dco),  # 4.6.13
+        (sin(omega*t), omega/(s**2+omega**2),
+         S.true, Abs(im(omega)), dco),  # 4,7,1
+        (Abs(sin(omega*t)), omega/(s**2+omega**2)*coth(pi*s/2/omega),
+         omega > 0, S.Zero, dco),  # 4.7.2
+        (sin(omega*t)/t, atan(omega/s),
+         S.true, Abs(im(omega)), dco),  # 4.7.16
+        (sin(omega*t)**2/t, log(1+4*omega**2/s**2)/4,
+         S.true, 2*Abs(im(omega)), dco),  # 4.7.17
+        (sin(omega*t)**2/t**2,
+         omega*atan(2*omega/s)-s*log(1+4*omega**2/s**2)/4,
+         S.true, 2*Abs(im(omega)), dco),  # 4.7.20
+        # (sin(2*sqrt(a*t)), sqrt(pi*a)/s/sqrt(s)*exp(-a/s),
+        #  S.true, S.Zero, dco),  # 4.7.32
+        # (sin(2*sqrt(a*t))/t, pi*erf(sqrt(a/s)),
+        #  S.true, S.Zero, dco),  # 4.7.34
+        (cos(omega*t), s/(s**2+omega**2),
+         S.true, Abs(im(omega)), dco),  # 4.7.43
+        (cos(omega*t)**2, (s**2+2*omega**2)/(s**2+4*omega**2)/s,
+         S.true, 2*Abs(im(omega)), dco),  # 4.7.45
+        # (sqrt(t)*cos(2*sqrt(a*t)), sqrt(pi)/2*s**(-S(5)/2)*(s-2*a)*exp(-a/s),
+        #  S.true, S.Zero, dco),  # 4.7.66
+        # (cos(2*sqrt(a*t))/sqrt(t), sqrt(pi/s)*exp(-a/s),
+        #  S.true, S.Zero, dco),  # 4.7.67
+        (sin(a*t)*sin(b*t), 2*a*b*s/(s**2+(a+b)**2)/(s**2+(a-b)**2),
+         S.true, Abs(im(a))+Abs(im(b)), dco),  # 4.7.78
+        (cos(a*t)*sin(b*t), b*(s**2-a**2+b**2)/(s**2+(a+b)**2)/(s**2+(a-b)**2),
+         S.true, Abs(im(a))+Abs(im(b)), dco),  # 4.7.79
+        (cos(a*t)*cos(b*t), s*(s**2+a**2+b**2)/(s**2+(a+b)**2)/(s**2+(a-b)**2),
+         S.true, Abs(im(a))+Abs(im(b)), dco),  # 4.7.80
+        (sinh(a*t), a/(s**2-a**2),
+         S.true, Abs(re(a)), dco),  # 4.9.1
+        (cosh(a*t), s/(s**2-a**2),
+         S.true, Abs(re(a)), dco),  # 4.9.2
+        (sinh(a*t)**2, 2*a**2/(s**3-4*a**2*s),
+         S.true, 2*Abs(re(a)), dco),  # 4.9.3
+        (cosh(a*t)**2, (s**2-2*a**2)/(s**3-4*a**2*s),
+         S.true, 2*Abs(re(a)), dco),  # 4.9.4
+        (sinh(a*t)/t, log((s+a)/(s-a))/2,
+         S.true, Abs(re(a)), dco),  # 4.9.12
+        (t**n*sinh(a*t), gamma(n+1)/2*((s-a)**(-n-1)-(s+a)**(-n-1)),
+         n > -2, Abs(a), dco),  # 4.9.18
+        (t**n*cosh(a*t), gamma(n+1)/2*((s-a)**(-n-1)+(s+a)**(-n-1)),
+         n > -1, Abs(a), dco),  # 4.9.19
+        # TODO
+        # (sinh(2*sqrt(a*t)), sqrt(pi*a)/s/sqrt(s)*exp(a/s),
+        #  S.true, S.Zero, dco),  # 4.9.34
+        # (cosh(2*sqrt(a*t)), 1/s+sqrt(pi*a)/s/sqrt(s)*exp(a/s)*erf(sqrt(a/s)),
+        #  S.true, S.Zero, dco),  # 4.9.35
+        # (
+        #     sqrt(t)*sinh(2*sqrt(a*t)),
+        #     pi**(S(1)/2)*s**(-S(5)/2)*(s/2+a) *
+        #     exp(a/s)*erf(sqrt(a/s))-a**(S(1)/2)*s**(-2),
+        #     S.true, S.Zero, dco),  # 4.9.36
+        # (sqrt(t)*cosh(2*sqrt(a*t)), pi**(S(1)/2)*s**(-S(5)/2)*(s/2+a)*exp(a/s),
+        #   S.true, S.Zero, dco),  # 4.9.37
+        # (sinh(2*sqrt(a*t))/sqrt(t),
+        #  pi**(S(1)/2)*s**(-S(1)/2)*exp(a/s) * erf(sqrt(a/s)),
+        #     S.true, S.Zero, dco),  # 4.9.38
+        # (cosh(2*sqrt(a*t))/sqrt(t), pi**(S(1)/2)*s**(-S(1)/2)*exp(a/s),
+        #  S.true, S.Zero, dco),  # 4.9.39
+        # (sinh(sqrt(a*t))**2/sqrt(t), pi**(S(1)/2)/2*s**(-S(1)/2)*(exp(a/s)-1),
+        #  S.true, S.Zero, dco),  # 4.9.40
+        # (cosh(sqrt(a*t))**2/sqrt(t), pi**(S(1)/2)/2*s**(-S(1)/2)*(exp(a/s)+1),
+        #  S.true, S.Zero, dco),  # 4.9.41
+        (erf(a*t), exp(s**2/(2*a)**2)*erfc(s/(2*a))/s,
+         4*Abs(arg(a)) < pi, S.Zero, dco),  # 4.12.2
+        # (erf(sqrt(a*t)), sqrt(a)/sqrt(s+a)/s,
+        #  S.true, Max(S.Zero, -re(a)), dco),  # 4.12.4
+        # (exp(a*t)*erf(sqrt(a*t)), sqrt(a)/sqrt(s)/(s-a),
+        #  S.true, Max(S.Zero, re(a)), dco),  # 4.12.5
+        # (erf(sqrt(a/t)/2), (1-exp(-sqrt(a*s)))/s,
+        #  re(a) > 0, S.Zero, dco),  # 4.12.6
+        # (erfc(sqrt(a*t)), (sqrt(s+a)-sqrt(a))/sqrt(s+a)/s,
+        #  S.true, -re(a), dco),  # 4.12.9
+        # (exp(a*t)*erfc(sqrt(a*t)), 1/(s+sqrt(a*s)),
+        #  S.true, S.Zero, dco),  # 4.12.10
+        # (erfc(sqrt(a/t)/2), exp(-sqrt(a*s))/s,
+        #  re(a) > 0, S.Zero, dco),  # 4.2.11
+        (besselj(n, a*t), a**n/(sqrt(s**2+a**2)*(s+sqrt(s**2+a**2))**n),
+         re(n) > -1, Abs(im(a)), dco),  # 4.14.1
+        (t**b*besselj(n, a*t),
+         2**n/sqrt(pi)*gamma(n+S.Half)*a**n*(s**2+a**2)**(-n-S.Half),
+         And(re(n) > -S.Half, Eq(b, n)), Abs(im(a)), dco),  # 4.14.7
+        (t**b*besselj(n, a*t),
+         2**(n+1)/sqrt(pi)*gamma(n+S(3)/2)*a**n*s*(s**2+a**2)**(-n-S(3)/2),
+         And(re(n) > -1, Eq(b, n+1)), Abs(im(a)), dco),  # 4.14.8
+        # (besselj(0, 2*sqrt(a*t)), exp(-a/s)/s,
+        #  S.true, S.Zero, dco),  # 4.14.25
+        # (t**(b)*besselj(n, 2*sqrt(a*t)), a**(n/2)*s**(-n-1)*exp(-a/s),
+        #  And(re(n) > -1, Eq(b, n*S.Half)), S.Zero, dco),  # 4.14.30
+        (besselj(0, a*sqrt(t**2+b*t)),
+         exp(b*s-b*sqrt(s**2+a**2))/sqrt(s**2+a**2),
+         Abs(arg(b)) < pi, Abs(im(a)), dco),  # 4.15.19
+        (besseli(n, a*t), a**n/(sqrt(s**2-a**2)*(s+sqrt(s**2-a**2))**n),
+         re(n) > -1, Abs(re(a)), dco),  # 4.16.1
+        (t**b*besseli(n, a*t),
+         2**n/sqrt(pi)*gamma(n+S.Half)*a**n*(s**2-a**2)**(-n-S.Half),
+         And(re(n) > -S.Half, Eq(b, n)), Abs(re(a)), dco),  # 4.16.6
+        (t**b*besseli(n, a*t),
+         2**(n+1)/sqrt(pi)*gamma(n+S(3)/2)*a**n*s*(s**2-a**2)**(-n-S(3)/2),
+         And(re(n) > -1, Eq(b, n+1)), Abs(re(a)), dco),  # 4.16.7
+        # (t**(b)*besseli(n, 2*sqrt(a*t)), a**(n/2)*s**(-n-1)*exp(a/s),
+        #  And(re(n) > -1, Eq(b, n*S.Half)), S.Zero, dco),  # 4.16.18
+        (bessely(0, a*t), -2/pi*asinh(s/a)/sqrt(s**2+a**2),
+         S.true, Abs(im(a)), dco),  # 4.15.44
+        (besselk(0, a*t), log((s + sqrt(s**2-a**2))/a)/(sqrt(s**2-a**2)),
+         S.true, -re(a), dco)  # 4.16.23
+    ]
+    return laplace_transform_rules, t, s
+
+
+@DEBUG_WRAP
+def _laplace_rule_timescale(f, t, s):
+    """
+    This function applies the time-scaling rule of the Laplace transform in
+    a straight-forward way. For example, if it gets ``(f(a*t), t, s)``, it will
+    compute ``LaplaceTransform(f(t)/a, t, s/a)`` if ``a>0``.
+    """
+
+    a = Wild('a', exclude=[t])
+    g = WildFunction('g', nargs=1)
+    ma1 = f.match(g)
+    if ma1:
+        arg = ma1[g].args[0].collect(t)
+        ma2 = arg.match(a*t)
+        if ma2 and ma2[a].is_positive and ma2[a] != 1:
+            _debug('     rule: time scaling (4.1.4)')
+            r, pr, cr = _laplace_transform(
+                1/ma2[a]*ma1[g].func(t), t, s/ma2[a], simplify=False)
+            return (r, pr, cr)
+    return None
+
+
+@DEBUG_WRAP
+def _laplace_rule_heaviside(f, t, s):
+    """
+    This function deals with time-shifted Heaviside step functions. If the time
+    shift is positive, it applies the time-shift rule of the Laplace transform.
+    For example, if it gets ``(Heaviside(t-a)*f(t), t, s)``, it will compute
+    ``exp(-a*s)*LaplaceTransform(f(t+a), t, s)``.
+
+    If the time shift is negative, the Heaviside function is simply removed
+    as it means nothing to the Laplace transform.
+
+    The function does not remove a factor ``Heaviside(t)``; this is done by
+    the simple rules.
+    """
+
+    a = Wild('a', exclude=[t])
+    y = Wild('y')
+    g = Wild('g')
+    if ma1 := f.match(Heaviside(y) * g):
+        if ma2 := ma1[y].match(t - a):
+            if ma2[a].is_positive:
+                _debug('     rule: time shift (4.1.4)')
+                r, pr, cr = _laplace_transform(
+                    ma1[g].subs(t, t + ma2[a]), t, s, simplify=False)
+                return (exp(-ma2[a] * s) * r, pr, cr)
+            if ma2[a].is_negative:
+                _debug(
+                    '     rule: Heaviside factor; negative time shift (4.1.4)')
+                r, pr, cr = _laplace_transform(ma1[g], t, s, simplify=False)
+                return (r, pr, cr)
+        if ma2 := ma1[y].match(a - t):
+            if ma2[a].is_positive:
+                _debug('     rule: Heaviside window open')
+                r, pr, cr = _laplace_transform(
+                    (1 - Heaviside(t - ma2[a])) * ma1[g], t, s, simplify=False)
+                return (r, pr, cr)
+            if ma2[a].is_negative:
+                _debug('     rule: Heaviside window closed')
+                return (0, 0, S.true)
+    return None
+
+
+@DEBUG_WRAP
+def _laplace_rule_exp(f, t, s):
+    """
+    If this function finds a factor ``exp(a*t)``, it applies the
+    frequency-shift rule of the Laplace transform and adjusts the convergence
+    plane accordingly.  For example, if it gets ``(exp(-a*t)*f(t), t, s)``, it
+    will compute ``LaplaceTransform(f(t), t, s+a)``.
+    """
+
+    a = Wild('a', exclude=[t])
+    y = Wild('y')
+    z = Wild('z')
+    ma1 = f.match(exp(y)*z)
+    if ma1:
+        ma2 = ma1[y].collect(t).match(a*t)
+        if ma2:
+            _debug('     rule: multiply with exp (4.1.5)')
+            r, pr, cr = _laplace_transform(ma1[z], t, s-ma2[a],
+                                           simplify=False)
+            return (r, pr+re(ma2[a]), cr)
+    return None
+
+
+@DEBUG_WRAP
+def _laplace_rule_delta(f, t, s):
+    """
+    If this function finds a factor ``DiracDelta(b*t-a)``, it applies the
+    masking property of the delta distribution. For example, if it gets
+    ``(DiracDelta(t-a)*f(t), t, s)``, it will return
+    ``(f(a)*exp(-a*s), -a, True)``.
+    """
+    # This rule is not in Bateman54
+
+    a = Wild('a', exclude=[t])
+    b = Wild('b', exclude=[t])
+
+    y = Wild('y')
+    z = Wild('z')
+    ma1 = f.match(DiracDelta(y)*z)
+    if ma1 and not ma1[z].has(DiracDelta):
+        ma2 = ma1[y].collect(t).match(b*t-a)
+        if ma2:
+            _debug('     rule: multiply with DiracDelta')
+            loc = ma2[a]/ma2[b]
+            if re(loc) >= 0 and im(loc) == 0:
+                fn = exp(-ma2[a]/ma2[b]*s)*ma1[z]
+                if fn.has(sin, cos):
+                    # Then it may be possible that a sinc() is present in the
+                    # term; let's try this:
+                    fn = fn.rewrite(sinc).ratsimp()
+                n, d = [x.subs(t, ma2[a]/ma2[b]) for x in fn.as_numer_denom()]
+                if d != 0:
+                    return (n/d/ma2[b], S.NegativeInfinity, S.true)
+                else:
+                    return None
+            else:
+                return (0, S.NegativeInfinity, S.true)
+        if ma1[y].is_polynomial(t):
+            ro = roots(ma1[y], t)
+            if ro != {} and set(ro.values()) == {1}:
+                slope = diff(ma1[y], t)
+                r = Add(
+                    *[exp(-x*s)*ma1[z].subs(t, s)/slope.subs(t, x)
+                      for x in list(ro.keys()) if im(x) == 0 and re(x) >= 0])
+                return (r, S.NegativeInfinity, S.true)
+    return None
+
+
+@DEBUG_WRAP
+def _laplace_trig_split(fn):
+    """
+    Helper function for `_laplace_rule_trig`.  This function returns two terms
+    `f` and `g`.  `f` contains all product terms with sin, cos, sinh, cosh in
+    them; `g` contains everything else.
+    """
+    trigs = [S.One]
+    other = [S.One]
+    for term in Mul.make_args(fn):
+        if term.has(sin, cos, sinh, cosh, exp):
+            trigs.append(term)
+        else:
+            other.append(term)
+    f = Mul(*trigs)
+    g = Mul(*other)
+    return f, g
+
+
+@DEBUG_WRAP
+def _laplace_trig_expsum(f, t):
+    """
+    Helper function for `_laplace_rule_trig`.  This function expects the `f`
+    from `_laplace_trig_split`.  It returns two lists `xm` and `xn`.  `xm` is
+    a list of dictionaries with keys `k` and `a` representing a function
+    `k*exp(a*t)`.  `xn` is a list of all terms that cannot be brought into
+    that form, which may happen, e.g., when a trigonometric function has
+    another function in its argument.
+    """
+    c1 = Wild('c1', exclude=[t])
+    c0 = Wild('c0', exclude=[t])
+    p = Wild('p', exclude=[t])
+    xm = []
+    xn = []
+
+    x1 = f.rewrite(exp).expand()
+
+    for term in Add.make_args(x1):
+        if not term.has(t):
+            xm.append({'k': term, 'a': 0, re: 0, im: 0})
+            continue
+        term = _laplace_deep_collect(term.powsimp(combine='exp'), t)
+
+        if (r := term.match(p*exp(c1*t+c0))) is not None:
+            xm.append({
+                'k': r[p]*exp(r[c0]), 'a': r[c1],
+                re: re(r[c1]), im: im(r[c1])})
+        else:
+            xn.append(term)
+    return xm, xn
+
+
+@DEBUG_WRAP
+def _laplace_trig_ltex(xm, t, s):
+    """
+    Helper function for `_laplace_rule_trig`.  This function takes the list of
+    exponentials `xm` from `_laplace_trig_expsum` and simplifies complex
+    conjugate and real symmetric poles.  It returns the result as a sum and
+    the convergence plane.
+    """
+    results = []
+    planes = []
+
+    def _simpc(coeffs):
+        nc = coeffs.copy()
+        for k in range(len(nc)):
+            ri = nc[k].as_real_imag()
+            if ri[0].has(im):
+                nc[k] = nc[k].rewrite(cos)
+            else:
+                nc[k] = (ri[0] + I*ri[1]).rewrite(cos)
+        return nc
+
+    def _quadpole(t1, k1, k2, k3, s):
+        a, k0, a_r, a_i = t1['a'], t1['k'], t1[re], t1[im]
+        nc = [
+            k0 + k1 + k2 + k3,
+            a*(k0 + k1 - k2 - k3) - 2*I*a_i*k1 + 2*I*a_i*k2,
+            (
+                a**2*(-k0 - k1 - k2 - k3) +
+                a*(4*I*a_i*k0 + 4*I*a_i*k3) +
+                4*a_i**2*k0 + 4*a_i**2*k3),
+            (
+                a**3*(-k0 - k1 + k2 + k3) +
+                a**2*(4*I*a_i*k0 + 2*I*a_i*k1 - 2*I*a_i*k2 - 4*I*a_i*k3) +
+                a*(4*a_i**2*k0 - 4*a_i**2*k3))
+        ]
+        dc = [
+            S.One, S.Zero, 2*a_i**2 - 2*a_r**2,
+            S.Zero, a_i**4 + 2*a_i**2*a_r**2 + a_r**4]
+        n = Add(
+            *[x*s**y for x, y in zip(_simpc(nc), range(len(nc))[::-1])])
+        d = Add(
+            *[x*s**y for x, y in zip(dc, range(len(dc))[::-1])])
+        return n/d
+
+    def _ccpole(t1, k1, s):
+        a, k0, a_r, a_i = t1['a'], t1['k'], t1[re], t1[im]
+        nc = [k0 + k1, -a*k0 - a*k1 + 2*I*a_i*k0]
+        dc = [S.One, -2*a_r, a_i**2 + a_r**2]
+        n = Add(
+            *[x*s**y for x, y in zip(_simpc(nc), range(len(nc))[::-1])])
+        d = Add(
+            *[x*s**y for x, y in zip(dc, range(len(dc))[::-1])])
+        return n/d
+
+    def _rspole(t1, k2, s):
+        a, k0, a_r, a_i = t1['a'], t1['k'], t1[re], t1[im]
+        nc = [k0 + k2, a*k0 - a*k2 - 2*I*a_i*k0]
+        dc = [S.One, -2*I*a_i, -a_i**2 - a_r**2]
+        n = Add(
+            *[x*s**y for x, y in zip(_simpc(nc), range(len(nc))[::-1])])
+        d = Add(
+            *[x*s**y for x, y in zip(dc, range(len(dc))[::-1])])
+        return n/d
+
+    def _sypole(t1, k3, s):
+        a, k0 = t1['a'], t1['k']
+        nc = [k0 + k3, a*(k0 - k3)]
+        dc = [S.One, S.Zero, -a**2]
+        n = Add(
+            *[x*s**y for x, y in zip(_simpc(nc), range(len(nc))[::-1])])
+        d = Add(
+            *[x*s**y for x, y in zip(dc, range(len(dc))[::-1])])
+        return n/d
+
+    def _simplepole(t1, s):
+        a, k0 = t1['a'], t1['k']
+        n = k0
+        d = s - a
+        return n/d
+
+    while len(xm) > 0:
+        t1 = xm.pop()
+        i_imagsym = None
+        i_realsym = None
+        i_pointsym = None
+        # The following code checks all remaining poles. If t1 is a pole at
+        # a+b*I, then we check for a-b*I, -a+b*I, and -a-b*I, and
+        # assign the respective indices to i_imagsym, i_realsym, i_pointsym.
+        # -a-b*I / i_pointsym only applies if both a and b are != 0.
+        for i in range(len(xm)):
+            real_eq = t1[re] == xm[i][re]
+            realsym = t1[re] == -xm[i][re]
+            imag_eq = t1[im] == xm[i][im]
+            imagsym = t1[im] == -xm[i][im]
+            if realsym and imagsym and t1[re] != 0 and t1[im] != 0:
+                i_pointsym = i
+            elif realsym and imag_eq and t1[re] != 0:
+                i_realsym = i
+            elif real_eq and imagsym and t1[im] != 0:
+                i_imagsym = i
+
+        # The next part looks for four possible pole constellations:
+        # quad:   a+b*I, a-b*I, -a+b*I, -a-b*I
+        # cc:     a+b*I, a-b*I (a may be zero)
+        # quad:   a+b*I, -a+b*I (b may be zero)
+        # point:  a+b*I, -a-b*I (a!=0 and b!=0 is needed, but that has been
+        #                        asserted when finding i_pointsym above.)
+        # If none apply, then t1 is a simple pole.
+        if (
+                i_imagsym is not None and i_realsym is not None
+                and i_pointsym is not None):
+            results.append(
+                _quadpole(t1,
+                          xm[i_imagsym]['k'], xm[i_realsym]['k'],
+                          xm[i_pointsym]['k'], s))
+            planes.append(Abs(re(t1['a'])))
+            # The three additional poles have now been used; to pop them
+            # easily we have to do it from the back.
+            indices_to_pop = [i_imagsym, i_realsym, i_pointsym]
+            indices_to_pop.sort(reverse=True)
+            for i in indices_to_pop:
+                xm.pop(i)
+        elif i_imagsym is not None:
+            results.append(_ccpole(t1, xm[i_imagsym]['k'], s))
+            planes.append(t1[re])
+            xm.pop(i_imagsym)
+        elif i_realsym is not None:
+            results.append(_rspole(t1, xm[i_realsym]['k'], s))
+            planes.append(Abs(t1[re]))
+            xm.pop(i_realsym)
+        elif i_pointsym is not None:
+            results.append(_sypole(t1, xm[i_pointsym]['k'], s))
+            planes.append(Abs(t1[re]))
+            xm.pop(i_pointsym)
+        else:
+            results.append(_simplepole(t1, s))
+            planes.append(t1[re])
+
+    return Add(*results), Max(*planes)
+
+
+@DEBUG_WRAP
+def _laplace_rule_trig(fn, t_, s):
+    """
+    This rule covers trigonometric factors by splitting everything into a
+    sum of exponential functions and collecting complex conjugate poles and
+    real symmetric poles.
+    """
+    t = Dummy('t', real=True)
+
+    if not fn.has(sin, cos, sinh, cosh):
+        return None
+
+    f, g = _laplace_trig_split(fn.subs(t_, t))
+    xm, xn = _laplace_trig_expsum(f, t)
+
+    if len(xn) > 0:
+        # TODO not implemented yet, but also not important
+        return None
+
+    if not g.has(t):
+        r, p = _laplace_trig_ltex(xm, t, s)
+        return g*r, p, S.true
+    else:
+        # Just transform `g` and make frequency-shifted copies
+        planes = []
+        results = []
+        G, G_plane, G_cond = _laplace_transform(g, t, s, simplify=False)
+        for x1 in xm:
+            results.append(x1['k']*G.subs(s, s-x1['a']))
+            planes.append(G_plane+re(x1['a']))
+    return Add(*results).subs(t, t_), Max(*planes), G_cond
+
+
+@DEBUG_WRAP
+def _laplace_rule_diff(f, t, s):
+    """
+    This function looks for derivatives in the time domain and replaces it
+    by factors of `s` and initial conditions in the frequency domain. For
+    example, if it gets ``(diff(f(t), t), t, s)``, it will compute
+    ``s*LaplaceTransform(f(t), t, s) - f(0)``.
+    """
+
+    a = Wild('a', exclude=[t])
+    n = Wild('n', exclude=[t])
+    g = WildFunction('g')
+    ma1 = f.match(a*Derivative(g, (t, n)))
+    if ma1 and ma1[n].is_integer:
+        m = [z.has(t) for z in ma1[g].args]
+        if sum(m) == 1:
+            _debug('     rule: time derivative (4.1.8)')
+            d = []
+            for k in range(ma1[n]):
+                if k == 0:
+                    y = ma1[g].subs(t, 0)
+                else:
+                    y = Derivative(ma1[g], (t, k)).subs(t, 0)
+                d.append(s**(ma1[n]-k-1)*y)
+            r, pr, cr = _laplace_transform(ma1[g], t, s, simplify=False)
+            return (ma1[a]*(s**ma1[n]*r - Add(*d)),  pr, cr)
+    return None
+
+
+@DEBUG_WRAP
+def _laplace_rule_sdiff(f, t, s):
+    """
+    This function looks for multiplications with polynoimials in `t` as they
+    correspond to differentiation in the frequency domain. For example, if it
+    gets ``(t*f(t), t, s)``, it will compute
+    ``-Derivative(LaplaceTransform(f(t), t, s), s)``.
+    """
+
+    if f.is_Mul:
+        pfac = [1]
+        ofac = [1]
+        for fac in Mul.make_args(f):
+            if fac.is_polynomial(t):
+                pfac.append(fac)
+            else:
+                ofac.append(fac)
+        if len(pfac) > 1:
+            pex = prod(pfac)
+            pc = Poly(pex, t).all_coeffs()
+            N = len(pc)
+            if N > 1:
+                oex = prod(ofac)
+                r_, p_, c_ = _laplace_transform(oex, t, s, simplify=False)
+                deri = [r_]
+                d1 = False
+                try:
+                    d1 = -diff(deri[-1], s)
+                except ValueError:
+                    d1 = False
+                if r_.has(LaplaceTransform):
+                    for k in range(N-1):
+                        deri.append((-1)**(k+1)*Derivative(r_, s, k+1))
+                elif d1:
+                    deri.append(d1)
+                    for k in range(N-2):
+                        deri.append(-diff(deri[-1], s))
+                if d1:
+                    r = Add(*[pc[N-n-1]*deri[n] for n in range(N)])
+                    return (r, p_, c_)
+    # We still have to cover the possibility that there is a symbolic positive
+    # integer exponent.
+    n = Wild('n', exclude=[t])
+    g = Wild('g')
+    if ma1 := f.match(t**n*g):
+        if ma1[n].is_integer and ma1[n].is_positive:
+            r_, p_, c_ = _laplace_transform(ma1[g], t, s, simplify=False)
+            return (-1)**ma1[n]*diff(r_, (s, ma1[n])), p_, c_
+    return None
+
+
+@DEBUG_WRAP
+def _laplace_expand(f, t, s):
+    """
+    This function tries to expand its argument with successively stronger
+    methods: first it will expand on the top level, then it will expand any
+    multiplications in depth, then it will try all available expansion methods,
+    and finally it will try to expand trigonometric functions.
+
+    If it can expand, it will then compute the Laplace transform of the
+    expanded term.
+    """
+
+    r = expand(f, deep=False)
+    if r.is_Add:
+        return _laplace_transform(r, t, s, simplify=False)
+    r = expand_mul(f)
+    if r.is_Add:
+        return _laplace_transform(r, t, s, simplify=False)
+    r = expand(f)
+    if r.is_Add:
+        return _laplace_transform(r, t, s, simplify=False)
+    if r != f:
+        return _laplace_transform(r, t, s, simplify=False)
+    r = expand(expand_trig(f))
+    if r.is_Add:
+        return _laplace_transform(r, t, s, simplify=False)
+    return None
+
+
+@DEBUG_WRAP
+def _laplace_apply_prog_rules(f, t, s):
+    """
+    This function applies all program rules and returns the result if one
+    of them gives a result.
+    """
+
+    prog_rules = [_laplace_rule_heaviside, _laplace_rule_delta,
+                  _laplace_rule_timescale, _laplace_rule_exp,
+                  _laplace_rule_trig,
+                  _laplace_rule_diff, _laplace_rule_sdiff]
+
+    for p_rule in prog_rules:
+        if (L := p_rule(f, t, s)) is not None:
+            return L
+    return None
+
+
+@DEBUG_WRAP
+def _laplace_apply_simple_rules(f, t, s):
+    """
+    This function applies all simple rules and returns the result if one
+    of them gives a result.
+    """
+    simple_rules, t_, s_ = _laplace_build_rules()
+    prep_old = ''
+    prep_f = ''
+    for t_dom, s_dom, check, plane, prep in simple_rules:
+        if prep_old != prep:
+            prep_f = prep(f.subs({t: t_}))
+            prep_old = prep
+        ma = prep_f.match(t_dom)
+        if ma:
+            try:
+                c = check.xreplace(ma)
+            except TypeError:
+                # This may happen if the time function has imaginary
+                # numbers in it. Then we give up.
+                continue
+            if c == S.true:
+                return (s_dom.xreplace(ma).subs({s_: s}),
+                        plane.xreplace(ma), S.true)
+    return None
+
+
+@DEBUG_WRAP
+def _piecewise_to_heaviside(f, t):
+    """
+    This function converts a Piecewise expression to an expression written
+    with Heaviside. It is not exact, but valid in the context of the Laplace
+    transform.
+    """
+    if not t.is_real:
+        r = Dummy('r', real=True)
+        return _piecewise_to_heaviside(f.xreplace({t: r}), r).xreplace({r: t})
+    x = piecewise_exclusive(f)
+    r = []
+    for fn, cond in x.args:
+        # Here we do not need to do many checks because piecewise_exclusive
+        # has a clearly predictable output. However, if any of the conditions
+        # is not relative to t, this function just returns the input argument.
+        if isinstance(cond, Relational) and t in cond.args:
+            if isinstance(cond, (Eq, Ne)):
+                # We do not cover this case; these would be single-point
+                # exceptions that do not play a role in Laplace practice,
+                # except if they contain Dirac impulses, and then we can
+                # expect users to not try to use Piecewise for writing it.
+                return f
+            else:
+                r.append(Heaviside(cond.gts - cond.lts)*fn)
+        elif isinstance(cond, Or) and len(cond.args) == 2:
+            # Or(t<2, t>4), Or(t>4, t<=2), ... in any order with any <= >=
+            for c2 in cond.args:
+                if c2.lhs == t:
+                    r.append(Heaviside(c2.gts - c2.lts)*fn)
+                else:
+                    return f
+        elif isinstance(cond, And) and len(cond.args) == 2:
+            # And(t>2, t<4), And(t>4, t<=2), ...  in any order with any <= >=
+            c0, c1 = cond.args
+            if c0.lhs == t and c1.lhs == t:
+                if '>' in c0.rel_op:
+                    c0, c1 = c1, c0
+                r.append(
+                    (Heaviside(c1.gts - c1.lts) -
+                     Heaviside(c0.lts - c0.gts))*fn)
+            else:
+                return f
+        else:
+            return f
+    return Add(*r)
+
+
+def laplace_correspondence(f, fdict, /):
+    """
+    This helper function takes a function `f` that is the result of a
+    ``laplace_transform`` or an ``inverse_laplace_transform``.  It replaces all
+    unevaluated ``LaplaceTransform(y(t), t, s)`` by `Y(s)` for any `s` and
+    all ``InverseLaplaceTransform(Y(s), s, t)`` by `y(t)` for any `t` if
+    ``fdict`` contains a correspondence ``{y: Y}``.
+
+    Parameters
+    ==========
+
+    f : sympy expression
+        Expression containing unevaluated ``LaplaceTransform`` or
+        ``LaplaceTransform`` objects.
+    fdict : dictionary
+        Dictionary containing one or more function correspondences,
+        e.g., ``{x: X, y: Y}`` meaning that ``X`` and ``Y`` are the
+        Laplace transforms of ``x`` and ``y``, respectively.
+
+    Examples
+    ========
+
+    >>> from sympy import laplace_transform, diff, Function
+    >>> from sympy import laplace_correspondence, inverse_laplace_transform
+    >>> from sympy.abc import t, s
+    >>> y = Function("y")
+    >>> Y = Function("Y")
+    >>> z = Function("z")
+    >>> Z = Function("Z")
+    >>> f = laplace_transform(diff(y(t), t, 1) + z(t), t, s, noconds=True)
+    >>> laplace_correspondence(f, {y: Y, z: Z})
+    s*Y(s) + Z(s) - y(0)
+    >>> f = inverse_laplace_transform(Y(s), s, t)
+    >>> laplace_correspondence(f, {y: Y})
+    y(t)
+    """
+    p = Wild('p')
+    s = Wild('s')
+    t = Wild('t')
+    a = Wild('a')
+    if (
+            not isinstance(f, Expr)
+            or (not f.has(LaplaceTransform)
+                and not f.has(InverseLaplaceTransform))):
+        return f
+    for y, Y in fdict.items():
+        if (
+                (m := f.match(LaplaceTransform(y(a), t, s))) is not None
+                and m[a] == m[t]):
+            return Y(m[s])
+        if (
+                (m := f.match(InverseLaplaceTransform(Y(a), s, t, p)))
+                is not None
+                and m[a] == m[s]):
+            return y(m[t])
+    func = f.func
+    args = [laplace_correspondence(arg, fdict) for arg in f.args]
+    return func(*args)
+
+
+def laplace_initial_conds(f, t, fdict, /):
+    """
+    This helper function takes a function `f` that is the result of a
+    ``laplace_transform``.  It takes an fdict of the form ``{y: [1, 4, 2]}``,
+    where the values in the list are the initial value, the initial slope, the
+    initial second derivative, etc., of the function `y(t)`, and replaces all
+    unevaluated initial conditions.
+
+    Parameters
+    ==========
+
+    f : sympy expression
+        Expression containing initial conditions of unevaluated functions.
+    t : sympy expression
+        Variable for which the initial conditions are to be applied.
+    fdict : dictionary
+        Dictionary containing a list of initial conditions for every
+        function, e.g., ``{y: [0, 1, 2], x: [3, 4, 5]}``. The order
+        of derivatives is ascending, so `0`, `1`, `2` are `y(0)`, `y'(0)`,
+        and `y''(0)`, respectively.
+
+    Examples
+    ========
+
+    >>> from sympy import laplace_transform, diff, Function
+    >>> from sympy import laplace_correspondence, laplace_initial_conds
+    >>> from sympy.abc import t, s
+    >>> y = Function("y")
+    >>> Y = Function("Y")
+    >>> f = laplace_transform(diff(y(t), t, 3), t, s, noconds=True)
+    >>> g = laplace_correspondence(f, {y: Y})
+    >>> laplace_initial_conds(g, t, {y: [2, 4, 8, 16, 32]})
+    s**3*Y(s) - 2*s**2 - 4*s - 8
+    """
+    for y, ic in fdict.items():
+        for k in range(len(ic)):
+            if k == 0:
+                f = f.replace(y(0), ic[0])
+            elif k == 1:
+                f = f.replace(Subs(Derivative(y(t), t), t, 0), ic[1])
+            else:
+                f = f.replace(Subs(Derivative(y(t), (t, k)), t, 0), ic[k])
+    return f
+
+
+@DEBUG_WRAP
+def _laplace_transform(fn, t_, s_, *, simplify):
+    """
+    Front-end function of the Laplace transform. It tries to apply all known
+    rules recursively, and if everything else fails, it tries to integrate.
+    """
+
+    terms_t = Add.make_args(fn)
+    terms_s = []
+    terms = []
+    planes = []
+    conditions = []
+
+    for ff in terms_t:
+        k, ft = ff.as_independent(t_, as_Add=False)
+        if ft.has(SingularityFunction):
+            _terms = Add.make_args(ft.rewrite(Heaviside))
+            for _term in _terms:
+                k1, f1 = _term.as_independent(t_, as_Add=False)
+                terms.append((k*k1, f1))
+        elif ft.func == Piecewise and not ft.has(DiracDelta(t_)):
+            _terms = Add.make_args(_piecewise_to_heaviside(ft, t_))
+            for _term in _terms:
+                k1, f1 = _term.as_independent(t_, as_Add=False)
+                terms.append((k*k1, f1))
+        else:
+            terms.append((k, ft))
+
+    for k, ft in terms:
+        if ft.has(SingularityFunction):
+            r = (LaplaceTransform(ft, t_, s_), S.NegativeInfinity, True)
+        else:
+            if ft.has(Heaviside(t_)) and not ft.has(DiracDelta(t_)):
+                # For t>=0, Heaviside(t)=1 can be used, except if there is also
+                # a DiracDelta(t) present, in which case removing Heaviside(t)
+                # is unnecessary because _laplace_rule_delta can deal with it.
+                ft = ft.subs(Heaviside(t_), 1)
+            if (
+                    (r := _laplace_apply_simple_rules(ft, t_, s_))
+                    is not None or
+                    (r := _laplace_apply_prog_rules(ft, t_, s_))
+                    is not None or
+                    (r := _laplace_expand(ft, t_, s_)) is not None):
+                pass
+            elif any(undef.has(t_) for undef in ft.atoms(AppliedUndef)):
+                # If there are undefined functions f(t) then integration is
+                # unlikely to do anything useful so we skip it and given an
+                # unevaluated LaplaceTransform.
+                r = (LaplaceTransform(ft, t_, s_), S.NegativeInfinity, True)
+            elif (r := _laplace_transform_integration(
+                    ft, t_, s_, simplify=simplify)) is not None:
+                pass
+            else:
+                r = (LaplaceTransform(ft, t_, s_), S.NegativeInfinity, True)
+        (ri_, pi_, ci_) = r
+        terms_s.append(k*ri_)
+        planes.append(pi_)
+        conditions.append(ci_)
+
+    result = Add(*terms_s)
+    if simplify:
+        result = result.simplify(doit=False)
+    plane = Max(*planes)
+    condition = And(*conditions)
+
+    return result, plane, condition
+
+
+class LaplaceTransform(IntegralTransform):
+    """
+    Class representing unevaluated Laplace transforms.
+
+    For usage of this class, see the :class:`IntegralTransform` docstring.
+
+    For how to compute Laplace transforms, see the :func:`laplace_transform`
+    docstring.
+
+    If this is called with ``.doit()``, it returns the Laplace transform as an
+    expression. If it is called with ``.doit(noconds=False)``, it returns a
+    tuple containing the same expression, a convergence plane, and conditions.
+    """
+
+    _name = 'Laplace'
+
+    def _compute_transform(self, f, t, s, **hints):
+        _simplify = hints.get('simplify', False)
+        LT = _laplace_transform_integration(f, t, s, simplify=_simplify)
+        return LT
+
+    def _as_integral(self, f, t, s):
+        return Integral(f*exp(-s*t), (t, S.Zero, S.Infinity))
+
+    def doit(self, **hints):
+        """
+        Try to evaluate the transform in closed form.
+
+        Explanation
+        ===========
+
+        Standard hints are the following:
+        - ``noconds``:  if True, do not return convergence conditions. The
+        default setting is `True`.
+        - ``simplify``: if True, it simplifies the final result. The
+        default setting is `False`.
+        """
+        _noconds = hints.get('noconds', True)
+        _simplify = hints.get('simplify', False)
+
+        debugf('[LT doit] (%s, %s, %s)', (self.function,
+                                          self.function_variable,
+                                          self.transform_variable))
+
+        t_ = self.function_variable
+        s_ = self.transform_variable
+        fn = self.function
+
+        r = _laplace_transform(fn, t_, s_, simplify=_simplify)
+
+        if _noconds:
+            return r[0]
+        else:
+            return r
+
+
+def laplace_transform(f, t, s, legacy_matrix=True, **hints):
+    r"""
+    Compute the Laplace Transform `F(s)` of `f(t)`,
+
+    .. math :: F(s) = \int_{0^{-}}^\infty e^{-st} f(t) \mathrm{d}t.
+
+    Explanation
+    ===========
+
+    For all sensible functions, this converges absolutely in a
+    half-plane
+
+    .. math :: a < \operatorname{Re}(s)
+
+    This function returns ``(F, a, cond)`` where ``F`` is the Laplace
+    transform of ``f``, `a` is the half-plane of convergence, and `cond` are
+    auxiliary convergence conditions.
+
+    The implementation is rule-based, and if you are interested in which
+    rules are applied, and whether integration is attempted, you can switch
+    debug information on by setting ``sympy.SYMPY_DEBUG=True``. The numbers
+    of the rules in the debug information (and the code) refer to Bateman's
+    Tables of Integral Transforms [1].
+
+    The lower bound is `0-`, meaning that this bound should be approached
+    from the lower side. This is only necessary if distributions are involved.
+    At present, it is only done if `f(t)` contains ``DiracDelta``, in which
+    case the Laplace transform is computed implicitly as
+
+    .. math ::
+        F(s) = \lim_{\tau\to 0^{-}} \int_{\tau}^\infty e^{-st}
+        f(t) \mathrm{d}t
+
+    by applying rules.
+
+    If the Laplace transform cannot be fully computed in closed form, this
+    function returns expressions containing unevaluated
+    :class:`LaplaceTransform` objects.
+
+    For a description of possible hints, refer to the docstring of
+    :func:`sympy.integrals.transforms.IntegralTransform.doit`. If
+    ``noconds=True``, only `F` will be returned (i.e. not ``cond``, and also
+    not the plane ``a``).
+
+    .. deprecated:: 1.9
+        Legacy behavior for matrices where ``laplace_transform`` with
+        ``noconds=False`` (the default) returns a Matrix whose elements are
+        tuples. The behavior of ``laplace_transform`` for matrices will change
+        in a future release of SymPy to return a tuple of the transformed
+        Matrix and the convergence conditions for the matrix as a whole. Use
+        ``legacy_matrix=False`` to enable the new behavior.
+
+    Examples
+    ========
+
+    >>> from sympy import DiracDelta, exp, laplace_transform
+    >>> from sympy.abc import t, s, a
+    >>> laplace_transform(t**4, t, s)
+    (24/s**5, 0, True)
+    >>> laplace_transform(t**a, t, s)
+    (gamma(a + 1)/(s*s**a), 0, re(a) > -1)
+    >>> laplace_transform(DiracDelta(t)-a*exp(-a*t), t, s, simplify=True)
+    (s/(a + s), -re(a), True)
+
+    There are also helper functions that make it easy to solve differential
+    equations by Laplace transform. For example, to solve
+
+    .. math :: m x''(t) + d x'(t) + k x(t) = 0
+
+    with initial value `0` and initial derivative `v`:
+
+    >>> from sympy import Function, laplace_correspondence, diff, solve
+    >>> from sympy import laplace_initial_conds, inverse_laplace_transform
+    >>> from sympy.abc import d, k, m, v
+    >>> x = Function('x')
+    >>> X = Function('X')
+    >>> f = m*diff(x(t), t, 2) + d*diff(x(t), t) + k*x(t)
+    >>> F = laplace_transform(f, t, s, noconds=True)
+    >>> F = laplace_correspondence(F, {x: X})
+    >>> F = laplace_initial_conds(F, t, {x: [0, v]})
+    >>> F
+    d*s*X(s) + k*X(s) + m*(s**2*X(s) - v)
+    >>> Xs = solve(F, X(s))[0]
+    >>> Xs
+    m*v/(d*s + k + m*s**2)
+    >>> inverse_laplace_transform(Xs, s, t)
+    2*v*exp(-d*t/(2*m))*sin(t*sqrt((-d**2 + 4*k*m)/m**2)/2)*Heaviside(t)/sqrt((-d**2 + 4*k*m)/m**2)
+
+    References
+    ==========
+
+    .. [1] Erdelyi, A. (ed.), Tables of Integral Transforms, Volume 1,
+           Bateman Manuscript Prooject, McGraw-Hill (1954), available:
+           https://resolver.caltech.edu/CaltechAUTHORS:20140123-101456353
+
+    See Also
+    ========
+
+    inverse_laplace_transform, mellin_transform, fourier_transform
+    hankel_transform, inverse_hankel_transform
+
+    """
+
+    _noconds = hints.get('noconds', False)
+    _simplify = hints.get('simplify', False)
+
+    if isinstance(f, MatrixBase) and hasattr(f, 'applyfunc'):
+
+        conds = not hints.get('noconds', False)
+
+        if conds and legacy_matrix:
+            adt = 'deprecated-laplace-transform-matrix'
+            sympy_deprecation_warning(
+                """
+Calling laplace_transform() on a Matrix with noconds=False (the default) is
+deprecated. Either noconds=True or use legacy_matrix=False to get the new
+behavior.
+                """,
+                deprecated_since_version='1.9',
+                active_deprecations_target=adt,
+            )
+            # Temporarily disable the deprecation warning for non-Expr objects
+            # in Matrix
+            with ignore_warnings(SymPyDeprecationWarning):
+                return f.applyfunc(
+                    lambda fij: laplace_transform(fij, t, s, **hints))
+        else:
+            elements_trans = [laplace_transform(
+                fij, t, s, **hints) for fij in f]
+            if conds:
+                elements, avals, conditions = zip(*elements_trans)
+                f_laplace = type(f)(*f.shape, elements)
+                return f_laplace, Max(*avals), And(*conditions)
+            else:
+                return type(f)(*f.shape, elements_trans)
+
+    LT, p, c = LaplaceTransform(f, t, s).doit(noconds=False,
+                                              simplify=_simplify)
+
+    if not _noconds:
+        return LT, p, c
+    else:
+        return LT
+
+
+@DEBUG_WRAP
+def _inverse_laplace_transform_integration(F, s, t_, plane, *, simplify):
+    """ The backend function for inverse Laplace transforms. """
+    from sympy.integrals.meijerint import meijerint_inversion, _get_coeff_exp
+    from sympy.integrals.transforms import inverse_mellin_transform
+
+    # There are two strategies we can try:
+    # 1) Use inverse mellin transform, related by a simple change of variables.
+    # 2) Use the inversion integral.
+
+    t = Dummy('t', real=True)
+
+    def pw_simp(*args):
+        """ Simplify a piecewise expression from hyperexpand. """
+        if len(args) != 3:
+            return Piecewise(*args)
+        arg = args[2].args[0].argument
+        coeff, exponent = _get_coeff_exp(arg, t)
+        e1 = args[0].args[0]
+        e2 = args[1].args[0]
+        return (
+            Heaviside(1/Abs(coeff) - t**exponent)*e1 +
+            Heaviside(t**exponent - 1/Abs(coeff))*e2)
+
+    if F.is_rational_function(s):
+        F = F.apart(s)
+
+    if F.is_Add:
+        f = Add(
+            *[_inverse_laplace_transform_integration(X, s, t, plane, simplify)
+              for X in F.args])
+        return _simplify(f.subs(t, t_), simplify), True
+
+    try:
+        f, cond = inverse_mellin_transform(F, s, exp(-t), (None, S.Infinity),
+                                           needeval=True, noconds=False)
+    except IntegralTransformError:
+        f = None
+
+    if f is None:
+        f = meijerint_inversion(F, s, t)
+        if f is None:
+            return None
+        if f.is_Piecewise:
+            f, cond = f.args[0]
+            if f.has(Integral):
+                return None
+        else:
+            cond = S.true
+        f = f.replace(Piecewise, pw_simp)
+
+    if f.is_Piecewise:
+        # many of the functions called below can't work with piecewise
+        # (b/c it has a bool in args)
+        return f.subs(t, t_), cond
+
+    u = Dummy('u')
+
+    def simp_heaviside(arg, H0=S.Half):
+        a = arg.subs(exp(-t), u)
+        if a.has(t):
+            return Heaviside(arg, H0)
+        from sympy.solvers.inequalities import _solve_inequality
+        rel = _solve_inequality(a > 0, u)
+        if rel.lts == u:
+            k = log(rel.gts)
+            return Heaviside(t + k, H0)
+        else:
+            k = log(rel.lts)
+            return Heaviside(-(t + k), H0)
+
+    f = f.replace(Heaviside, simp_heaviside)
+
+    def simp_exp(arg):
+        return expand_complex(exp(arg))
+
+    f = f.replace(exp, simp_exp)
+
+    return _simplify(f.subs(t, t_), simplify), cond
+
+
+@DEBUG_WRAP
+def _complete_the_square_in_denom(f, s):
+    from sympy.simplify.radsimp import fraction
+    [n, d] = fraction(f)
+    if d.is_polynomial(s):
+        cf = d.as_poly(s).all_coeffs()
+        if len(cf) == 3:
+            a, b, c = cf
+            d = a*((s+b/(2*a))**2+c/a-(b/(2*a))**2)
+    return n/d
+
+
+@cacheit
+def _inverse_laplace_build_rules():
+    """
+    This is an internal helper function that returns the table of inverse
+    Laplace transform rules in terms of the time variable `t` and the
+    frequency variable `s`.  It is used by `_inverse_laplace_apply_rules`.
+    """
+    s = Dummy('s')
+    t = Dummy('t')
+    a = Wild('a', exclude=[s])
+    b = Wild('b', exclude=[s])
+    c = Wild('c', exclude=[s])
+
+    _debug('_inverse_laplace_build_rules is building rules')
+
+    def _frac(f, s):
+        try:
+            return f.factor(s)
+        except PolynomialError:
+            return f
+
+    def same(f): return f
+    # This list is sorted according to the prep function needed.
+    _ILT_rules = [
+        (a/s, a, S.true, same, 1),
+        (
+            b*(s+a)**(-c), t**(c-1)*exp(-a*t)/gamma(c),
+            S.true, same, 1),
+        (1/(s**2+a**2)**2, (sin(a*t) - a*t*cos(a*t))/(2*a**3),
+         S.true, same, 1),
+        # The next two rules must be there in that order. For the second
+        # one, the condition would be a != 0 or, respectively, to take the
+        # limit a -> 0 after the transform if a == 0. It is much simpler if
+        # the case a == 0 has its own rule.
+        (1/(s**b), t**(b - 1)/gamma(b), S.true, same, 1),
+        (1/(s*(s+a)**b), lowergamma(b, a*t)/(a**b*gamma(b)),
+         S.true, same, 1)
+    ]
+    return _ILT_rules, s, t
+
+
+@DEBUG_WRAP
+def _inverse_laplace_apply_simple_rules(f, s, t):
+    """
+    Helper function for the class InverseLaplaceTransform.
+    """
+    if f == 1:
+        _debug('     rule: 1 o---o DiracDelta()')
+        return DiracDelta(t), S.true
+
+    _ILT_rules, s_, t_ = _inverse_laplace_build_rules()
+    _prep = ''
+    fsubs = f.subs({s: s_})
+
+    for s_dom, t_dom, check, prep, fac in _ILT_rules:
+        if _prep != (prep, fac):
+            _F = prep(fsubs*fac)
+            _prep = (prep, fac)
+        ma = _F.match(s_dom)
+        if ma:
+            c = check
+            if c is not S.true:
+                args = [x.xreplace(ma) for x in c[0]]
+                c = c[1](*args)
+            if c == S.true:
+                return Heaviside(t)*t_dom.xreplace(ma).subs({t_: t}), S.true
+
+    return None
+
+
+@DEBUG_WRAP
+def _inverse_laplace_diff(f, s, t, plane):
+    """
+    Helper function for the class InverseLaplaceTransform.
+    """
+    a = Wild('a', exclude=[s])
+    n = Wild('n', exclude=[s])
+    g = Wild('g')
+    ma = f.match(a*Derivative(g, (s, n)))
+    if ma and ma[n].is_integer:
+        _debug('     rule: t**n*f(t) o---o (-1)**n*diff(F(s), s, n)')
+        r, c = _inverse_laplace_transform(
+            ma[g], s, t, plane, simplify=False, dorational=False)
+        return (-t)**ma[n]*r, c
+    return None
+
+
+@DEBUG_WRAP
+def _inverse_laplace_time_shift(F, s, t, plane):
+    """
+    Helper function for the class InverseLaplaceTransform.
+    """
+    a = Wild('a', exclude=[s])
+    g = Wild('g')
+
+    if not F.has(s):
+        return F*DiracDelta(t), S.true
+    if not F.has(exp):
+        return None
+
+    ma1 = F.match(exp(a*s))
+    if ma1:
+        if ma1[a].is_negative:
+            _debug('     rule: exp(-a*s) o---o DiracDelta(t-a)')
+            return DiracDelta(t+ma1[a]), S.true
+        else:
+            return InverseLaplaceTransform(F, s, t, plane), S.true
+
+    ma1 = F.match(exp(a*s)*g)
+    if ma1:
+        if ma1[a].is_negative:
+            _debug('     rule: exp(-a*s)*F(s) o---o Heaviside(t-a)*f(t-a)')
+            return _inverse_laplace_transform(
+                ma1[g], s, t+ma1[a], plane, simplify=False, dorational=True)
+        else:
+            return InverseLaplaceTransform(F, s, t, plane), S.true
+    return None
+
+
+@DEBUG_WRAP
+def _inverse_laplace_freq_shift(F, s, t, plane):
+    """
+    Helper function for the class InverseLaplaceTransform.
+    """
+    if not F.has(s):
+        return F*DiracDelta(t), S.true
+    if len(args := F.args) == 1:
+        a = Wild('a', exclude=[s])
+        if (ma := args[0].match(s-a)) and re(ma[a]).is_positive:
+            _debug('     rule: F(s-a) o---o exp(-a*t)*f(t)')
+            return (
+                exp(-ma[a]*t) *
+                InverseLaplaceTransform(F.func(s), s, t, plane), S.true)
+    return None
+
+
+@DEBUG_WRAP
+def _inverse_laplace_time_diff(F, s, t, plane):
+    """
+    Helper function for the class InverseLaplaceTransform.
+    """
+    n = Wild('n', exclude=[s])
+    g = Wild('g')
+
+    ma1 = F.match(s**n*g)
+    if ma1 and ma1[n].is_integer and ma1[n].is_positive:
+        _debug('     rule: s**n*F(s) o---o diff(f(t), t, n)')
+        r, c = _inverse_laplace_transform(
+            ma1[g], s, t, plane, simplify=False, dorational=True)
+        r = r.replace(Heaviside(t), 1)
+        if r.has(InverseLaplaceTransform):
+            return diff(r, t, ma1[n]), c
+        else:
+            return Heaviside(t)*diff(r, t, ma1[n]), c
+    return None
+
+
+@DEBUG_WRAP
+def _inverse_laplace_irrational(fn, s, t, plane):
+    """
+    Helper function for the class InverseLaplaceTransform.
+    """
+
+    a = Wild('a', exclude=[s])
+    b = Wild('b', exclude=[s])
+    m = Wild('m', exclude=[s])
+    n = Wild('n', exclude=[s])
+
+    result = None
+    condition = S.true
+
+    fa = fn.as_ordered_factors()
+
+    ma = [x.match((a*s**m+b)**n) for x in fa]
+
+    if None in ma:
+        return None
+
+    constants = S.One
+    zeros = []
+    poles = []
+    rest = []
+
+    for term in ma:
+        if term[a] == 0:
+            constants = constants*term
+        elif term[n].is_positive:
+            zeros.append(term)
+        elif term[n].is_negative:
+            poles.append(term)
+        else:
+            rest.append(term)
+
+    # The code below assumes that the poles are sorted in a specific way:
+    poles = sorted(poles, key=lambda x: (x[n], x[b] != 0, x[b]))
+    zeros = sorted(zeros, key=lambda x: (x[n], x[b] != 0, x[b]))
+
+    if len(rest) != 0:
+        return None
+
+    if len(poles) == 1 and len(zeros) == 0:
+        if poles[0][n] == -1 and poles[0][m] == S.Half:
+            # 1/(a0*sqrt(s)+b0) == 1/a0 * 1/(sqrt(s)+b0/a0)
+            a_ = poles[0][b]/poles[0][a]
+            k_ = 1/poles[0][a]*constants
+            if a_.is_positive:
+                result = (
+                    k_/sqrt(pi)/sqrt(t) -
+                    k_*a_*exp(a_**2*t)*erfc(a_*sqrt(t)))
+                _debug('     rule 5.3.4')
+        elif poles[0][n] == -2 and poles[0][m] == S.Half:
+            # 1/(a0*sqrt(s)+b0)**2 == 1/a0**2 * 1/(sqrt(s)+b0/a0)**2
+            a_sq = poles[0][b]/poles[0][a]
+            a_ = a_sq**2
+            k_ = 1/poles[0][a]**2*constants
+            if a_sq.is_positive:
+                result = (
+                    k_*(1 - 2/sqrt(pi)*sqrt(a_)*sqrt(t) +
+                        (1-2*a_*t)*exp(a_*t)*(erf(sqrt(a_)*sqrt(t))-1)))
+                _debug('     rule 5.3.10')
+        elif poles[0][n] == -3 and poles[0][m] == S.Half:
+            # 1/(a0*sqrt(s)+b0)**3 == 1/a0**3 * 1/(sqrt(s)+b0/a0)**3
+            a_ = poles[0][b]/poles[0][a]
+            k_ = 1/poles[0][a]**3*constants
+            if a_.is_positive:
+                result = (
+                    k_*(2/sqrt(pi)*(a_**2*t+1)*sqrt(t) -
+                        a_*t*exp(a_**2*t)*(2*a_**2*t+3)*erfc(a_*sqrt(t))))
+                _debug('     rule 5.3.13')
+        elif poles[0][n] == -4 and poles[0][m] == S.Half:
+            # 1/(a0*sqrt(s)+b0)**4 == 1/a0**4 * 1/(sqrt(s)+b0/a0)**4
+            a_ = poles[0][b]/poles[0][a]
+            k_ = 1/poles[0][a]**4*constants/3
+            if a_.is_positive:
+                result = (
+                    k_*(t*(4*a_**4*t**2+12*a_**2*t+3)*exp(a_**2*t) *
+                        erfc(a_*sqrt(t)) -
+                        2/sqrt(pi)*a_**3*t**(S(5)/2)*(2*a_**2*t+5)))
+                _debug('     rule 5.3.16')
+        elif poles[0][n] == -S.Half and poles[0][m] == 2:
+            # 1/sqrt(a0*s**2+b0) == 1/sqrt(a0) * 1/sqrt(s**2+b0/a0)
+            a_ = sqrt(poles[0][b]/poles[0][a])
+            k_ = 1/sqrt(poles[0][a])*constants
+            result = (k_*(besselj(0, a_*t)))
+            _debug('     rule 5.3.35/44')
+
+    elif len(poles) == 1 and len(zeros) == 1:
+        if (
+                poles[0][n] == -3 and poles[0][m] == S.Half and
+                zeros[0][n] == S.Half and zeros[0][b] == 0):
+            # sqrt(az*s)/(ap*sqrt(s+bp)**3)
+            # == sqrt(az)/ap * sqrt(s)/(sqrt(s+bp)**3)
+            a_ = poles[0][b]
+            k_ = sqrt(zeros[0][a])/poles[0][a]*constants
+            result = (
+                k_*(2*a_**4*t**2+5*a_**2*t+1)*exp(a_**2*t) *
+                erfc(a_*sqrt(t)) - 2/sqrt(pi)*a_*(a_**2*t+2)*sqrt(t))
+            _debug('     rule 5.3.14')
+        if (
+                poles[0][n] == -1 and poles[0][m] == 1 and
+                zeros[0][n] == S.Half and zeros[0][m] == 1):
+            # sqrt(az*s+bz)/(ap*s+bp)
+            # == sqrt(az)/ap * (sqrt(s+bz/az)/(s+bp/ap))
+            a_ = zeros[0][b]/zeros[0][a]
+            b_ = poles[0][b]/poles[0][a]
+            k_ = sqrt(zeros[0][a])/poles[0][a]*constants
+            result = (
+                k_*(exp(-a_*t)/sqrt(t)/sqrt(pi)+sqrt(a_-b_) *
+                    exp(-b_*t)*erf(sqrt(a_-b_)*sqrt(t))))
+            _debug('     rule 5.3.22')
+
+    elif len(poles) == 2 and len(zeros) == 0:
+        if (
+                poles[0][n] == -1 and poles[0][m] == 1 and
+                poles[1][n] == -S.Half and poles[1][m] == 1 and
+                poles[1][b] == 0):
+            # 1/((a0*s+b0)*sqrt(a1*s))
+            # == 1/(a0*sqrt(a1)) * 1/((s+b0/a0)*sqrt(s))
+            a_ = -poles[0][b]/poles[0][a]
+            k_ = 1/sqrt(poles[1][a])/poles[0][a]*constants
+            if a_.is_positive:
+                result = (k_/sqrt(a_)*exp(a_*t)*erf(sqrt(a_)*sqrt(t)))
+                _debug('     rule 5.3.1')
+        elif (
+                poles[0][n] == -1 and poles[0][m] == 1 and poles[0][b] == 0 and
+                poles[1][n] == -1 and poles[1][m] == S.Half):
+            # 1/(a0*s*(a1*sqrt(s)+b1))
+            # == 1/(a0*a1) * 1/(s*(sqrt(s)+b1/a1))
+            a_ = poles[1][b]/poles[1][a]
+            k_ = 1/poles[0][a]/poles[1][a]/a_*constants
+            if a_.is_positive:
+                result = k_*(1-exp(a_**2*t)*erfc(a_*sqrt(t)))
+                _debug('     rule 5.3.5')
+        elif (
+                poles[0][n] == -1 and poles[0][m] == S.Half and
+                poles[1][n] == -S.Half and poles[1][m] == 1 and
+                poles[1][b] == 0):
+            # 1/((a0*sqrt(s)+b0)*(sqrt(a1*s))
+            # == 1/(a0*sqrt(a1)) * 1/((sqrt(s)+b0/a0)"sqrt(s))
+            a_ = poles[0][b]/poles[0][a]
+            k_ = 1/(poles[0][a]*sqrt(poles[1][a]))*constants
+            if a_.is_positive:
+                result = k_*exp(a_**2*t)*erfc(a_*sqrt(t))
+                _debug('     rule 5.3.7')
+        elif (
+                poles[0][n] == -S(3)/2 and poles[0][m] == 1 and
+                poles[0][b] == 0 and poles[1][n] == -1 and
+                poles[1][m] == S.Half):
+            # 1/((a0**(3/2)*s**(3/2))*(a1*sqrt(s)+b1))
+            # == 1/(a0**(3/2)*a1)  1/((s**(3/2))*(sqrt(s)+b1/a1))
+            # Note that Bateman54 5.3 (8) is incorrect; there (sqrt(p)+a)
+            # should be (sqrt(p)+a)**(-1).
+            a_ = poles[1][b]/poles[1][a]
+            k_ = 1/(poles[0][a]**(S(3)/2)*poles[1][a])/a_**2*constants
+            if a_.is_positive:
+                result = (
+                    k_*(2/sqrt(pi)*a_*sqrt(t)+exp(a_**2*t)*erfc(a_*sqrt(t))-1))
+                _debug('     rule 5.3.8')
+        elif (
+                poles[0][n] == -2 and poles[0][m] == S.Half and
+                poles[1][n] == -1 and poles[1][m] == 1 and
+                poles[1][b] == 0):
+            # 1/((a0*sqrt(s)+b0)**2*a1*s)
+            # == 1/a0**2/a1 * 1/(sqrt(s)+b0/a0)**2/s
+            a_sq = poles[0][b]/poles[0][a]
+            a_ = a_sq**2
+            k_ = 1/poles[0][a]**2/poles[1][a]*constants
+            if a_sq.is_positive:
+                result = (
+                    k_*(1/a_ + (2*t-1/a_)*exp(a_*t)*erfc(sqrt(a_)*sqrt(t)) -
+                        2/sqrt(pi)/sqrt(a_)*sqrt(t)))
+                _debug('     rule 5.3.11')
+        elif (
+                poles[0][n] == -2 and poles[0][m] == S.Half and
+                poles[1][n] == -S.Half and poles[1][m] == 1 and
+                poles[1][b] == 0):
+            # 1/((a0*sqrt(s)+b0)**2*sqrt(a1*s))
+            # == 1/a0**2/sqrt(a1) * 1/(sqrt(s)+b0/a0)**2/sqrt(s)
+            a_ = poles[0][b]/poles[0][a]
+            k_ = 1/poles[0][a]**2/sqrt(poles[1][a])*constants
+            if a_.is_positive:
+                result = (
+                    k_*(2/sqrt(pi)*sqrt(t) -
+                        2*a_*t*exp(a_**2*t)*erfc(a_*sqrt(t))))
+                _debug('     rule 5.3.12')
+        elif (
+                poles[0][n] == -3 and poles[0][m] == S.Half and
+                poles[1][n] == -S.Half and poles[1][m] == 1 and
+                poles[1][b] == 0):
+            # 1 / (sqrt(a1*s)*(a0*sqrt(s+b0)**3))
+            # == 1/(sqrt(a1)*a0) * 1/(sqrt(s)*(sqrt(s+b0)**3))
+            a_ = poles[0][b]
+            k_ = constants/sqrt(poles[1][a])/poles[0][a]
+            result = k_*(
+                (2*a_**2*t+1)*t*exp(a_**2*t)*erfc(a_*sqrt(t)) -
+                2/sqrt(pi)*a_*t**(S(3)/2))
+            _debug('     rule 5.3.15')
+        elif (
+                poles[0][n] == -1 and poles[0][m] == 1 and
+                poles[1][n] == -S.Half and poles[1][m] == 1):
+            # 1 / ( (a0*s+b0)* sqrt(a1*s+b1) )
+            # == 1/(sqrt(a1)*a0) * 1 / ( (s+b0/a0)* sqrt(s+b1/a1) )
+            a_ = poles[0][b]/poles[0][a]
+            b_ = poles[1][b]/poles[1][a]
+            k_ = constants/sqrt(poles[1][a])/poles[0][a]
+            result = k_*(
+                1/sqrt(b_-a_)*exp(-a_*t)*erf(sqrt(b_-a_)*sqrt(t)))
+            _debug('     rule 5.3.23')
+
+    elif len(poles) == 2 and len(zeros) == 1:
+        if (
+                poles[0][n] == -1 and poles[0][m] == 1 and
+                poles[1][n] == -1 and poles[1][m] == S.Half and
+                zeros[0][n] == S.Half and zeros[0][m] == 1 and
+                zeros[0][b] == 0):
+            # sqrt(za0*s)/((a0*s+b0)*(a1*sqrt(s)+b1))
+            # == sqrt(za0)/(a0*a1) * s/((s+b0/a0)*(sqrt(s)+b1/a1))
+            a_sq = poles[1][b]/poles[1][a]
+            a_ = a_sq**2
+            b_ = -poles[0][b]/poles[0][a]
+            k_ = sqrt(zeros[0][a])/poles[0][a]/poles[1][a]/(a_-b_)*constants
+            if a_sq.is_positive and b_.is_positive:
+                result = k_*(
+                    a_*exp(a_*t)*erfc(sqrt(a_)*sqrt(t)) +
+                    sqrt(a_)*sqrt(b_)*exp(b_*t)*erfc(sqrt(b_)*sqrt(t)) -
+                    b_*exp(b_*t))
+                _debug('     rule 5.3.6')
+        elif (
+                poles[0][n] == -1 and poles[0][m] == 1 and
+                poles[0][b] == 0 and poles[1][n] == -1 and
+                poles[1][m] == S.Half and zeros[0][n] == 1 and
+                zeros[0][m] == S.Half):
+            # (az*sqrt(s)+bz)/(a0*s*(a1*sqrt(s)+b1))
+            # == az/a0/a1 * (sqrt(z)+bz/az)/(s*(sqrt(s)+b1/a1))
+            a_num = zeros[0][b]/zeros[0][a]
+            a_ = poles[1][b]/poles[1][a]
+            if a_+a_num == 0:
+                k_ = zeros[0][a]/poles[0][a]/poles[1][a]*constants
+                result = k_*(
+                    2*exp(a_**2*t)*erfc(a_*sqrt(t))-1)
+                _debug('     rule 5.3.17')
+        elif (
+                poles[1][n] == -1 and poles[1][m] == 1 and
+                poles[1][b] == 0 and poles[0][n] == -2 and
+                poles[0][m] == S.Half and zeros[0][n] == 2 and
+                zeros[0][m] == S.Half):
+            # (az*sqrt(s)+bz)**2/(a1*s*(a0*sqrt(s)+b0)**2)
+            # == az**2/a1/a0**2 * (sqrt(z)+bz/az)**2/(s*(sqrt(s)+b0/a0)**2)
+            a_num = zeros[0][b]/zeros[0][a]
+            a_ = poles[0][b]/poles[0][a]
+            if a_+a_num == 0:
+                k_ = zeros[0][a]**2/poles[1][a]/poles[0][a]**2*constants
+                result = k_*(
+                    1 + 8*a_**2*t*exp(a_**2*t)*erfc(a_*sqrt(t)) -
+                    8/sqrt(pi)*a_*sqrt(t))
+                _debug('     rule 5.3.18')
+        elif (
+                poles[1][n] == -1 and poles[1][m] == 1 and
+                poles[1][b] == 0 and poles[0][n] == -3 and
+                poles[0][m] == S.Half and zeros[0][n] == 3 and
+                zeros[0][m] == S.Half):
+            # (az*sqrt(s)+bz)**3/(a1*s*(a0*sqrt(s)+b0)**3)
+            # == az**3/a1/a0**3 * (sqrt(z)+bz/az)**3/(s*(sqrt(s)+b0/a0)**3)
+            a_num = zeros[0][b]/zeros[0][a]
+            a_ = poles[0][b]/poles[0][a]
+            if a_+a_num == 0:
+                k_ = zeros[0][a]**3/poles[1][a]/poles[0][a]**3*constants
+                result = k_*(
+                    2*(8*a_**4*t**2+8*a_**2*t+1)*exp(a_**2*t) *
+                    erfc(a_*sqrt(t))-8/sqrt(pi)*a_*sqrt(t)*(2*a_**2*t+1)-1)
+                _debug('     rule 5.3.19')
+
+    elif len(poles) == 3 and len(zeros) == 0:
+        if (
+                poles[0][n] == -1 and poles[0][b] == 0 and poles[0][m] == 1 and
+                poles[1][n] == -1 and poles[1][m] == 1 and
+                poles[2][n] == -S.Half and poles[2][m] == 1):
+            # 1/((a0*s)*(a1*s+b1)*sqrt(a2*s))
+            # == 1/(a0*a1*sqrt(a2)) * 1/((s)*(s+b1/a1)*sqrt(s))
+            a_ = -poles[1][b]/poles[1][a]
+            k_ = 1/poles[0][a]/poles[1][a]/sqrt(poles[2][a])*constants
+            if a_.is_positive:
+                result = k_ * (
+                    a_**(-S(3)/2) * exp(a_*t) * erf(sqrt(a_)*sqrt(t)) -
+                    2/a_/sqrt(pi)*sqrt(t))
+                _debug('     rule 5.3.2')
+        elif (
+                poles[0][n] == -1 and poles[0][m] == 1 and
+                poles[1][n] == -1 and poles[1][m] == S.Half and
+                poles[2][n] == -S.Half and poles[2][m] == 1 and
+                poles[2][b] == 0):
+            # 1/((a0*s+b0)*(a1*sqrt(s)+b1)*(sqrt(a2)*sqrt(s)))
+            # == 1/(a0*a1*sqrt(a2)) * 1/((s+b0/a0)*(sqrt(s)+b1/a1)*sqrt(s))
+            a_sq = poles[1][b]/poles[1][a]
+            a_ = a_sq**2
+            b_ = -poles[0][b]/poles[0][a]
+            k_ = (
+                1/poles[0][a]/poles[1][a]/sqrt(poles[2][a]) /
+                (sqrt(b_)*(a_-b_)))
+            if a_sq.is_positive and b_.is_positive:
+                result = k_ * (
+                    sqrt(b_)*exp(a_*t)*erfc(sqrt(a_)*sqrt(t)) +
+                    sqrt(a_)*exp(b_*t)*erf(sqrt(b_)*sqrt(t)) -
+                    sqrt(b_)*exp(b_*t))
+                _debug('     rule 5.3.9')
+
+    if result is None:
+        return None
+    else:
+        return Heaviside(t)*result, condition
+
+
+@DEBUG_WRAP
+def _inverse_laplace_early_prog_rules(F, s, t, plane):
+    """
+    Helper function for the class InverseLaplaceTransform.
+    """
+    prog_rules = [_inverse_laplace_irrational]
+
+    for p_rule in prog_rules:
+        if (r := p_rule(F, s, t, plane)) is not None:
+            return r
+    return None
+
+
+@DEBUG_WRAP
+def _inverse_laplace_apply_prog_rules(F, s, t, plane):
+    """
+    Helper function for the class InverseLaplaceTransform.
+    """
+    prog_rules = [_inverse_laplace_time_shift, _inverse_laplace_freq_shift,
+                  _inverse_laplace_time_diff, _inverse_laplace_diff,
+                  _inverse_laplace_irrational]
+
+    for p_rule in prog_rules:
+        if (r := p_rule(F, s, t, plane)) is not None:
+            return r
+    return None
+
+
+@DEBUG_WRAP
+def _inverse_laplace_expand(fn, s, t, plane):
+    """
+    Helper function for the class InverseLaplaceTransform.
+    """
+    if fn.is_Add:
+        return None
+    r = expand(fn, deep=False)
+    if r.is_Add:
+        return _inverse_laplace_transform(
+            r, s, t, plane, simplify=False, dorational=True)
+    r = expand_mul(fn)
+    if r.is_Add:
+        return _inverse_laplace_transform(
+            r, s, t, plane, simplify=False, dorational=True)
+    r = expand(fn)
+    if r.is_Add:
+        return _inverse_laplace_transform(
+            r, s, t, plane, simplify=False, dorational=True)
+    if fn.is_rational_function(s):
+        r = fn.apart(s).doit()
+    if r.is_Add:
+        return _inverse_laplace_transform(
+            r, s, t, plane, simplify=False, dorational=True)
+    return None
+
+
+@DEBUG_WRAP
+def _inverse_laplace_rational(fn, s, t, plane, *, simplify):
+    """
+    Helper function for the class InverseLaplaceTransform.
+    """
+    x_ = symbols('x_')
+    f = fn.apart(s)
+    terms = Add.make_args(f)
+    terms_t = []
+    conditions = [S.true]
+    for term in terms:
+        [n, d] = term.as_numer_denom()
+        dc = d.as_poly(s).all_coeffs()
+        dc_lead = dc[0]
+        dc = [x/dc_lead for x in dc]
+        nc = [x/dc_lead for x in n.as_poly(s).all_coeffs()]
+        if len(dc) == 1:
+            N = len(nc)-1
+            for c in enumerate(nc):
+                r = c[1]*DiracDelta(t, N-c[0])
+                terms_t.append(r)
+        elif len(dc) == 2:
+            r = nc[0]*exp(-dc[1]*t)
+            terms_t.append(Heaviside(t)*r)
+        elif len(dc) == 3:
+            a = dc[1]/2
+            b = (dc[2]-a**2).factor()
+            if len(nc) == 1:
+                nc = [S.Zero] + nc
+            l, m = tuple(nc)
+            if b == 0:
+                r = (m*t+l*(1-a*t))*exp(-a*t)
+            else:
+                hyp = False
+                if b.is_negative:
+                    b = -b
+                    hyp = True
+                b2 = list(roots(x_**2-b, x_).keys())[0]
+                bs = sqrt(b).simplify()
+                if hyp:
+                    r = (
+                        l*exp(-a*t)*cosh(b2*t) + (m-a*l) /
+                        bs*exp(-a*t)*sinh(bs*t))
+                else:
+                    r = l*exp(-a*t)*cos(b2*t) + (m-a*l)/bs*exp(-a*t)*sin(bs*t)
+            terms_t.append(Heaviside(t)*r)
+        else:
+            ft, cond = _inverse_laplace_transform(
+                term, s, t, plane, simplify=simplify, dorational=False)
+            terms_t.append(ft)
+            conditions.append(cond)
+
+    result = Add(*terms_t)
+    if simplify:
+        result = result.simplify(doit=False)
+    return result, And(*conditions)
+
+
+@DEBUG_WRAP
+def _inverse_laplace_transform(fn, s_, t_, plane, *, simplify, dorational):
+    """
+    Front-end function of the inverse Laplace transform. It tries to apply all
+    known rules recursively.  If everything else fails, it tries to integrate.
+    """
+    terms = Add.make_args(fn)
+    terms_t = []
+    conditions = []
+
+    for term in terms:
+        if term.has(exp):
+            # Simplify expressions with exp() such that time-shifted
+            # expressions have negative exponents in the numerator instead of
+            # positive exponents in the numerator and denominator; this is a
+            # (necessary) trick. It will, for example, convert
+            # (s**2*exp(2*s) + 4*exp(s) - 4)*exp(-2*s)/(s*(s**2 + 1)) into
+            # (s**2 + 4*exp(-s) - 4*exp(-2*s))/(s*(s**2 + 1))
+            term = term.subs(s_, -s_).together().subs(s_, -s_)
+        k, f = term.as_independent(s_, as_Add=False)
+        if (
+                dorational and term.is_rational_function(s_) and
+                (r := _inverse_laplace_rational(
+                    f, s_, t_, plane, simplify=simplify))
+                is not None or
+                (r := _inverse_laplace_apply_simple_rules(f, s_, t_))
+                is not None or
+                (r := _inverse_laplace_early_prog_rules(f, s_, t_, plane))
+                is not None or
+                (r := _inverse_laplace_expand(f, s_, t_, plane))
+                is not None or
+                (r := _inverse_laplace_apply_prog_rules(f, s_, t_, plane))
+                is not None):
+            pass
+        elif any(undef.has(s_) for undef in f.atoms(AppliedUndef)):
+            # If there are undefined functions f(t) then integration is
+            # unlikely to do anything useful so we skip it and given an
+            # unevaluated LaplaceTransform.
+            r = (InverseLaplaceTransform(f, s_, t_, plane), S.true)
+        elif (
+                r := _inverse_laplace_transform_integration(
+                    f, s_, t_, plane, simplify=simplify)) is not None:
+            pass
+        else:
+            r = (InverseLaplaceTransform(f, s_, t_, plane), S.true)
+        (ri_, ci_) = r
+        terms_t.append(k*ri_)
+        conditions.append(ci_)
+
+    result = Add(*terms_t)
+    if simplify:
+        result = result.simplify(doit=False)
+    condition = And(*conditions)
+
+    return result, condition
+
+
+class InverseLaplaceTransform(IntegralTransform):
+    """
+    Class representing unevaluated inverse Laplace transforms.
+
+    For usage of this class, see the :class:`IntegralTransform` docstring.
+
+    For how to compute inverse Laplace transforms, see the
+    :func:`inverse_laplace_transform` docstring.
+    """
+
+    _name = 'Inverse Laplace'
+    _none_sentinel = Dummy('None')
+    _c = Dummy('c')
+
+    def __new__(cls, F, s, x, plane, **opts):
+        if plane is None:
+            plane = InverseLaplaceTransform._none_sentinel
+        return IntegralTransform.__new__(cls, F, s, x, plane, **opts)
+
+    @property
+    def fundamental_plane(self):
+        plane = self.args[3]
+        if plane is InverseLaplaceTransform._none_sentinel:
+            plane = None
+        return plane
+
+    def _compute_transform(self, F, s, t, **hints):
+        return _inverse_laplace_transform_integration(
+            F, s, t, self.fundamental_plane, **hints)
+
+    def _as_integral(self, F, s, t):
+        c = self.__class__._c
+        return (
+            Integral(exp(s*t)*F, (s, c - S.ImaginaryUnit*S.Infinity,
+                                  c + S.ImaginaryUnit*S.Infinity)) /
+            (2*S.Pi*S.ImaginaryUnit))
+
+    def doit(self, **hints):
+        """
+        Try to evaluate the transform in closed form.
+
+        Explanation
+        ===========
+
+        Standard hints are the following:
+        - ``noconds``:  if True, do not return convergence conditions. The
+        default setting is `True`.
+        - ``simplify``: if True, it simplifies the final result. The
+        default setting is `False`.
+        """
+        _noconds = hints.get('noconds', True)
+        _simplify = hints.get('simplify', False)
+
+        debugf('[ILT doit] (%s, %s, %s)', (self.function,
+                                           self.function_variable,
+                                           self.transform_variable))
+
+        s_ = self.function_variable
+        t_ = self.transform_variable
+        fn = self.function
+        plane = self.fundamental_plane
+
+        r = _inverse_laplace_transform(
+            fn, s_, t_, plane, simplify=_simplify, dorational=True)
+
+        if _noconds:
+            return r[0]
+        else:
+            return r
+
+
+def inverse_laplace_transform(F, s, t, plane=None, **hints):
+    r"""
+    Compute the inverse Laplace transform of `F(s)`, defined as
+
+    .. math ::
+        f(t) = \frac{1}{2\pi i} \int_{c-i\infty}^{c+i\infty} e^{st}
+        F(s) \mathrm{d}s,
+
+    for `c` so large that `F(s)` has no singularites in the
+    half-plane `\operatorname{Re}(s) > c-\epsilon`.
+
+    Explanation
+    ===========
+
+    The plane can be specified by
+    argument ``plane``, but will be inferred if passed as None.
+
+    Under certain regularity conditions, this recovers `f(t)` from its
+    Laplace Transform `F(s)`, for non-negative `t`, and vice
+    versa.
+
+    If the integral cannot be computed in closed form, this function returns
+    an unevaluated :class:`InverseLaplaceTransform` object.
+
+    Note that this function will always assume `t` to be real,
+    regardless of the SymPy assumption on `t`.
+
+    For a description of possible hints, refer to the docstring of
+    :func:`sympy.integrals.transforms.IntegralTransform.doit`.
+
+    Examples
+    ========
+
+    >>> from sympy import inverse_laplace_transform, exp, Symbol
+    >>> from sympy.abc import s, t
+    >>> a = Symbol('a', positive=True)
+    >>> inverse_laplace_transform(exp(-a*s)/s, s, t)
+    Heaviside(-a + t)
+
+    See Also
+    ========
+
+    laplace_transform
+    hankel_transform, inverse_hankel_transform
+    """
+    _noconds = hints.get('noconds', True)
+    _simplify = hints.get('simplify', False)
+
+    if isinstance(F, MatrixBase) and hasattr(F, 'applyfunc'):
+        return F.applyfunc(
+            lambda Fij: inverse_laplace_transform(Fij, s, t, plane, **hints))
+
+    r, c = InverseLaplaceTransform(F, s, t, plane).doit(
+        noconds=False, simplify=_simplify)
+
+    if _noconds:
+        return r
+    else:
+        return r, c
+
+
+def _fast_inverse_laplace(e, s, t):
+    """Fast inverse Laplace transform of rational function including RootSum"""
+    a, b, n = symbols('a, b, n', cls=Wild, exclude=[s])
+
+    def _ilt(e):
+        if not e.has(s):
+            return e
+        elif e.is_Add:
+            return _ilt_add(e)
+        elif e.is_Mul:
+            return _ilt_mul(e)
+        elif e.is_Pow:
+            return _ilt_pow(e)
+        elif isinstance(e, RootSum):
+            return _ilt_rootsum(e)
+        else:
+            raise NotImplementedError
+
+    def _ilt_add(e):
+        return e.func(*map(_ilt, e.args))
+
+    def _ilt_mul(e):
+        coeff, expr = e.as_independent(s)
+        if expr.is_Mul:
+            raise NotImplementedError
+        return coeff * _ilt(expr)
+
+    def _ilt_pow(e):
+        match = e.match((a*s + b)**n)
+        if match is not None:
+            nm, am, bm = match[n], match[a], match[b]
+            if nm.is_Integer and nm < 0:
+                return t**(-nm-1)*exp(-(bm/am)*t)/(am**-nm*gamma(-nm))
+            if nm == 1:
+                return exp(-(bm/am)*t) / am
+        raise NotImplementedError
+
+    def _ilt_rootsum(e):
+        expr = e.fun.expr
+        [variable] = e.fun.variables
+        return RootSum(e.poly, Lambda(variable, together(_ilt(expr))))
+
+    return _ilt(e)

.venv/lib/python3.12/site-packages/sympy/integrals/manualintegrate.py

@@ -0,0 +1,2174 @@
+"""Integration method that emulates by-hand techniques.
+
+This module also provides functionality to get the steps used to evaluate a
+particular integral, in the ``integral_steps`` function. This will return
+nested ``Rule`` s representing the integration rules used.
+
+Each ``Rule`` class represents a (maybe parametrized) integration rule, e.g.
+``SinRule`` for integrating ``sin(x)`` and ``ReciprocalSqrtQuadraticRule``
+for integrating ``1/sqrt(a+b*x+c*x**2)``. The ``eval`` method returns the
+integration result.
+
+The ``manualintegrate`` function computes the integral by calling ``eval``
+on the rule returned by ``integral_steps``.
+
+The integrator can be extended with new heuristics and evaluation
+techniques. To do so, extend the ``Rule`` class, implement ``eval`` method,
+then write a function that accepts an ``IntegralInfo`` object and returns
+either a ``Rule`` instance or ``None``. If the new technique requires a new
+match, add the key and call to the antiderivative function to integral_steps.
+To enable simple substitutions, add the match to find_substitutions.
+
+"""
+
+from __future__ import annotations
+from typing import NamedTuple, Type, Callable, Sequence
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from collections import defaultdict
+from collections.abc import Mapping
+
+from sympy.core.add import Add
+from sympy.core.cache import cacheit
+from sympy.core.containers import Dict
+from sympy.core.expr import Expr
+from sympy.core.function import Derivative
+from sympy.core.logic import fuzzy_not
+from sympy.core.mul import Mul
+from sympy.core.numbers import Integer, Number, E
+from sympy.core.power import Pow
+from sympy.core.relational import Eq, Ne, Boolean
+from sympy.core.singleton import S
+from sympy.core.symbol import Dummy, Symbol, Wild
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.elementary.hyperbolic import (HyperbolicFunction, csch,
+    cosh, coth, sech, sinh, tanh, asinh)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (TrigonometricFunction,
+    cos, sin, tan, cot, csc, sec, acos, asin, atan, acot, acsc, asec)
+from sympy.functions.special.delta_functions import Heaviside, DiracDelta
+from sympy.functions.special.error_functions import (erf, erfi, fresnelc,
+    fresnels, Ci, Chi, Si, Shi, Ei, li)
+from sympy.functions.special.gamma_functions import uppergamma
+from sympy.functions.special.elliptic_integrals import elliptic_e, elliptic_f
+from sympy.functions.special.polynomials import (chebyshevt, chebyshevu,
+    legendre, hermite, laguerre, assoc_laguerre, gegenbauer, jacobi,
+    OrthogonalPolynomial)
+from sympy.functions.special.zeta_functions import polylog
+from .integrals import Integral
+from sympy.logic.boolalg import And
+from sympy.ntheory.factor_ import primefactors
+from sympy.polys.polytools import degree, lcm_list, gcd_list, Poly
+from sympy.simplify.radsimp import fraction
+from sympy.simplify.simplify import simplify
+from sympy.solvers.solvers import solve
+from sympy.strategies.core import switch, do_one, null_safe, condition
+from sympy.utilities.iterables import iterable
+from sympy.utilities.misc import debug
+
+
+@dataclass
+class Rule(ABC):
+    integrand: Expr
+    variable: Symbol
+
+    @abstractmethod
+    def eval(self) -> Expr:
+        pass
+
+    @abstractmethod
+    def contains_dont_know(self) -> bool:
+        pass
+
+
+@dataclass
+class AtomicRule(Rule, ABC):
+    """A simple rule that does not depend on other rules"""
+    def contains_dont_know(self) -> bool:
+        return False
+
+
+@dataclass
+class ConstantRule(AtomicRule):
+    """integrate(a, x)  ->  a*x"""
+    def eval(self) -> Expr:
+        return self.integrand * self.variable
+
+
+@dataclass
+class ConstantTimesRule(Rule):
+    """integrate(a*f(x), x)  ->  a*integrate(f(x), x)"""
+    constant: Expr
+    other: Expr
+    substep: Rule
+
+    def eval(self) -> Expr:
+        return self.constant * self.substep.eval()
+
+    def contains_dont_know(self) -> bool:
+        return self.substep.contains_dont_know()
+
+
+@dataclass
+class PowerRule(AtomicRule):
+    """integrate(x**a, x)"""
+    base: Expr
+    exp: Expr
+
+    def eval(self) -> Expr:
+        return Piecewise(
+            ((self.base**(self.exp + 1))/(self.exp + 1), Ne(self.exp, -1)),
+            (log(self.base), True),
+        )
+
+
+@dataclass
+class NestedPowRule(AtomicRule):
+    """integrate((x**a)**b, x)"""
+    base: Expr
+    exp: Expr
+
+    def eval(self) -> Expr:
+        m = self.base * self.integrand
+        return Piecewise((m / (self.exp + 1), Ne(self.exp, -1)),
+                         (m * log(self.base), True))
+
+
+@dataclass
+class AddRule(Rule):
+    """integrate(f(x) + g(x), x) -> integrate(f(x), x) + integrate(g(x), x)"""
+    substeps: list[Rule]
+
+    def eval(self) -> Expr:
+        return Add(*(substep.eval() for substep in self.substeps))
+
+    def contains_dont_know(self) -> bool:
+        return any(substep.contains_dont_know() for substep in self.substeps)
+
+
+@dataclass
+class URule(Rule):
+    """integrate(f(g(x))*g'(x), x) -> integrate(f(u), u), u = g(x)"""
+    u_var: Symbol
+    u_func: Expr
+    substep: Rule
+
+    def eval(self) -> Expr:
+        result = self.substep.eval()
+        if self.u_func.is_Pow:
+            base, exp_ = self.u_func.as_base_exp()
+            if exp_ == -1:
+                # avoid needless -log(1/x) from substitution
+                result = result.subs(log(self.u_var), -log(base))
+        return result.subs(self.u_var, self.u_func)
+
+    def contains_dont_know(self) -> bool:
+        return self.substep.contains_dont_know()
+
+
+@dataclass
+class PartsRule(Rule):
+    """integrate(u(x)*v'(x), x) -> u(x)*v(x) - integrate(u'(x)*v(x), x)"""
+    u: Symbol
+    dv: Expr
+    v_step: Rule
+    second_step: Rule | None  # None when is a substep of CyclicPartsRule
+
+    def eval(self) -> Expr:
+        assert self.second_step is not None
+        v = self.v_step.eval()
+        return self.u * v - self.second_step.eval()
+
+    def contains_dont_know(self) -> bool:
+        return self.v_step.contains_dont_know() or (
+            self.second_step is not None and self.second_step.contains_dont_know())
+
+
+@dataclass
+class CyclicPartsRule(Rule):
+    """Apply PartsRule multiple times to integrate exp(x)*sin(x)"""
+    parts_rules: list[PartsRule]
+    coefficient: Expr
+
+    def eval(self) -> Expr:
+        result = []
+        sign = 1
+        for rule in self.parts_rules:
+            result.append(sign * rule.u * rule.v_step.eval())
+            sign *= -1
+        return Add(*result) / (1 - self.coefficient)
+
+    def contains_dont_know(self) -> bool:
+        return any(substep.contains_dont_know() for substep in self.parts_rules)
+
+
+@dataclass
+class TrigRule(AtomicRule, ABC):
+    pass
+
+
+@dataclass
+class SinRule(TrigRule):
+    """integrate(sin(x), x) -> -cos(x)"""
+    def eval(self) -> Expr:
+        return -cos(self.variable)
+
+
+@dataclass
+class CosRule(TrigRule):
+    """integrate(cos(x), x) -> sin(x)"""
+    def eval(self) -> Expr:
+        return sin(self.variable)
+
+
+@dataclass
+class SecTanRule(TrigRule):
+    """integrate(sec(x)*tan(x), x) -> sec(x)"""
+    def eval(self) -> Expr:
+        return sec(self.variable)
+
+
+@dataclass
+class CscCotRule(TrigRule):
+    """integrate(csc(x)*cot(x), x) -> -csc(x)"""
+    def eval(self) -> Expr:
+        return -csc(self.variable)
+
+
+@dataclass
+class Sec2Rule(TrigRule):
+    """integrate(sec(x)**2, x) -> tan(x)"""
+    def eval(self) -> Expr:
+        return tan(self.variable)
+
+
+@dataclass
+class Csc2Rule(TrigRule):
+    """integrate(csc(x)**2, x) -> -cot(x)"""
+    def eval(self) -> Expr:
+        return -cot(self.variable)
+
+
+@dataclass
+class HyperbolicRule(AtomicRule, ABC):
+    pass
+
+
+@dataclass
+class SinhRule(HyperbolicRule):
+    """integrate(sinh(x), x) -> cosh(x)"""
+    def eval(self) -> Expr:
+        return cosh(self.variable)
+
+
+@dataclass
+class CoshRule(HyperbolicRule):
+    """integrate(cosh(x), x) -> sinh(x)"""
+    def eval(self):
+        return sinh(self.variable)
+
+
+@dataclass
+class ExpRule(AtomicRule):
+    """integrate(a**x, x) -> a**x/ln(a)"""
+    base: Expr
+    exp: Expr
+
+    def eval(self) -> Expr:
+        return self.integrand / log(self.base)
+
+
+@dataclass
+class ReciprocalRule(AtomicRule):
+    """integrate(1/x, x) -> ln(x)"""
+    base: Expr
+
+    def eval(self) -> Expr:
+        return log(self.base)
+
+
+@dataclass
+class ArcsinRule(AtomicRule):
+    """integrate(1/sqrt(1-x**2), x) -> asin(x)"""
+    def eval(self) -> Expr:
+        return asin(self.variable)
+
+
+@dataclass
+class ArcsinhRule(AtomicRule):
+    """integrate(1/sqrt(1+x**2), x) -> asin(x)"""
+    def eval(self) -> Expr:
+        return asinh(self.variable)
+
+
+@dataclass
+class ReciprocalSqrtQuadraticRule(AtomicRule):
+    """integrate(1/sqrt(a+b*x+c*x**2), x) -> log(2*sqrt(c)*sqrt(a+b*x+c*x**2)+b+2*c*x)/sqrt(c)"""
+    a: Expr
+    b: Expr
+    c: Expr
+
+    def eval(self) -> Expr:
+        a, b, c, x = self.a, self.b, self.c, self.variable
+        return log(2*sqrt(c)*sqrt(a+b*x+c*x**2)+b+2*c*x)/sqrt(c)
+
+
+@dataclass
+class SqrtQuadraticDenomRule(AtomicRule):
+    """integrate(poly(x)/sqrt(a+b*x+c*x**2), x)"""
+    a: Expr
+    b: Expr
+    c: Expr
+    coeffs: list[Expr]
+
+    def eval(self) -> Expr:
+        a, b, c, coeffs, x = self.a, self.b, self.c, self.coeffs.copy(), self.variable
+        # Integrate poly/sqrt(a+b*x+c*x**2) using recursion.
+        # coeffs are coefficients of the polynomial.
+        # Let I_n = x**n/sqrt(a+b*x+c*x**2), then
+        # I_n = A * x**(n-1)*sqrt(a+b*x+c*x**2) - B * I_{n-1} - C * I_{n-2}
+        # where A = 1/(n*c), B = (2*n-1)*b/(2*n*c), C = (n-1)*a/(n*c)
+        # See https://github.com/sympy/sympy/pull/23608 for proof.
+        result_coeffs = []
+        coeffs = coeffs.copy()
+        for i in range(len(coeffs)-2):
+            n = len(coeffs)-1-i
+            coeff = coeffs[i]/(c*n)
+            result_coeffs.append(coeff)
+            coeffs[i+1] -= (2*n-1)*b/2*coeff
+            coeffs[i+2] -= (n-1)*a*coeff
+        d, e = coeffs[-1], coeffs[-2]
+        s = sqrt(a+b*x+c*x**2)
+        constant = d-b*e/(2*c)
+        if constant == 0:
+            I0 = 0
+        else:
+            step = inverse_trig_rule(IntegralInfo(1/s, x), degenerate=False)
+            I0 = constant*step.eval()
+        return Add(*(result_coeffs[i]*x**(len(coeffs)-2-i)
+                     for i in range(len(result_coeffs))), e/c)*s + I0
+
+
+@dataclass
+class SqrtQuadraticRule(AtomicRule):
+    """integrate(sqrt(a+b*x+c*x**2), x)"""
+    a: Expr
+    b: Expr
+    c: Expr
+
+    def eval(self) -> Expr:
+        step = sqrt_quadratic_rule(IntegralInfo(self.integrand, self.variable), degenerate=False)
+        return step.eval()
+
+
+@dataclass
+class AlternativeRule(Rule):
+    """Multiple ways to do integration."""
+    alternatives: list[Rule]
+
+    def eval(self) -> Expr:
+        return self.alternatives[0].eval()
+
+    def contains_dont_know(self) -> bool:
+        return any(substep.contains_dont_know() for substep in self.alternatives)
+
+
+@dataclass
+class DontKnowRule(Rule):
+    """Leave the integral as is."""
+    def eval(self) -> Expr:
+        return Integral(self.integrand, self.variable)
+
+    def contains_dont_know(self) -> bool:
+        return True
+
+
+@dataclass
+class DerivativeRule(AtomicRule):
+    """integrate(f'(x), x) -> f(x)"""
+    def eval(self) -> Expr:
+        assert isinstance(self.integrand, Derivative)
+        variable_count = list(self.integrand.variable_count)
+        for i, (var, count) in enumerate(variable_count):
+            if var == self.variable:
+                variable_count[i] = (var, count - 1)
+                break
+        return Derivative(self.integrand.expr, *variable_count)
+
+
+@dataclass
+class RewriteRule(Rule):
+    """Rewrite integrand to another form that is easier to handle."""
+    rewritten: Expr
+    substep: Rule
+
+    def eval(self) -> Expr:
+        return self.substep.eval()
+
+    def contains_dont_know(self) -> bool:
+        return self.substep.contains_dont_know()
+
+
+@dataclass
+class CompleteSquareRule(RewriteRule):
+    """Rewrite a+b*x+c*x**2 to a-b**2/(4*c) + c*(x+b/(2*c))**2"""
+    pass
+
+
+@dataclass
+class PiecewiseRule(Rule):
+    subfunctions: Sequence[tuple[Rule, bool | Boolean]]
+
+    def eval(self) -> Expr:
+        return Piecewise(*[(substep.eval(), cond)
+                           for substep, cond in self.subfunctions])
+
+    def contains_dont_know(self) -> bool:
+        return any(substep.contains_dont_know() for substep, _ in self.subfunctions)
+
+
+@dataclass
+class HeavisideRule(Rule):
+    harg: Expr
+    ibnd: Expr
+    substep: Rule
+
+    def eval(self) -> Expr:
+        # If we are integrating over x and the integrand has the form
+        #       Heaviside(m*x+b)*g(x) == Heaviside(harg)*g(symbol)
+        # then there needs to be continuity at -b/m == ibnd,
+        # so we subtract the appropriate term.
+        result = self.substep.eval()
+        return Heaviside(self.harg) * (result - result.subs(self.variable, self.ibnd))
+
+    def contains_dont_know(self) -> bool:
+        return self.substep.contains_dont_know()
+
+
+@dataclass
+class DiracDeltaRule(AtomicRule):
+    n: Expr
+    a: Expr
+    b: Expr
+
+    def eval(self) -> Expr:
+        n, a, b, x = self.n, self.a, self.b, self.variable
+        if n == 0:
+            return Heaviside(a+b*x)/b
+        return DiracDelta(a+b*x, n-1)/b
+
+
+@dataclass
+class TrigSubstitutionRule(Rule):
+    theta: Expr
+    func: Expr
+    rewritten: Expr
+    substep: Rule
+    restriction: bool | Boolean
+
+    def eval(self) -> Expr:
+        theta, func, x = self.theta, self.func, self.variable
+        func = func.subs(sec(theta), 1/cos(theta))
+        func = func.subs(csc(theta), 1/sin(theta))
+        func = func.subs(cot(theta), 1/tan(theta))
+
+        trig_function = list(func.find(TrigonometricFunction))
+        assert len(trig_function) == 1
+        trig_function = trig_function[0]
+        relation = solve(x - func, trig_function)
+        assert len(relation) == 1
+        numer, denom = fraction(relation[0])
+
+        if isinstance(trig_function, sin):
+            opposite = numer
+            hypotenuse = denom
+            adjacent = sqrt(denom**2 - numer**2)
+            inverse = asin(relation[0])
+        elif isinstance(trig_function, cos):
+            adjacent = numer
+            hypotenuse = denom
+            opposite = sqrt(denom**2 - numer**2)
+            inverse = acos(relation[0])
+        else:  # tan
+            opposite = numer
+            adjacent = denom
+            hypotenuse = sqrt(denom**2 + numer**2)
+            inverse = atan(relation[0])
+
+        substitution = [
+            (sin(theta), opposite/hypotenuse),
+            (cos(theta), adjacent/hypotenuse),
+            (tan(theta), opposite/adjacent),
+            (theta, inverse)
+        ]
+        return Piecewise(
+                (self.substep.eval().subs(substitution).trigsimp(), self.restriction) # type: ignore
+        )
+
+    def contains_dont_know(self) -> bool:
+        return self.substep.contains_dont_know()
+
+
+@dataclass
+class ArctanRule(AtomicRule):
+    """integrate(a/(b*x**2+c), x) -> a/b / sqrt(c/b) * atan(x/sqrt(c/b))"""
+    a: Expr
+    b: Expr
+    c: Expr
+
+    def eval(self) -> Expr:
+        a, b, c, x = self.a, self.b, self.c, self.variable
+        return a/b / sqrt(c/b) * atan(x/sqrt(c/b))
+
+
+@dataclass
+class OrthogonalPolyRule(AtomicRule, ABC):
+    n: Expr
+
+
+@dataclass
+class JacobiRule(OrthogonalPolyRule):
+    a: Expr
+    b: Expr
+
+    def eval(self) -> Expr:
+        n, a, b, x = self.n, self.a, self.b, self.variable
+        return Piecewise(
+            (2*jacobi(n + 1, a - 1, b - 1, x)/(n + a + b), Ne(n + a + b, 0)),
+            (x, Eq(n, 0)),
+            ((a + b + 2)*x**2/4 + (a - b)*x/2, Eq(n, 1)))
+
+
+@dataclass
+class GegenbauerRule(OrthogonalPolyRule):
+    a: Expr
+
+    def eval(self) -> Expr:
+        n, a, x = self.n, self.a, self.variable
+        return Piecewise(
+            (gegenbauer(n + 1, a - 1, x)/(2*(a - 1)), Ne(a, 1)),
+            (chebyshevt(n + 1, x)/(n + 1), Ne(n, -1)),
+            (S.Zero, True))
+
+
+@dataclass
+class ChebyshevTRule(OrthogonalPolyRule):
+    def eval(self) -> Expr:
+        n, x = self.n, self.variable
+        return Piecewise(
+            ((chebyshevt(n + 1, x)/(n + 1) -
+              chebyshevt(n - 1, x)/(n - 1))/2, Ne(Abs(n), 1)),
+            (x**2/2, True))
+
+
+@dataclass
+class ChebyshevURule(OrthogonalPolyRule):
+    def eval(self) -> Expr:
+        n, x = self.n, self.variable
+        return Piecewise(
+            (chebyshevt(n + 1, x)/(n + 1), Ne(n, -1)),
+            (S.Zero, True))
+
+
+@dataclass
+class LegendreRule(OrthogonalPolyRule):
+    def eval(self) -> Expr:
+        n, x = self.n, self.variable
+        return(legendre(n + 1, x) - legendre(n - 1, x))/(2*n + 1)
+
+
+@dataclass
+class HermiteRule(OrthogonalPolyRule):
+    def eval(self) -> Expr:
+        n, x = self.n, self.variable
+        return hermite(n + 1, x)/(2*(n + 1))
+
+
+@dataclass
+class LaguerreRule(OrthogonalPolyRule):
+    def eval(self) -> Expr:
+        n, x = self.n, self.variable
+        return laguerre(n, x) - laguerre(n + 1, x)
+
+
+@dataclass
+class AssocLaguerreRule(OrthogonalPolyRule):
+    a: Expr
+
+    def eval(self) -> Expr:
+        return -assoc_laguerre(self.n + 1, self.a - 1, self.variable)
+
+
+@dataclass
+class IRule(AtomicRule, ABC):
+    a: Expr
+    b: Expr
+
+
+@dataclass
+class CiRule(IRule):
+    def eval(self) -> Expr:
+        a, b, x = self.a, self.b, self.variable
+        return cos(b)*Ci(a*x) - sin(b)*Si(a*x)
+
+
+@dataclass
+class ChiRule(IRule):
+    def eval(self) -> Expr:
+        a, b, x = self.a, self.b, self.variable
+        return cosh(b)*Chi(a*x) + sinh(b)*Shi(a*x)
+
+
+@dataclass
+class EiRule(IRule):
+    def eval(self) -> Expr:
+        a, b, x = self.a, self.b, self.variable
+        return exp(b)*Ei(a*x)
+
+
+@dataclass
+class SiRule(IRule):
+    def eval(self) -> Expr:
+        a, b, x = self.a, self.b, self.variable
+        return sin(b)*Ci(a*x) + cos(b)*Si(a*x)
+
+
+@dataclass
+class ShiRule(IRule):
+    def eval(self) -> Expr:
+        a, b, x = self.a, self.b, self.variable
+        return sinh(b)*Chi(a*x) + cosh(b)*Shi(a*x)
+
+
+@dataclass
+class LiRule(IRule):
+    def eval(self) -> Expr:
+        a, b, x = self.a, self.b, self.variable
+        return li(a*x + b)/a
+
+
+@dataclass
+class ErfRule(AtomicRule):
+    a: Expr
+    b: Expr
+    c: Expr
+
+    def eval(self) -> Expr:
+        a, b, c, x = self.a, self.b, self.c, self.variable
+        if a.is_extended_real:
+            return Piecewise(
+                (sqrt(S.Pi)/sqrt(-a)/2 * exp(c - b**2/(4*a)) *
+                    erf((-2*a*x - b)/(2*sqrt(-a))), a < 0),
+                (sqrt(S.Pi)/sqrt(a)/2 * exp(c - b**2/(4*a)) *
+                    erfi((2*a*x + b)/(2*sqrt(a))), True))
+        return sqrt(S.Pi)/sqrt(a)/2 * exp(c - b**2/(4*a)) * \
+                erfi((2*a*x + b)/(2*sqrt(a)))
+
+
+@dataclass
+class FresnelCRule(AtomicRule):
+    a: Expr
+    b: Expr
+    c: Expr
+
+    def eval(self) -> Expr:
+        a, b, c, x = self.a, self.b, self.c, self.variable
+        return sqrt(S.Pi)/sqrt(2*a) * (
+            cos(b**2/(4*a) - c)*fresnelc((2*a*x + b)/sqrt(2*a*S.Pi)) +
+            sin(b**2/(4*a) - c)*fresnels((2*a*x + b)/sqrt(2*a*S.Pi)))
+
+
+@dataclass
+class FresnelSRule(AtomicRule):
+    a: Expr
+    b: Expr
+    c: Expr
+
+    def eval(self) -> Expr:
+        a, b, c, x = self.a, self.b, self.c, self.variable
+        return sqrt(S.Pi)/sqrt(2*a) * (
+            cos(b**2/(4*a) - c)*fresnels((2*a*x + b)/sqrt(2*a*S.Pi)) -
+            sin(b**2/(4*a) - c)*fresnelc((2*a*x + b)/sqrt(2*a*S.Pi)))
+
+
+@dataclass
+class PolylogRule(AtomicRule):
+    a: Expr
+    b: Expr
+
+    def eval(self) -> Expr:
+        return polylog(self.b + 1, self.a * self.variable)
+
+
+@dataclass
+class UpperGammaRule(AtomicRule):
+    a: Expr
+    e: Expr
+
+    def eval(self) -> Expr:
+        a, e, x = self.a, self.e, self.variable
+        return x**e * (-a*x)**(-e) * uppergamma(e + 1, -a*x)/a
+
+
+@dataclass
+class EllipticFRule(AtomicRule):
+    a: Expr
+    d: Expr
+
+    def eval(self) -> Expr:
+        return elliptic_f(self.variable, self.d/self.a)/sqrt(self.a)
+
+
+@dataclass
+class EllipticERule(AtomicRule):
+    a: Expr
+    d: Expr
+
+    def eval(self) -> Expr:
+        return elliptic_e(self.variable, self.d/self.a)*sqrt(self.a)
+
+
+class IntegralInfo(NamedTuple):
+    integrand: Expr
+    symbol: Symbol
+
+
+def manual_diff(f, symbol):
+    """Derivative of f in form expected by find_substitutions
+
+    SymPy's derivatives for some trig functions (like cot) are not in a form
+    that works well with finding substitutions; this replaces the
+    derivatives for those particular forms with something that works better.
+
+    """
+    if f.args:
+        arg = f.args[0]
+        if isinstance(f, tan):
+            return arg.diff(symbol) * sec(arg)**2
+        elif isinstance(f, cot):
+            return -arg.diff(symbol) * csc(arg)**2
+        elif isinstance(f, sec):
+            return arg.diff(symbol) * sec(arg) * tan(arg)
+        elif isinstance(f, csc):
+            return -arg.diff(symbol) * csc(arg) * cot(arg)
+        elif isinstance(f, Add):
+            return sum(manual_diff(arg, symbol) for arg in f.args)
+        elif isinstance(f, Mul):
+            if len(f.args) == 2 and isinstance(f.args[0], Number):
+                return f.args[0] * manual_diff(f.args[1], symbol)
+    return f.diff(symbol)
+
+def manual_subs(expr, *args):
+    """
+    A wrapper for `expr.subs(*args)` with additional logic for substitution
+    of invertible functions.
+    """
+    if len(args) == 1:
+        sequence = args[0]
+        if isinstance(sequence, (Dict, Mapping)):
+            sequence = sequence.items()
+        elif not iterable(sequence):
+            raise ValueError("Expected an iterable of (old, new) pairs")
+    elif len(args) == 2:
+        sequence = [args]
+    else:
+        raise ValueError("subs accepts either 1 or 2 arguments")
+
+    new_subs = []
+    for old, new in sequence:
+        if isinstance(old, log):
+            # If log(x) = y, then exp(a*log(x)) = exp(a*y)
+            # that is, x**a = exp(a*y). Replace nontrivial powers of x
+            # before subs turns them into `exp(y)**a`, but
+            # do not replace x itself yet, to avoid `log(exp(y))`.
+            x0 = old.args[0]
+            expr = expr.replace(lambda x: x.is_Pow and x.base == x0,
+                lambda x: exp(x.exp*new))
+            new_subs.append((x0, exp(new)))
+
+    return expr.subs(list(sequence) + new_subs)
+
+# Method based on that on SIN, described in "Symbolic Integration: The
+# Stormy Decade"
+
+inverse_trig_functions = (atan, asin, acos, acot, acsc, asec)
+
+
+def find_substitutions(integrand, symbol, u_var):
+    results = []
+
+    def test_subterm(u, u_diff):
+        if u_diff == 0:
+            return False
+        substituted = integrand / u_diff
+        debug("substituted: {}, u: {}, u_var: {}".format(substituted, u, u_var))
+        substituted = manual_subs(substituted, u, u_var).cancel()
+
+        if substituted.has_free(symbol):
+            return False
+        # avoid increasing the degree of a rational function
+        if integrand.is_rational_function(symbol) and substituted.is_rational_function(u_var):
+            deg_before = max(degree(t, symbol) for t in integrand.as_numer_denom())
+            deg_after = max(degree(t, u_var) for t in substituted.as_numer_denom())
+            if deg_after > deg_before:
+                return False
+        return substituted.as_independent(u_var, as_Add=False)
+
+    def exp_subterms(term: Expr):
+        linear_coeffs = []
+        terms = []
+        n = Wild('n', properties=[lambda n: n.is_Integer])
+        for exp_ in term.find(exp):
+            arg = exp_.args[0]
+            if symbol not in arg.free_symbols:
+                continue
+            match = arg.match(n*symbol)
+            if match:
+                linear_coeffs.append(match[n])
+            else:
+                terms.append(exp_)
+        if linear_coeffs:
+            terms.append(exp(gcd_list(linear_coeffs)*symbol))
+        return terms
+
+    def possible_subterms(term):
+        if isinstance(term, (TrigonometricFunction, HyperbolicFunction,
+                             *inverse_trig_functions,
+                             exp, log, Heaviside)):
+            return [term.args[0]]
+        elif isinstance(term, (chebyshevt, chebyshevu,
+                        legendre, hermite, laguerre)):
+            return [term.args[1]]
+        elif isinstance(term, (gegenbauer, assoc_laguerre)):
+            return [term.args[2]]
+        elif isinstance(term, jacobi):
+            return [term.args[3]]
+        elif isinstance(term, Mul):
+            r = []
+            for u in term.args:
+                r.append(u)
+                r.extend(possible_subterms(u))
+            return r
+        elif isinstance(term, Pow):
+            r = [arg for arg in term.args if arg.has(symbol)]
+            if term.exp.is_Integer:
+                r.extend([term.base**d for d in primefactors(term.exp)
+                    if 1 < d < abs(term.args[1])])
+                if term.base.is_Add:
+                    r.extend([t for t in possible_subterms(term.base)
+                        if t.is_Pow])
+            return r
+        elif isinstance(term, Add):
+            r = []
+            for arg in term.args:
+                r.append(arg)
+                r.extend(possible_subterms(arg))
+            return r
+        return []
+
+    for u in list(dict.fromkeys(possible_subterms(integrand) + exp_subterms(integrand))):
+        if u == symbol:
+            continue
+        u_diff = manual_diff(u, symbol)
+        new_integrand = test_subterm(u, u_diff)
+        if new_integrand is not False:
+            constant, new_integrand = new_integrand
+            if new_integrand == integrand.subs(symbol, u_var):
+                continue
+            substitution = (u, constant, new_integrand)
+            if substitution not in results:
+                results.append(substitution)
+
+    return results
+
+def rewriter(condition, rewrite):
+    """Strategy that rewrites an integrand."""
+    def _rewriter(integral):
+        integrand, symbol = integral
+        debug("Integral: {} is rewritten with {} on symbol: {}".format(integrand, rewrite, symbol))
+        if condition(*integral):
+            rewritten = rewrite(*integral)
+            if rewritten != integrand:
+                substep = integral_steps(rewritten, symbol)
+                if not isinstance(substep, DontKnowRule) and substep:
+                    return RewriteRule(integrand, symbol, rewritten, substep)
+    return _rewriter
+
+def proxy_rewriter(condition, rewrite):
+    """Strategy that rewrites an integrand based on some other criteria."""
+    def _proxy_rewriter(criteria):
+        criteria, integral = criteria
+        integrand, symbol = integral
+        debug("Integral: {} is rewritten with {} on symbol: {} and criteria: {}".format(integrand, rewrite, symbol, criteria))
+        args = criteria + list(integral)
+        if condition(*args):
+            rewritten = rewrite(*args)
+            if rewritten != integrand:
+                return RewriteRule(integrand, symbol, rewritten, integral_steps(rewritten, symbol))
+    return _proxy_rewriter
+
+def multiplexer(conditions):
+    """Apply the rule that matches the condition, else None"""
+    def multiplexer_rl(expr):
+        for key, rule in conditions.items():
+            if key(expr):
+                return rule(expr)
+    return multiplexer_rl
+
+def alternatives(*rules):
+    """Strategy that makes an AlternativeRule out of multiple possible results."""
+    def _alternatives(integral):
+        alts = []
+        count = 0
+        debug("List of Alternative Rules")
+        for rule in rules:
+            count = count + 1
+            debug("Rule {}: {}".format(count, rule))
+
+            result = rule(integral)
+            if (result and not isinstance(result, DontKnowRule) and
+                result != integral and result not in alts):
+                alts.append(result)
+        if len(alts) == 1:
+            return alts[0]
+        elif alts:
+            doable = [rule for rule in alts if not rule.contains_dont_know()]
+            if doable:
+                return AlternativeRule(*integral, doable)
+            else:
+                return AlternativeRule(*integral, alts)
+    return _alternatives
+
+def constant_rule(integral):
+    return ConstantRule(*integral)
+
+def power_rule(integral):
+    integrand, symbol = integral
+    base, expt = integrand.as_base_exp()
+
+    if symbol not in expt.free_symbols and isinstance(base, Symbol):
+        if simplify(expt + 1) == 0:
+            return ReciprocalRule(integrand, symbol, base)
+        return PowerRule(integrand, symbol, base, expt)
+    elif symbol not in base.free_symbols and isinstance(expt, Symbol):
+        rule = ExpRule(integrand, symbol, base, expt)
+
+        if fuzzy_not(log(base).is_zero):
+            return rule
+        elif log(base).is_zero:
+            return ConstantRule(1, symbol)
+
+        return PiecewiseRule(integrand, symbol, [
+            (rule, Ne(log(base), 0)),
+            (ConstantRule(1, symbol), True)
+        ])
+
+def exp_rule(integral):
+    integrand, symbol = integral
+    if isinstance(integrand.args[0], Symbol):
+        return ExpRule(integrand, symbol, E, integrand.args[0])
+
+
+def orthogonal_poly_rule(integral):
+    orthogonal_poly_classes = {
+        jacobi: JacobiRule,
+        gegenbauer: GegenbauerRule,
+        chebyshevt: ChebyshevTRule,
+        chebyshevu: ChebyshevURule,
+        legendre: LegendreRule,
+        hermite: HermiteRule,
+        laguerre: LaguerreRule,
+        assoc_laguerre: AssocLaguerreRule
+        }
+    orthogonal_poly_var_index = {
+        jacobi: 3,
+        gegenbauer: 2,
+        assoc_laguerre: 2
+        }
+    integrand, symbol = integral
+    for klass in orthogonal_poly_classes:
+        if isinstance(integrand, klass):
+            var_index = orthogonal_poly_var_index.get(klass, 1)
+            if (integrand.args[var_index] is symbol and not
+                any(v.has(symbol) for v in integrand.args[:var_index])):
+                    return orthogonal_poly_classes[klass](integrand, symbol, *integrand.args[:var_index])
+
+
+_special_function_patterns: list[tuple[Type, Expr, Callable | None, tuple]] = []
+_wilds = []
+_symbol = Dummy('x')
+
+
+def special_function_rule(integral):
+    integrand, symbol = integral
+    if not _special_function_patterns:
+        a = Wild('a', exclude=[_symbol], properties=[lambda x: not x.is_zero])
+        b = Wild('b', exclude=[_symbol])
+        c = Wild('c', exclude=[_symbol])
+        d = Wild('d', exclude=[_symbol], properties=[lambda x: not x.is_zero])
+        e = Wild('e', exclude=[_symbol], properties=[
+            lambda x: not (x.is_nonnegative and x.is_integer)])
+        _wilds.extend((a, b, c, d, e))
+        # patterns consist of a SymPy class, a wildcard expr, an optional
+        # condition coded as a lambda (when Wild properties are not enough),
+        # followed by an applicable rule
+        linear_pattern = a*_symbol + b
+        quadratic_pattern = a*_symbol**2 + b*_symbol + c
+        _special_function_patterns.extend((
+            (Mul, exp(linear_pattern, evaluate=False)/_symbol, None, EiRule),
+            (Mul, cos(linear_pattern, evaluate=False)/_symbol, None, CiRule),
+            (Mul, cosh(linear_pattern, evaluate=False)/_symbol, None, ChiRule),
+            (Mul, sin(linear_pattern, evaluate=False)/_symbol, None, SiRule),
+            (Mul, sinh(linear_pattern, evaluate=False)/_symbol, None, ShiRule),
+            (Pow, 1/log(linear_pattern, evaluate=False), None, LiRule),
+            (exp, exp(quadratic_pattern, evaluate=False), None, ErfRule),
+            (sin, sin(quadratic_pattern, evaluate=False), None, FresnelSRule),
+            (cos, cos(quadratic_pattern, evaluate=False), None, FresnelCRule),
+            (Mul, _symbol**e*exp(a*_symbol, evaluate=False), None, UpperGammaRule),
+            (Mul, polylog(b, a*_symbol, evaluate=False)/_symbol, None, PolylogRule),
+            (Pow, 1/sqrt(a - d*sin(_symbol, evaluate=False)**2),
+                lambda a, d: a != d, EllipticFRule),
+            (Pow, sqrt(a - d*sin(_symbol, evaluate=False)**2),
+                lambda a, d: a != d, EllipticERule),
+        ))
+    _integrand = integrand.subs(symbol, _symbol)
+    for type_, pattern, constraint, rule in _special_function_patterns:
+        if isinstance(_integrand, type_):
+            match = _integrand.match(pattern)
+            if match:
+                wild_vals = tuple(match.get(w) for w in _wilds
+                                  if match.get(w) is not None)
+                if constraint is None or constraint(*wild_vals):
+                    return rule(integrand, symbol, *wild_vals)
+
+
+def _add_degenerate_step(generic_cond, generic_step: Rule, degenerate_step: Rule | None) -> Rule:
+    if degenerate_step is None:
+        return generic_step
+    if isinstance(generic_step, PiecewiseRule):
+        subfunctions = [(substep, (cond & generic_cond).simplify())
+                        for substep, cond in generic_step.subfunctions]
+    else:
+        subfunctions = [(generic_step, generic_cond)]
+    if isinstance(degenerate_step, PiecewiseRule):
+        subfunctions += degenerate_step.subfunctions
+    else:
+        subfunctions.append((degenerate_step, S.true))
+    return PiecewiseRule(generic_step.integrand, generic_step.variable, subfunctions)
+
+
+def nested_pow_rule(integral: IntegralInfo):
+    # nested (c*(a+b*x)**d)**e
+    integrand, x = integral
+
+    a_ = Wild('a', exclude=[x])
+    b_ = Wild('b', exclude=[x, 0])
+    pattern = a_+b_*x
+    generic_cond = S.true
+
+    class NoMatch(Exception):
+        pass
+
+    def _get_base_exp(expr: Expr) -> tuple[Expr, Expr]:
+        if not expr.has_free(x):
+            return S.One, S.Zero
+        if expr.is_Mul:
+            _, terms = expr.as_coeff_mul()
+            if not terms:
+                return S.One, S.Zero
+            results = [_get_base_exp(term) for term in terms]
+            bases = {b for b, _ in results}
+            bases.discard(S.One)
+            if len(bases) == 1:
+                return bases.pop(), Add(*(e for _, e in results))
+            raise NoMatch
+        if expr.is_Pow:
+            b, e = expr.base, expr.exp  # type: ignore
+            if e.has_free(x):
+                raise NoMatch
+            base_, sub_exp = _get_base_exp(b)
+            return base_, sub_exp * e
+        match = expr.match(pattern)
+        if match:
+            a, b = match[a_], match[b_]
+            base_ = x + a/b
+            nonlocal generic_cond
+            generic_cond = Ne(b, 0)
+            return base_, S.One
+        raise NoMatch
+
+    try:
+        base, exp_ = _get_base_exp(integrand)
+    except NoMatch:
+        return
+    if generic_cond is S.true:
+        degenerate_step = None
+    else:
+        # equivalent with subs(b, 0) but no need to find b
+        degenerate_step = ConstantRule(integrand.subs(x, 0), x)
+    generic_step = NestedPowRule(integrand, x, base, exp_)
+    return _add_degenerate_step(generic_cond, generic_step, degenerate_step)
+
+
+def inverse_trig_rule(integral: IntegralInfo, degenerate=True):
+    """
+    Set degenerate=False on recursive call where coefficient of quadratic term
+    is assumed non-zero.
+    """
+    integrand, symbol = integral
+    base, exp = integrand.as_base_exp()
+    a = Wild('a', exclude=[symbol])
+    b = Wild('b', exclude=[symbol])
+    c = Wild('c', exclude=[symbol, 0])
+    match = base.match(a + b*symbol + c*symbol**2)
+
+    if not match:
+        return
+
+    def make_inverse_trig(RuleClass, a, sign_a, c, sign_c, h) -> Rule:
+        u_var = Dummy("u")
+        rewritten = 1/sqrt(sign_a*a + sign_c*c*(symbol-h)**2)  # a>0, c>0
+        quadratic_base = sqrt(c/a)*(symbol-h)
+        constant = 1/sqrt(c)
+        u_func = None
+        if quadratic_base is not symbol:
+            u_func = quadratic_base
+            quadratic_base = u_var
+        standard_form = 1/sqrt(sign_a + sign_c*quadratic_base**2)
+        substep = RuleClass(standard_form, quadratic_base)
+        if constant != 1:
+            substep = ConstantTimesRule(constant*standard_form, symbol, constant, standard_form, substep)
+        if u_func is not None:
+            substep = URule(rewritten, symbol, u_var, u_func, substep)
+        if h != 0:
+            substep = CompleteSquareRule(integrand, symbol, rewritten, substep)
+        return substep
+
+    a, b, c = [match.get(i, S.Zero) for i in (a, b, c)]
+    generic_cond = Ne(c, 0)
+    if not degenerate or generic_cond is S.true:
+        degenerate_step = None
+    elif b.is_zero:
+        degenerate_step = ConstantRule(a ** exp, symbol)
+    else:
+        degenerate_step = sqrt_linear_rule(IntegralInfo((a + b * symbol) ** exp, symbol))
+
+    if simplify(2*exp + 1) == 0:
+        h, k = -b/(2*c), a - b**2/(4*c)  # rewrite base to k + c*(symbol-h)**2
+        non_square_cond = Ne(k, 0)
+        square_step = None
+        if non_square_cond is not S.true:
+            square_step = NestedPowRule(1/sqrt(c*(symbol-h)**2), symbol, symbol-h, S.NegativeOne)
+        if non_square_cond is S.false:
+            return square_step
+        generic_step = ReciprocalSqrtQuadraticRule(integrand, symbol, a, b, c)
+        step = _add_degenerate_step(non_square_cond, generic_step, square_step)
+        if k.is_real and c.is_real:
+            # list of ((rule, base_exp, a, sign_a, b, sign_b), condition)
+            rules = []
+            for args, cond in (  # don't apply ArccoshRule to x**2-1
+                ((ArcsinRule, k, 1, -c, -1, h), And(k > 0, c < 0)),  # 1-x**2
+                ((ArcsinhRule, k, 1, c, 1, h), And(k > 0, c > 0)),  # 1+x**2
+            ):
+                if cond is S.true:
+                    return make_inverse_trig(*args)
+                if cond is not S.false:
+                    rules.append((make_inverse_trig(*args), cond))
+            if rules:
+                if not k.is_positive:  # conditions are not thorough, need fall back rule
+                    rules.append((generic_step, S.true))
+                step = PiecewiseRule(integrand, symbol, rules)
+            else:
+                step = generic_step
+        return _add_degenerate_step(generic_cond, step, degenerate_step)
+    if exp == S.Half:
+        step = SqrtQuadraticRule(integrand, symbol, a, b, c)
+        return _add_degenerate_step(generic_cond, step, degenerate_step)
+
+
+def add_rule(integral):
+    integrand, symbol = integral
+    results = [integral_steps(g, symbol)
+              for g in integrand.as_ordered_terms()]
+    return None if None in results else AddRule(integrand, symbol, results)
+
+
+def mul_rule(integral: IntegralInfo):
+    integrand, symbol = integral
+
+    # Constant times function case
+    coeff, f = integrand.as_independent(symbol)
+    if coeff != 1:
+        next_step = integral_steps(f, symbol)
+        if next_step is not None:
+            return ConstantTimesRule(integrand, symbol, coeff, f, next_step)
+
+
+def _parts_rule(integrand, symbol) -> tuple[Expr, Expr, Expr, Expr, Rule] | None:
+    # LIATE rule:
+    # log, inverse trig, algebraic, trigonometric, exponential
+    def pull_out_algebraic(integrand):
+        integrand = integrand.cancel().together()
+        # iterating over Piecewise args would not work here
+        algebraic = ([] if isinstance(integrand, Piecewise) or not integrand.is_Mul
+            else [arg for arg in integrand.args if arg.is_algebraic_expr(symbol)])
+        if algebraic:
+            u = Mul(*algebraic)
+            dv = (integrand / u).cancel()
+            return u, dv
+
+    def pull_out_u(*functions) -> Callable[[Expr], tuple[Expr, Expr] | None]:
+        def pull_out_u_rl(integrand: Expr) -> tuple[Expr, Expr] | None:
+            if any(integrand.has(f) for f in functions):
+                args = [arg for arg in integrand.args
+                        if any(isinstance(arg, cls) for cls in functions)]
+                if args:
+                    u = Mul(*args) # type: ignore
+                    dv = integrand / u
+                    return u, dv
+            return None
+
+        return pull_out_u_rl
+
+    liate_rules = [pull_out_u(log), pull_out_u(*inverse_trig_functions),
+                   pull_out_algebraic, pull_out_u(sin, cos),
+                   pull_out_u(exp)]
+
+
+    dummy = Dummy("temporary")
+    # we can integrate log(x) and atan(x) by setting dv = 1
+    if isinstance(integrand, (log, *inverse_trig_functions)):
+        integrand = dummy * integrand
+
+    for index, rule in enumerate(liate_rules):
+        result = rule(integrand)
+
+        if result:
+            u, dv = result
+
+            # Don't pick u to be a constant if possible
+            if symbol not in u.free_symbols and not u.has(dummy):
+                return None
+
+            u = u.subs(dummy, 1)
+            dv = dv.subs(dummy, 1)
+
+            # Don't pick a non-polynomial algebraic to be differentiated
+            if rule == pull_out_algebraic and not u.is_polynomial(symbol):
+                return None
+            # Don't trade one logarithm for another
+            if isinstance(u, log):
+                rec_dv = 1/dv
+                if (rec_dv.is_polynomial(symbol) and
+                    degree(rec_dv, symbol) == 1):
+                    return None
+
+            # Can integrate a polynomial times OrthogonalPolynomial
+            if rule == pull_out_algebraic:
+                if dv.is_Derivative or dv.has(TrigonometricFunction) or \
+                        isinstance(dv, OrthogonalPolynomial):
+                    v_step = integral_steps(dv, symbol)
+                    if v_step.contains_dont_know():
+                        return None
+                    else:
+                        du = u.diff(symbol)
+                        v = v_step.eval()
+                        return u, dv, v, du, v_step
+
+            # make sure dv is amenable to integration
+            accept = False
+            if index < 2:  # log and inverse trig are usually worth trying
+                accept = True
+            elif (rule == pull_out_algebraic and dv.args and
+                all(isinstance(a, (sin, cos, exp))
+                for a in dv.args)):
+                    accept = True
+            else:
+                for lrule in liate_rules[index + 1:]:
+                    r = lrule(integrand)
+                    if r and r[0].subs(dummy, 1).equals(dv):
+                        accept = True
+                        break
+
+            if accept:
+                du = u.diff(symbol)
+                v_step = integral_steps(simplify(dv), symbol)
+                if not v_step.contains_dont_know():
+                    v = v_step.eval()
+                    return u, dv, v, du, v_step
+    return None
+
+
+def parts_rule(integral):
+    integrand, symbol = integral
+    constant, integrand = integrand.as_coeff_Mul()
+
+    result = _parts_rule(integrand, symbol)
+
+    steps = []
+    if result:
+        u, dv, v, du, v_step = result
+        debug("u : {}, dv : {}, v : {}, du : {}, v_step: {}".format(u, dv, v, du, v_step))
+        steps.append(result)
+
+        if isinstance(v, Integral):
+            return
+
+        # Set a limit on the number of times u can be used
+        if isinstance(u, (sin, cos, exp, sinh, cosh)):
+            cachekey = u.xreplace({symbol: _cache_dummy})
+            if _parts_u_cache[cachekey] > 2:
+                return
+            _parts_u_cache[cachekey] += 1
+
+        # Try cyclic integration by parts a few times
+        for _ in range(4):
+            debug("Cyclic integration {} with v: {}, du: {}, integrand: {}".format(_, v, du, integrand))
+            coefficient = ((v * du) / integrand).cancel()
+            if coefficient == 1:
+                break
+            if symbol not in coefficient.free_symbols:
+                rule = CyclicPartsRule(integrand, symbol,
+                    [PartsRule(None, None, u, dv, v_step, None)
+                     for (u, dv, v, du, v_step) in steps],
+                    (-1) ** len(steps) * coefficient)
+                if (constant != 1) and rule:
+                    rule = ConstantTimesRule(constant * integrand, symbol, constant, integrand, rule)
+                return rule
+
+            # _parts_rule is sensitive to constants, factor it out
+            next_constant, next_integrand = (v * du).as_coeff_Mul()
+            result = _parts_rule(next_integrand, symbol)
+
+            if result:
+                u, dv, v, du, v_step = result
+                u *= next_constant
+                du *= next_constant
+                steps.append((u, dv, v, du, v_step))
+            else:
+                break
+
+    def make_second_step(steps, integrand):
+        if steps:
+            u, dv, v, du, v_step = steps[0]
+            return PartsRule(integrand, symbol, u, dv, v_step, make_second_step(steps[1:], v * du))
+        return integral_steps(integrand, symbol)
+
+    if steps:
+        u, dv, v, du, v_step = steps[0]
+        rule = PartsRule(integrand, symbol, u, dv, v_step, make_second_step(steps[1:], v * du))
+        if (constant != 1) and rule:
+            rule = ConstantTimesRule(constant * integrand, symbol, constant, integrand, rule)
+        return rule
+
+
+def trig_rule(integral):
+    integrand, symbol = integral
+    if integrand == sin(symbol):
+        return SinRule(integrand, symbol)
+    if integrand == cos(symbol):
+        return CosRule(integrand, symbol)
+    if integrand == sec(symbol)**2:
+        return Sec2Rule(integrand, symbol)
+    if integrand == csc(symbol)**2:
+        return Csc2Rule(integrand, symbol)
+
+    if isinstance(integrand, tan):
+        rewritten = sin(*integrand.args) / cos(*integrand.args)
+    elif isinstance(integrand, cot):
+        rewritten = cos(*integrand.args) / sin(*integrand.args)
+    elif isinstance(integrand, sec):
+        arg = integrand.args[0]
+        rewritten = ((sec(arg)**2 + tan(arg) * sec(arg)) /
+                     (sec(arg) + tan(arg)))
+    elif isinstance(integrand, csc):
+        arg = integrand.args[0]
+        rewritten = ((csc(arg)**2 + cot(arg) * csc(arg)) /
+                     (csc(arg) + cot(arg)))
+    else:
+        return
+
+    return RewriteRule(integrand, symbol, rewritten, integral_steps(rewritten, symbol))
+
+def trig_product_rule(integral: IntegralInfo):
+    integrand, symbol = integral
+    if integrand == sec(symbol) * tan(symbol):
+        return SecTanRule(integrand, symbol)
+    if integrand == csc(symbol) * cot(symbol):
+        return CscCotRule(integrand, symbol)
+
+
+def quadratic_denom_rule(integral):
+    integrand, symbol = integral
+    a = Wild('a', exclude=[symbol])
+    b = Wild('b', exclude=[symbol])
+    c = Wild('c', exclude=[symbol])
+
+    match = integrand.match(a / (b * symbol ** 2 + c))
+
+    if match:
+        a, b, c = match[a], match[b], match[c]
+        general_rule = ArctanRule(integrand, symbol, a, b, c)
+        if b.is_extended_real and c.is_extended_real:
+            positive_cond = c/b > 0
+            if positive_cond is S.true:
+                return general_rule
+            coeff = a/(2*sqrt(-c)*sqrt(b))
+            constant = sqrt(-c/b)
+            r1 = 1/(symbol-constant)
+            r2 = 1/(symbol+constant)
+            log_steps = [ReciprocalRule(r1, symbol, symbol-constant),
+                         ConstantTimesRule(-r2, symbol, -1, r2, ReciprocalRule(r2, symbol, symbol+constant))]
+            rewritten = sub = r1 - r2
+            negative_step = AddRule(sub, symbol, log_steps)
+            if coeff != 1:
+                rewritten = Mul(coeff, sub, evaluate=False)
+                negative_step = ConstantTimesRule(rewritten, symbol, coeff, sub, negative_step)
+            negative_step = RewriteRule(integrand, symbol, rewritten, negative_step)
+            if positive_cond is S.false:
+                return negative_step
+            return PiecewiseRule(integrand, symbol, [(general_rule, positive_cond), (negative_step, S.true)])
+
+        power = PowerRule(integrand, symbol, symbol, -2)
+        if b != 1:
+            power = ConstantTimesRule(integrand, symbol, 1/b, symbol**-2, power)
+
+        return PiecewiseRule(integrand, symbol, [(general_rule, Ne(c, 0)), (power, True)])
+
+    d = Wild('d', exclude=[symbol])
+    match2 = integrand.match(a / (b * symbol ** 2 + c * symbol + d))
+    if match2:
+        b, c =  match2[b], match2[c]
+        if b.is_zero:
+            return
+        u = Dummy('u')
+        u_func = symbol + c/(2*b)
+        integrand2 = integrand.subs(symbol, u - c / (2*b))
+        next_step = integral_steps(integrand2, u)
+        if next_step:
+            return URule(integrand2, symbol, u, u_func, next_step)
+        else:
+            return
+    e = Wild('e', exclude=[symbol])
+    match3 = integrand.match((a* symbol + b) / (c * symbol ** 2 + d * symbol + e))
+    if match3:
+        a, b, c, d, e = match3[a], match3[b], match3[c], match3[d], match3[e]
+        if c.is_zero:
+            return
+        denominator = c * symbol**2 + d * symbol + e
+        const =  a/(2*c)
+        numer1 =  (2*c*symbol+d)
+        numer2 = - const*d + b
+        u = Dummy('u')
+        step1 = URule(integrand, symbol,
+                      u, denominator, integral_steps(u**(-1), u))
+        if const != 1:
+            step1 = ConstantTimesRule(const*numer1/denominator, symbol,
+                                      const, numer1/denominator, step1)
+        if numer2.is_zero:
+            return step1
+        step2 = integral_steps(numer2/denominator, symbol)
+        substeps = AddRule(integrand, symbol, [step1, step2])
+        rewriten = const*numer1/denominator+numer2/denominator
+        return RewriteRule(integrand, symbol, rewriten, substeps)
+
+    return
+
+
+def sqrt_linear_rule(integral: IntegralInfo):
+    """
+    Substitute common (a+b*x)**(1/n)
+    """
+    integrand, x = integral
+    a = Wild('a', exclude=[x])
+    b = Wild('b', exclude=[x, 0])
+    a0 = b0 = 0
+    bases, qs, bs = [], [], []
+    for pow_ in integrand.find(Pow):  # collect all (a+b*x)**(p/q)
+        base, exp_ = pow_.base, pow_.exp
+        if exp_.is_Integer or x not in base.free_symbols:  # skip 1/x and sqrt(2)
+            continue
+        if not exp_.is_Rational:  # exclude x**pi
+            return
+        match = base.match(a+b*x)
+        if not match:  # skip non-linear
+            continue  # for sqrt(x+sqrt(x)), although base is non-linear, we can still substitute sqrt(x)
+        a1, b1 = match[a], match[b]
+        if a0*b1 != a1*b0 or not (b0/b1).is_nonnegative:  # cannot transform sqrt(x) to sqrt(x+1) or sqrt(-x)
+            return
+        if b0 == 0 or (b0/b1 > 1) is S.true:  # choose the latter of sqrt(2*x) and sqrt(x) as representative
+            a0, b0 = a1, b1
+        bases.append(base)
+        bs.append(b1)
+        qs.append(exp_.q)
+    if b0 == 0:  # no such pattern found
+        return
+    q0: Integer = lcm_list(qs)
+    u_x = (a0 + b0*x)**(1/q0)
+    u = Dummy("u")
+    substituted = integrand.subs({base**(S.One/q): (b/b0)**(S.One/q)*u**(q0/q)
+                                  for base, b, q in zip(bases, bs, qs)}).subs(x, (u**q0-a0)/b0)
+    substep = integral_steps(substituted*u**(q0-1)*q0/b0, u)
+    if not substep.contains_dont_know():
+        step: Rule = URule(integrand, x, u, u_x, substep)
+        generic_cond = Ne(b0, 0)
+        if generic_cond is not S.true:  # possible degenerate case
+            simplified = integrand.subs(dict.fromkeys(bs, 0))
+            degenerate_step = integral_steps(simplified, x)
+            step = PiecewiseRule(integrand, x, [(step, generic_cond), (degenerate_step, S.true)])
+        return step
+
+
+def sqrt_quadratic_rule(integral: IntegralInfo, degenerate=True):
+    integrand, x = integral
+    a = Wild('a', exclude=[x])
+    b = Wild('b', exclude=[x])
+    c = Wild('c', exclude=[x, 0])
+    f = Wild('f')
+    n = Wild('n', properties=[lambda n: n.is_Integer and n.is_odd])
+    match = integrand.match(f*sqrt(a+b*x+c*x**2)**n)
+    if not match:
+        return
+    a, b, c, f, n = match[a], match[b], match[c], match[f], match[n]
+    f_poly = f.as_poly(x)
+    if f_poly is None:
+        return
+
+    generic_cond = Ne(c, 0)
+    if not degenerate or generic_cond is S.true:
+        degenerate_step = None
+    elif b.is_zero:
+        degenerate_step = integral_steps(f*sqrt(a)**n, x)
+    else:
+        degenerate_step = sqrt_linear_rule(IntegralInfo(f*sqrt(a+b*x)**n, x))
+
+    def sqrt_quadratic_denom_rule(numer_poly: Poly, integrand: Expr):
+        denom = sqrt(a+b*x+c*x**2)
+        deg = numer_poly.degree()
+        if deg <= 1:
+            # integrand == (d+e*x)/sqrt(a+b*x+c*x**2)
+            e, d = numer_poly.all_coeffs() if deg == 1 else (S.Zero, numer_poly.as_expr())
+            # rewrite numerator to A*(2*c*x+b) + B
+            A = e/(2*c)
+            B = d-A*b
+            pre_substitute = (2*c*x+b)/denom
+            constant_step: Rule | None = None
+            linear_step: Rule | None = None
+            if A != 0:
+                u = Dummy("u")
+                pow_rule = PowerRule(1/sqrt(u), u, u, -S.Half)
+                linear_step = URule(pre_substitute, x, u, a+b*x+c*x**2, pow_rule)
+                if A != 1:
+                    linear_step = ConstantTimesRule(A*pre_substitute, x, A, pre_substitute, linear_step)
+            if B != 0:
+                constant_step = inverse_trig_rule(IntegralInfo(1/denom, x), degenerate=False)
+                if B != 1:
+                    constant_step = ConstantTimesRule(B/denom, x, B, 1/denom, constant_step)  # type: ignore
+            if linear_step and constant_step:
+                add = Add(A*pre_substitute, B/denom, evaluate=False)
+                step: Rule | None = RewriteRule(integrand, x, add, AddRule(add, x, [linear_step, constant_step]))
+            else:
+                step = linear_step or constant_step
+        else:
+            coeffs = numer_poly.all_coeffs()
+            step = SqrtQuadraticDenomRule(integrand, x, a, b, c, coeffs)
+        return step
+
+    if n > 0:  # rewrite poly * sqrt(s)**(2*k-1) to poly*s**k / sqrt(s)
+        numer_poly = f_poly * (a+b*x+c*x**2)**((n+1)/2)
+        rewritten = numer_poly.as_expr()/sqrt(a+b*x+c*x**2)
+        substep = sqrt_quadratic_denom_rule(numer_poly, rewritten)
+        generic_step = RewriteRule(integrand, x, rewritten, substep)
+    elif n == -1:
+        generic_step = sqrt_quadratic_denom_rule(f_poly, integrand)
+    else:
+        return  # todo: handle n < -1 case
+    return _add_degenerate_step(generic_cond, generic_step, degenerate_step)
+
+
+def hyperbolic_rule(integral: tuple[Expr, Symbol]):
+    integrand, symbol = integral
+    if isinstance(integrand, HyperbolicFunction) and integrand.args[0] == symbol:
+        if integrand.func == sinh:
+            return SinhRule(integrand, symbol)
+        if integrand.func == cosh:
+            return CoshRule(integrand, symbol)
+        u = Dummy('u')
+        if integrand.func == tanh:
+            rewritten = sinh(symbol)/cosh(symbol)
+            return RewriteRule(integrand, symbol, rewritten,
+                   URule(rewritten, symbol, u, cosh(symbol), ReciprocalRule(1/u, u, u)))
+        if integrand.func == coth:
+            rewritten = cosh(symbol)/sinh(symbol)
+            return RewriteRule(integrand, symbol, rewritten,
+                   URule(rewritten, symbol, u, sinh(symbol), ReciprocalRule(1/u, u, u)))
+        else:
+            rewritten = integrand.rewrite(tanh)
+            if integrand.func == sech:
+                return RewriteRule(integrand, symbol, rewritten,
+                       URule(rewritten, symbol, u, tanh(symbol/2),
+                       ArctanRule(2/(u**2 + 1), u, S(2), S.One, S.One)))
+            if integrand.func == csch:
+                return RewriteRule(integrand, symbol, rewritten,
+                       URule(rewritten, symbol, u, tanh(symbol/2),
+                       ReciprocalRule(1/u, u, u)))
+
+@cacheit
+def make_wilds(symbol):
+    a = Wild('a', exclude=[symbol])
+    b = Wild('b', exclude=[symbol])
+    m = Wild('m', exclude=[symbol], properties=[lambda n: isinstance(n, Integer)])
+    n = Wild('n', exclude=[symbol], properties=[lambda n: isinstance(n, Integer)])
+
+    return a, b, m, n
+
+@cacheit
+def sincos_pattern(symbol):
+    a, b, m, n = make_wilds(symbol)
+    pattern = sin(a*symbol)**m * cos(b*symbol)**n
+
+    return pattern, a, b, m, n
+
+@cacheit
+def tansec_pattern(symbol):
+    a, b, m, n = make_wilds(symbol)
+    pattern = tan(a*symbol)**m * sec(b*symbol)**n
+
+    return pattern, a, b, m, n
+
+@cacheit
+def cotcsc_pattern(symbol):
+    a, b, m, n = make_wilds(symbol)
+    pattern = cot(a*symbol)**m * csc(b*symbol)**n
+
+    return pattern, a, b, m, n
+
+@cacheit
+def heaviside_pattern(symbol):
+    m = Wild('m', exclude=[symbol])
+    b = Wild('b', exclude=[symbol])
+    g = Wild('g')
+    pattern = Heaviside(m*symbol + b) * g
+
+    return pattern, m, b, g
+
+def uncurry(func):
+    def uncurry_rl(args):
+        return func(*args)
+    return uncurry_rl
+
+def trig_rewriter(rewrite):
+    def trig_rewriter_rl(args):
+        a, b, m, n, integrand, symbol = args
+        rewritten = rewrite(a, b, m, n, integrand, symbol)
+        if rewritten != integrand:
+            return RewriteRule(integrand, symbol, rewritten, integral_steps(rewritten, symbol))
+    return trig_rewriter_rl
+
+sincos_botheven_condition = uncurry(
+    lambda a, b, m, n, i, s: m.is_even and n.is_even and
+    m.is_nonnegative and n.is_nonnegative)
+
+sincos_botheven = trig_rewriter(
+    lambda a, b, m, n, i, symbol: ( (((1 - cos(2*a*symbol)) / 2) ** (m / 2)) *
+                                    (((1 + cos(2*b*symbol)) / 2) ** (n / 2)) ))
+
+sincos_sinodd_condition = uncurry(lambda a, b, m, n, i, s: m.is_odd and m >= 3)
+
+sincos_sinodd = trig_rewriter(
+    lambda a, b, m, n, i, symbol: ( (1 - cos(a*symbol)**2)**((m - 1) / 2) *
+                                    sin(a*symbol) *
+                                    cos(b*symbol) ** n))
+
+sincos_cosodd_condition = uncurry(lambda a, b, m, n, i, s: n.is_odd and n >= 3)
+
+sincos_cosodd = trig_rewriter(
+    lambda a, b, m, n, i, symbol: ( (1 - sin(b*symbol)**2)**((n - 1) / 2) *
+                                    cos(b*symbol) *
+                                    sin(a*symbol) ** m))
+
+tansec_seceven_condition = uncurry(lambda a, b, m, n, i, s: n.is_even and n >= 4)
+tansec_seceven = trig_rewriter(
+    lambda a, b, m, n, i, symbol: ( (1 + tan(b*symbol)**2) ** (n/2 - 1) *
+                                    sec(b*symbol)**2 *
+                                    tan(a*symbol) ** m ))
+
+tansec_tanodd_condition = uncurry(lambda a, b, m, n, i, s: m.is_odd)
+tansec_tanodd = trig_rewriter(
+    lambda a, b, m, n, i, symbol: ( (sec(a*symbol)**2 - 1) ** ((m - 1) / 2) *
+                                     tan(a*symbol) *
+                                     sec(b*symbol) ** n ))
+
+tan_tansquared_condition = uncurry(lambda a, b, m, n, i, s: m == 2 and n == 0)
+tan_tansquared = trig_rewriter(
+    lambda a, b, m, n, i, symbol: ( sec(a*symbol)**2 - 1))
+
+cotcsc_csceven_condition = uncurry(lambda a, b, m, n, i, s: n.is_even and n >= 4)
+cotcsc_csceven = trig_rewriter(
+    lambda a, b, m, n, i, symbol: ( (1 + cot(b*symbol)**2) ** (n/2 - 1) *
+                                    csc(b*symbol)**2 *
+                                    cot(a*symbol) ** m ))
+
+cotcsc_cotodd_condition = uncurry(lambda a, b, m, n, i, s: m.is_odd)
+cotcsc_cotodd = trig_rewriter(
+    lambda a, b, m, n, i, symbol: ( (csc(a*symbol)**2 - 1) ** ((m - 1) / 2) *
+                                    cot(a*symbol) *
+                                    csc(b*symbol) ** n ))
+
+def trig_sincos_rule(integral):
+    integrand, symbol = integral
+
+    if any(integrand.has(f) for f in (sin, cos)):
+        pattern, a, b, m, n = sincos_pattern(symbol)
+        match = integrand.match(pattern)
+        if not match:
+            return
+
+        return multiplexer({
+            sincos_botheven_condition: sincos_botheven,
+            sincos_sinodd_condition: sincos_sinodd,
+            sincos_cosodd_condition: sincos_cosodd
+        })(tuple(
+            [match.get(i, S.Zero) for i in (a, b, m, n)] +
+            [integrand, symbol]))
+
+def trig_tansec_rule(integral):
+    integrand, symbol = integral
+
+    integrand = integrand.subs({
+        1 / cos(symbol): sec(symbol)
+    })
+
+    if any(integrand.has(f) for f in (tan, sec)):
+        pattern, a, b, m, n = tansec_pattern(symbol)
+        match = integrand.match(pattern)
+        if not match:
+            return
+
+        return multiplexer({
+            tansec_tanodd_condition: tansec_tanodd,
+            tansec_seceven_condition: tansec_seceven,
+            tan_tansquared_condition: tan_tansquared
+        })(tuple(
+            [match.get(i, S.Zero) for i in (a, b, m, n)] +
+            [integrand, symbol]))
+
+def trig_cotcsc_rule(integral):
+    integrand, symbol = integral
+    integrand = integrand.subs({
+        1 / sin(symbol): csc(symbol),
+        1 / tan(symbol): cot(symbol),
+        cos(symbol) / tan(symbol): cot(symbol)
+    })
+
+    if any(integrand.has(f) for f in (cot, csc)):
+        pattern, a, b, m, n = cotcsc_pattern(symbol)
+        match = integrand.match(pattern)
+        if not match:
+            return
+
+        return multiplexer({
+            cotcsc_cotodd_condition: cotcsc_cotodd,
+            cotcsc_csceven_condition: cotcsc_csceven
+        })(tuple(
+            [match.get(i, S.Zero) for i in (a, b, m, n)] +
+            [integrand, symbol]))
+
+def trig_sindouble_rule(integral):
+    integrand, symbol = integral
+    a = Wild('a', exclude=[sin(2*symbol)])
+    match = integrand.match(sin(2*symbol)*a)
+    if match:
+        sin_double = 2*sin(symbol)*cos(symbol)/sin(2*symbol)
+        return integral_steps(integrand * sin_double, symbol)
+
+def trig_powers_products_rule(integral):
+    return do_one(null_safe(trig_sincos_rule),
+                  null_safe(trig_tansec_rule),
+                  null_safe(trig_cotcsc_rule),
+                  null_safe(trig_sindouble_rule))(integral)
+
+def trig_substitution_rule(integral):
+    integrand, symbol = integral
+    A = Wild('a', exclude=[0, symbol])
+    B = Wild('b', exclude=[0, symbol])
+    theta = Dummy("theta")
+    target_pattern = A + B*symbol**2
+
+    matches = integrand.find(target_pattern)
+    for expr in matches:
+        match = expr.match(target_pattern)
+        a = match.get(A, S.Zero)
+        b = match.get(B, S.Zero)
+
+        a_positive = ((a.is_number and a > 0) or a.is_positive)
+        b_positive = ((b.is_number and b > 0) or b.is_positive)
+        a_negative = ((a.is_number and a < 0) or a.is_negative)
+        b_negative = ((b.is_number and b < 0) or b.is_negative)
+        x_func = None
+        if a_positive and b_positive:
+            # a**2 + b*x**2. Assume sec(theta) > 0, -pi/2 < theta < pi/2
+            x_func = (sqrt(a)/sqrt(b)) * tan(theta)
+            # Do not restrict the domain: tan(theta) takes on any real
+            # value on the interval -pi/2 < theta < pi/2 so x takes on
+            # any value
+            restriction = True
+        elif a_positive and b_negative:
+            # a**2 - b*x**2. Assume cos(theta) > 0, -pi/2 < theta < pi/2
+            constant = sqrt(a)/sqrt(-b)
+            x_func = constant * sin(theta)
+            restriction = And(symbol > -constant, symbol < constant)
+        elif a_negative and b_positive:
+            # b*x**2 - a**2. Assume sin(theta) > 0, 0 < theta < pi
+            constant = sqrt(-a)/sqrt(b)
+            x_func = constant * sec(theta)
+            restriction = And(symbol > -constant, symbol < constant)
+        if x_func:
+            # Manually simplify sqrt(trig(theta)**2) to trig(theta)
+            # Valid due to assumed domain restriction
+            substitutions = {}
+            for f in [sin, cos, tan,
+                      sec, csc, cot]:
+                substitutions[sqrt(f(theta)**2)] = f(theta)
+                substitutions[sqrt(f(theta)**(-2))] = 1/f(theta)
+
+            replaced = integrand.subs(symbol, x_func).trigsimp()
+            replaced = manual_subs(replaced, substitutions)
+            if not replaced.has(symbol):
+                replaced *= manual_diff(x_func, theta)
+                replaced = replaced.trigsimp()
+                secants = replaced.find(1/cos(theta))
+                if secants:
+                    replaced = replaced.xreplace({
+                        1/cos(theta): sec(theta)
+                    })
+
+                substep = integral_steps(replaced, theta)
+                if not substep.contains_dont_know():
+                    return TrigSubstitutionRule(integrand, symbol,
+                        theta, x_func, replaced, substep, restriction)
+
+def heaviside_rule(integral):
+    integrand, symbol = integral
+    pattern, m, b, g = heaviside_pattern(symbol)
+    match = integrand.match(pattern)
+    if match and 0 != match[g]:
+        # f = Heaviside(m*x + b)*g
+        substep = integral_steps(match[g], symbol)
+        m, b = match[m], match[b]
+        return HeavisideRule(integrand, symbol, m*symbol + b, -b/m, substep)
+
+
+def dirac_delta_rule(integral: IntegralInfo):
+    integrand, x = integral
+    if len(integrand.args) == 1:
+        n = S.Zero
+    else:
+        n = integrand.args[1] # type: ignore
+    if not n.is_Integer or n < 0:
+        return
+    a, b = Wild('a', exclude=[x]), Wild('b', exclude=[x, 0])
+    match = integrand.args[0].match(a+b*x)
+    if not match:
+        return
+    a, b = match[a], match[b]
+    generic_cond = Ne(b, 0)
+    if generic_cond is S.true:
+        degenerate_step = None
+    else:
+        degenerate_step = ConstantRule(DiracDelta(a, n), x)
+    generic_step = DiracDeltaRule(integrand, x, n, a, b)
+    return _add_degenerate_step(generic_cond, generic_step, degenerate_step)
+
+
+def substitution_rule(integral):
+    integrand, symbol = integral
+
+    u_var = Dummy("u")
+    substitutions = find_substitutions(integrand, symbol, u_var)
+    count = 0
+    if substitutions:
+        debug("List of Substitution Rules")
+        ways = []
+        for u_func, c, substituted in substitutions:
+            subrule = integral_steps(substituted, u_var)
+            count = count + 1
+            debug("Rule {}: {}".format(count, subrule))
+
+            if subrule.contains_dont_know():
+                continue
+
+            if simplify(c - 1) != 0:
+                _, denom = c.as_numer_denom()
+                if subrule:
+                    subrule = ConstantTimesRule(c * substituted, u_var, c, substituted, subrule)
+
+                if denom.free_symbols:
+                    piecewise = []
+                    could_be_zero = []
+
+                    if isinstance(denom, Mul):
+                        could_be_zero = denom.args
+                    else:
+                        could_be_zero.append(denom)
+
+                    for expr in could_be_zero:
+                        if not fuzzy_not(expr.is_zero):
+                            substep = integral_steps(manual_subs(integrand, expr, 0), symbol)
+
+                            if substep:
+                                piecewise.append((
+                                    substep,
+                                    Eq(expr, 0)
+                                ))
+                    piecewise.append((subrule, True))
+                    subrule = PiecewiseRule(substituted, symbol, piecewise)
+
+            ways.append(URule(integrand, symbol, u_var, u_func, subrule))
+
+        if len(ways) > 1:
+            return AlternativeRule(integrand, symbol, ways)
+        elif ways:
+            return ways[0]
+
+
+partial_fractions_rule = rewriter(
+    lambda integrand, symbol: integrand.is_rational_function(),
+    lambda integrand, symbol: integrand.apart(symbol))
+
+cancel_rule = rewriter(
+    # lambda integrand, symbol: integrand.is_algebraic_expr(),
+    # lambda integrand, symbol: isinstance(integrand, Mul),
+    lambda integrand, symbol: True,
+    lambda integrand, symbol: integrand.cancel())
+
+distribute_expand_rule = rewriter(
+    lambda integrand, symbol: (
+        isinstance(integrand, (Pow, Mul)) or all(arg.is_Pow or arg.is_polynomial(symbol) for arg in integrand.args)),
+    lambda integrand, symbol: integrand.expand())
+
+trig_expand_rule = rewriter(
+    # If there are trig functions with different arguments, expand them
+    lambda integrand, symbol: (
+        len({a.args[0] for a in integrand.atoms(TrigonometricFunction)}) > 1),
+    lambda integrand, symbol: integrand.expand(trig=True))
+
+def derivative_rule(integral):
+    integrand = integral[0]
+    diff_variables = integrand.variables
+    undifferentiated_function = integrand.expr
+    integrand_variables = undifferentiated_function.free_symbols
+
+    if integral.symbol in integrand_variables:
+        if integral.symbol in diff_variables:
+            return DerivativeRule(*integral)
+        else:
+            return DontKnowRule(integrand, integral.symbol)
+    else:
+        return ConstantRule(*integral)
+
+def rewrites_rule(integral):
+    integrand, symbol = integral
+
+    if integrand.match(1/cos(symbol)):
+        rewritten = integrand.subs(1/cos(symbol), sec(symbol))
+        return RewriteRule(integrand, symbol, rewritten, integral_steps(rewritten, symbol))
+
+def fallback_rule(integral):
+    return DontKnowRule(*integral)
+
+# Cache is used to break cyclic integrals.
+# Need to use the same dummy variable in cached expressions for them to match.
+# Also record "u" of integration by parts, to avoid infinite repetition.
+_integral_cache: dict[Expr, Expr | None] = {}
+_parts_u_cache: dict[Expr, int] = defaultdict(int)
+_cache_dummy = Dummy("z")
+
+def integral_steps(integrand, symbol, **options):
+    """Returns the steps needed to compute an integral.
+
+    Explanation
+    ===========
+
+    This function attempts to mirror what a student would do by hand as
+    closely as possible.
+
+    SymPy Gamma uses this to provide a step-by-step explanation of an
+    integral. The code it uses to format the results of this function can be
+    found at
+    https://github.com/sympy/sympy_gamma/blob/master/app/logic/intsteps.py.
+
+    Examples
+    ========
+
+    >>> from sympy import exp, sin
+    >>> from sympy.integrals.manualintegrate import integral_steps
+    >>> from sympy.abc import x
+    >>> print(repr(integral_steps(exp(x) / (1 + exp(2 * x)), x))) \
+    # doctest: +NORMALIZE_WHITESPACE
+    URule(integrand=exp(x)/(exp(2*x) + 1), variable=x, u_var=_u, u_func=exp(x),
+    substep=ArctanRule(integrand=1/(_u**2 + 1), variable=_u, a=1, b=1, c=1))
+    >>> print(repr(integral_steps(sin(x), x))) \
+    # doctest: +NORMALIZE_WHITESPACE
+    SinRule(integrand=sin(x), variable=x)
+    >>> print(repr(integral_steps((x**2 + 3)**2, x))) \
+    # doctest: +NORMALIZE_WHITESPACE
+    RewriteRule(integrand=(x**2 + 3)**2, variable=x, rewritten=x**4 + 6*x**2 + 9,
+    substep=AddRule(integrand=x**4 + 6*x**2 + 9, variable=x,
+    substeps=[PowerRule(integrand=x**4, variable=x, base=x, exp=4),
+    ConstantTimesRule(integrand=6*x**2, variable=x, constant=6, other=x**2,
+    substep=PowerRule(integrand=x**2, variable=x, base=x, exp=2)),
+    ConstantRule(integrand=9, variable=x)]))
+
+    Returns
+    =======
+
+    rule : Rule
+        The first step; most rules have substeps that must also be
+        considered. These substeps can be evaluated using ``manualintegrate``
+        to obtain a result.
+
+    """
+    cachekey = integrand.xreplace({symbol: _cache_dummy})
+    if cachekey in _integral_cache:
+        if _integral_cache[cachekey] is None:
+            # Stop this attempt, because it leads around in a loop
+            return DontKnowRule(integrand, symbol)
+        else:
+            # TODO: This is for future development, as currently
+            # _integral_cache gets no values other than None
+            return (_integral_cache[cachekey].xreplace(_cache_dummy, symbol),
+                symbol)
+    else:
+        _integral_cache[cachekey] = None
+
+    integral = IntegralInfo(integrand, symbol)
+
+    def key(integral):
+        integrand = integral.integrand
+
+        if symbol not in integrand.free_symbols:
+            return Number
+        for cls in (Symbol, TrigonometricFunction, OrthogonalPolynomial):
+            if isinstance(integrand, cls):
+                return cls
+        return type(integrand)
+
+    def integral_is_subclass(*klasses):
+        def _integral_is_subclass(integral):
+            k = key(integral)
+            return k and issubclass(k, klasses)
+        return _integral_is_subclass
+
+    result = do_one(
+        null_safe(special_function_rule),
+        null_safe(switch(key, {
+            Pow: do_one(null_safe(power_rule), null_safe(inverse_trig_rule),
+                        null_safe(sqrt_linear_rule),
+                        null_safe(quadratic_denom_rule)),
+            Symbol: power_rule,
+            exp: exp_rule,
+            Add: add_rule,
+            Mul: do_one(null_safe(mul_rule), null_safe(trig_product_rule),
+                        null_safe(heaviside_rule), null_safe(quadratic_denom_rule),
+                        null_safe(sqrt_linear_rule),
+                        null_safe(sqrt_quadratic_rule)),
+            Derivative: derivative_rule,
+            TrigonometricFunction: trig_rule,
+            Heaviside: heaviside_rule,
+            DiracDelta: dirac_delta_rule,
+            OrthogonalPolynomial: orthogonal_poly_rule,
+            Number: constant_rule
+        })),
+        do_one(
+            null_safe(trig_rule),
+            null_safe(hyperbolic_rule),
+            null_safe(alternatives(
+                rewrites_rule,
+                substitution_rule,
+                condition(
+                    integral_is_subclass(Mul, Pow),
+                    partial_fractions_rule),
+                condition(
+                    integral_is_subclass(Mul, Pow),
+                    cancel_rule),
+                condition(
+                    integral_is_subclass(Mul, log,
+                    *inverse_trig_functions),
+                    parts_rule),
+                condition(
+                    integral_is_subclass(Mul, Pow),
+                    distribute_expand_rule),
+                trig_powers_products_rule,
+                trig_expand_rule
+            )),
+            null_safe(condition(integral_is_subclass(Mul, Pow), nested_pow_rule)),
+            null_safe(trig_substitution_rule)
+        ),
+        fallback_rule)(integral)
+    del _integral_cache[cachekey]
+    return result
+
+
+def manualintegrate(f, var):
+    """manualintegrate(f, var)
+
+    Explanation
+    ===========
+
+    Compute indefinite integral of a single variable using an algorithm that
+    resembles what a student would do by hand.
+
+    Unlike :func:`~.integrate`, var can only be a single symbol.
+
+    Examples
+    ========
+
+    >>> from sympy import sin, cos, tan, exp, log, integrate
+    >>> from sympy.integrals.manualintegrate import manualintegrate
+    >>> from sympy.abc import x
+    >>> manualintegrate(1 / x, x)
+    log(x)
+    >>> integrate(1/x)
+    log(x)
+    >>> manualintegrate(log(x), x)
+    x*log(x) - x
+    >>> integrate(log(x))
+    x*log(x) - x
+    >>> manualintegrate(exp(x) / (1 + exp(2 * x)), x)
+    atan(exp(x))
+    >>> integrate(exp(x) / (1 + exp(2 * x)))
+    RootSum(4*_z**2 + 1, Lambda(_i, _i*log(2*_i + exp(x))))
+    >>> manualintegrate(cos(x)**4 * sin(x), x)
+    -cos(x)**5/5
+    >>> integrate(cos(x)**4 * sin(x), x)
+    -cos(x)**5/5
+    >>> manualintegrate(cos(x)**4 * sin(x)**3, x)
+    cos(x)**7/7 - cos(x)**5/5
+    >>> integrate(cos(x)**4 * sin(x)**3, x)
+    cos(x)**7/7 - cos(x)**5/5
+    >>> manualintegrate(tan(x), x)
+    -log(cos(x))
+    >>> integrate(tan(x), x)
+    -log(cos(x))
+
+    See Also
+    ========
+
+    sympy.integrals.integrals.integrate
+    sympy.integrals.integrals.Integral.doit
+    sympy.integrals.integrals.Integral
+    """
+    result = integral_steps(f, var).eval()
+    # Clear the cache of u-parts
+    _parts_u_cache.clear()
+    # If we got Piecewise with two parts, put generic first
+    if isinstance(result, Piecewise) and len(result.args) == 2:
+        cond = result.args[0][1]
+        if isinstance(cond, Eq) and result.args[1][1] == True:
+            result = result.func(
+                (result.args[1][0], Ne(*cond.args)),
+                (result.args[0][0], True))
+    return result

.venv/lib/python3.12/site-packages/sympy/integrals/meijerint.py

@@ -0,0 +1,2191 @@
+"""
+Integrate functions by rewriting them as Meijer G-functions.
+
+There are three user-visible functions that can be used by other parts of the
+sympy library to solve various integration problems:
+
+- meijerint_indefinite
+- meijerint_definite
+- meijerint_inversion
+
+They can be used to compute, respectively, indefinite integrals, definite
+integrals over intervals of the real line, and inverse laplace-type integrals
+(from c-I*oo to c+I*oo). See the respective docstrings for details.
+
+The main references for this are:
+
+[L] Luke, Y. L. (1969), The Special Functions and Their Approximations,
+    Volume 1
+
+[R] Kelly B. Roach.  Meijer G Function Representations.
+    In: Proceedings of the 1997 International Symposium on Symbolic and
+    Algebraic Computation, pages 205-211, New York, 1997. ACM.
+
+[P] A. P. Prudnikov, Yu. A. Brychkov and O. I. Marichev (1990).
+    Integrals and Series: More Special Functions, Vol. 3,.
+    Gordon and Breach Science Publisher
+"""
+
+from __future__ import annotations
+import itertools
+
+from sympy import SYMPY_DEBUG
+from sympy.core import S, Expr
+from sympy.core.add import Add
+from sympy.core.basic import Basic
+from sympy.core.cache import cacheit
+from sympy.core.containers import Tuple
+from sympy.core.exprtools import factor_terms
+from sympy.core.function import (expand, expand_mul, expand_power_base,
+                                 expand_trig, Function)
+from sympy.core.mul import Mul
+from sympy.core.intfunc import ilcm
+from sympy.core.numbers import Rational, pi
+from sympy.core.relational import Eq, Ne, _canonical_coeff
+from sympy.core.sorting import default_sort_key, ordered
+from sympy.core.symbol import Dummy, symbols, Wild, Symbol
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.complexes import (re, im, arg, Abs, sign,
+        unpolarify, polarify, polar_lift, principal_branch, unbranched_argument,
+        periodic_argument)
+from sympy.functions.elementary.exponential import exp, exp_polar, log
+from sympy.functions.elementary.integers import ceiling
+from sympy.functions.elementary.hyperbolic import (cosh, sinh,
+        _rewrite_hyperbolics_as_exp, HyperbolicFunction)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise, piecewise_fold
+from sympy.functions.elementary.trigonometric import (cos, sin, sinc,
+        TrigonometricFunction)
+from sympy.functions.special.bessel import besselj, bessely, besseli, besselk
+from sympy.functions.special.delta_functions import DiracDelta, Heaviside
+from sympy.functions.special.elliptic_integrals import elliptic_k, elliptic_e
+from sympy.functions.special.error_functions import (erf, erfc, erfi, Ei,
+        expint, Si, Ci, Shi, Chi, fresnels, fresnelc)
+from sympy.functions.special.gamma_functions import gamma
+from sympy.functions.special.hyper import hyper, meijerg
+from sympy.functions.special.singularity_functions import SingularityFunction
+from .integrals import Integral
+from sympy.logic.boolalg import And, Or, BooleanAtom, Not, BooleanFunction
+from sympy.polys import cancel, factor
+from sympy.utilities.iterables import multiset_partitions
+from sympy.utilities.misc import debug as _debug
+from sympy.utilities.misc import debugf as _debugf
+
+# keep this at top for easy reference
+z = Dummy('z')
+
+
+def _has(res, *f):
+    # return True if res has f; in the case of Piecewise
+    # only return True if *all* pieces have f
+    res = piecewise_fold(res)
+    if getattr(res, 'is_Piecewise', False):
+        return all(_has(i, *f) for i in res.args)
+    return res.has(*f)
+
+
+def _create_lookup_table(table):
+    """ Add formulae for the function -> meijerg lookup table. """
+    def wild(n):
+        return Wild(n, exclude=[z])
+    p, q, a, b, c = list(map(wild, 'pqabc'))
+    n = Wild('n', properties=[lambda x: x.is_Integer and x > 0])
+    t = p*z**q
+
+    def add(formula, an, ap, bm, bq, arg=t, fac=S.One, cond=True, hint=True):
+        table.setdefault(_mytype(formula, z), []).append((formula,
+                                     [(fac, meijerg(an, ap, bm, bq, arg))], cond, hint))
+
+    def addi(formula, inst, cond, hint=True):
+        table.setdefault(
+            _mytype(formula, z), []).append((formula, inst, cond, hint))
+
+    def constant(a):
+        return [(a, meijerg([1], [], [], [0], z)),
+                (a, meijerg([], [1], [0], [], z))]
+    table[()] = [(a, constant(a), True, True)]
+
+    # [P], Section 8.
+    class IsNonPositiveInteger(Function):
+
+        @classmethod
+        def eval(cls, arg):
+            arg = unpolarify(arg)
+            if arg.is_Integer is True:
+                return arg <= 0
+
+    # Section 8.4.2
+    # TODO this needs more polar_lift (c/f entry for exp)
+    add(Heaviside(t - b)*(t - b)**(a - 1), [a], [], [], [0], t/b,
+        gamma(a)*b**(a - 1), And(b > 0))
+    add(Heaviside(b - t)*(b - t)**(a - 1), [], [a], [0], [], t/b,
+        gamma(a)*b**(a - 1), And(b > 0))
+    add(Heaviside(z - (b/p)**(1/q))*(t - b)**(a - 1), [a], [], [], [0], t/b,
+        gamma(a)*b**(a - 1), And(b > 0))
+    add(Heaviside((b/p)**(1/q) - z)*(b - t)**(a - 1), [], [a], [0], [], t/b,
+        gamma(a)*b**(a - 1), And(b > 0))
+    add((b + t)**(-a), [1 - a], [], [0], [], t/b, b**(-a)/gamma(a),
+        hint=Not(IsNonPositiveInteger(a)))
+    add(Abs(b - t)**(-a), [1 - a], [(1 - a)/2], [0], [(1 - a)/2], t/b,
+        2*sin(pi*a/2)*gamma(1 - a)*Abs(b)**(-a), re(a) < 1)
+    add((t**a - b**a)/(t - b), [0, a], [], [0, a], [], t/b,
+        b**(a - 1)*sin(a*pi)/pi)
+
+    # 12
+    def A1(r, sign, nu):
+        return pi**Rational(-1, 2)*(-sign*nu/2)**(1 - 2*r)
+
+    def tmpadd(r, sgn):
+        # XXX the a**2 is bad for matching
+        add((sqrt(a**2 + t) + sgn*a)**b/(a**2 + t)**r,
+            [(1 + b)/2, 1 - 2*r + b/2], [],
+            [(b - sgn*b)/2], [(b + sgn*b)/2], t/a**2,
+            a**(b - 2*r)*A1(r, sgn, b))
+    tmpadd(0, 1)
+    tmpadd(0, -1)
+    tmpadd(S.Half, 1)
+    tmpadd(S.Half, -1)
+
+    # 13
+    def tmpadd(r, sgn):
+        add((sqrt(a + p*z**q) + sgn*sqrt(p)*z**(q/2))**b/(a + p*z**q)**r,
+            [1 - r + sgn*b/2], [1 - r - sgn*b/2], [0, S.Half], [],
+            p*z**q/a, a**(b/2 - r)*A1(r, sgn, b))
+    tmpadd(0, 1)
+    tmpadd(0, -1)
+    tmpadd(S.Half, 1)
+    tmpadd(S.Half, -1)
+    # (those after look obscure)
+
+    # Section 8.4.3
+    add(exp(polar_lift(-1)*t), [], [], [0], [])
+
+    # TODO can do sin^n, sinh^n by expansion ... where?
+    # 8.4.4 (hyperbolic functions)
+    add(sinh(t), [], [1], [S.Half], [1, 0], t**2/4, pi**Rational(3, 2))
+    add(cosh(t), [], [S.Half], [0], [S.Half, S.Half], t**2/4, pi**Rational(3, 2))
+
+    # Section 8.4.5
+    # TODO can do t + a. but can also do by expansion... (XXX not really)
+    add(sin(t), [], [], [S.Half], [0], t**2/4, sqrt(pi))
+    add(cos(t), [], [], [0], [S.Half], t**2/4, sqrt(pi))
+
+    # Section 8.4.6 (sinc function)
+    add(sinc(t), [], [], [0], [Rational(-1, 2)], t**2/4, sqrt(pi)/2)
+
+    # Section 8.5.5
+    def make_log1(subs):
+        N = subs[n]
+        return [(S.NegativeOne**N*factorial(N),
+                 meijerg([], [1]*(N + 1), [0]*(N + 1), [], t))]
+
+    def make_log2(subs):
+        N = subs[n]
+        return [(factorial(N),
+                 meijerg([1]*(N + 1), [], [], [0]*(N + 1), t))]
+    # TODO these only hold for positive p, and can be made more general
+    #      but who uses log(x)*Heaviside(a-x) anyway ...
+    # TODO also it would be nice to derive them recursively ...
+    addi(log(t)**n*Heaviside(1 - t), make_log1, True)
+    addi(log(t)**n*Heaviside(t - 1), make_log2, True)
+
+    def make_log3(subs):
+        return make_log1(subs) + make_log2(subs)
+    addi(log(t)**n, make_log3, True)
+    addi(log(t + a),
+         constant(log(a)) + [(S.One, meijerg([1, 1], [], [1], [0], t/a))],
+         True)
+    addi(log(Abs(t - a)), constant(log(Abs(a))) +
+         [(pi, meijerg([1, 1], [S.Half], [1], [0, S.Half], t/a))],
+         True)
+    # TODO log(x)/(x+a) and log(x)/(x-1) can also be done. should they
+    #      be derivable?
+    # TODO further formulae in this section seem obscure
+
+    # Sections 8.4.9-10
+    # TODO
+
+    # Section 8.4.11
+    addi(Ei(t),
+         constant(-S.ImaginaryUnit*pi) + [(S.NegativeOne, meijerg([], [1], [0, 0], [],
+                  t*polar_lift(-1)))],
+         True)
+
+    # Section 8.4.12
+    add(Si(t), [1], [], [S.Half], [0, 0], t**2/4, sqrt(pi)/2)
+    add(Ci(t), [], [1], [0, 0], [S.Half], t**2/4, -sqrt(pi)/2)
+
+    # Section 8.4.13
+    add(Shi(t), [S.Half], [], [0], [Rational(-1, 2), Rational(-1, 2)], polar_lift(-1)*t**2/4,
+        t*sqrt(pi)/4)
+    add(Chi(t), [], [S.Half, 1], [0, 0], [S.Half, S.Half], t**2/4, -
+        pi**S('3/2')/2)
+
+    # generalized exponential integral
+    add(expint(a, t), [], [a], [a - 1, 0], [], t)
+
+    # Section 8.4.14
+    add(erf(t), [1], [], [S.Half], [0], t**2, 1/sqrt(pi))
+    # TODO exp(-x)*erf(I*x) does not work
+    add(erfc(t), [], [1], [0, S.Half], [], t**2, 1/sqrt(pi))
+    # This formula for erfi(z) yields a wrong(?) minus sign
+    #add(erfi(t), [1], [], [S.Half], [0], -t**2, I/sqrt(pi))
+    add(erfi(t), [S.Half], [], [0], [Rational(-1, 2)], -t**2, t/sqrt(pi))
+
+    # Fresnel Integrals
+    add(fresnels(t), [1], [], [Rational(3, 4)], [0, Rational(1, 4)], pi**2*t**4/16, S.Half)
+    add(fresnelc(t), [1], [], [Rational(1, 4)], [0, Rational(3, 4)], pi**2*t**4/16, S.Half)
+
+    ##### bessel-type functions #####
+    # Section 8.4.19
+    add(besselj(a, t), [], [], [a/2], [-a/2], t**2/4)
+
+    # all of the following are derivable
+    #add(sin(t)*besselj(a, t), [Rational(1, 4), Rational(3, 4)], [], [(1+a)/2],
+    #    [-a/2, a/2, (1-a)/2], t**2, 1/sqrt(2))
+    #add(cos(t)*besselj(a, t), [Rational(1, 4), Rational(3, 4)], [], [a/2],
+    #    [-a/2, (1+a)/2, (1-a)/2], t**2, 1/sqrt(2))
+    #add(besselj(a, t)**2, [S.Half], [], [a], [-a, 0], t**2, 1/sqrt(pi))
+    #add(besselj(a, t)*besselj(b, t), [0, S.Half], [], [(a + b)/2],
+    #    [-(a+b)/2, (a - b)/2, (b - a)/2], t**2, 1/sqrt(pi))
+
+    # Section 8.4.20
+    add(bessely(a, t), [], [-(a + 1)/2], [a/2, -a/2], [-(a + 1)/2], t**2/4)
+
+    # TODO all of the following should be derivable
+    #add(sin(t)*bessely(a, t), [Rational(1, 4), Rational(3, 4)], [(1 - a - 1)/2],
+    #    [(1 + a)/2, (1 - a)/2], [(1 - a - 1)/2, (1 - 1 - a)/2, (1 - 1 + a)/2],
+    #    t**2, 1/sqrt(2))
+    #add(cos(t)*bessely(a, t), [Rational(1, 4), Rational(3, 4)], [(0 - a - 1)/2],
+    #    [(0 + a)/2, (0 - a)/2], [(0 - a - 1)/2, (1 - 0 - a)/2, (1 - 0 + a)/2],
+    #    t**2, 1/sqrt(2))
+    #add(besselj(a, t)*bessely(b, t), [0, S.Half], [(a - b - 1)/2],
+    #    [(a + b)/2, (a - b)/2], [(a - b - 1)/2, -(a + b)/2, (b - a)/2],
+    #    t**2, 1/sqrt(pi))
+    #addi(bessely(a, t)**2,
+    #     [(2/sqrt(pi), meijerg([], [S.Half, S.Half - a], [0, a, -a],
+    #                           [S.Half - a], t**2)),
+    #      (1/sqrt(pi), meijerg([S.Half], [], [a], [-a, 0], t**2))],
+    #     True)
+    #addi(bessely(a, t)*bessely(b, t),
+    #     [(2/sqrt(pi), meijerg([], [0, S.Half, (1 - a - b)/2],
+    #                           [(a + b)/2, (a - b)/2, (b - a)/2, -(a + b)/2],
+    #                           [(1 - a - b)/2], t**2)),
+    #      (1/sqrt(pi), meijerg([0, S.Half], [], [(a + b)/2],
+    #                           [-(a + b)/2, (a - b)/2, (b - a)/2], t**2))],
+    #     True)
+
+    # Section 8.4.21 ?
+    # Section 8.4.22
+    add(besseli(a, t), [], [(1 + a)/2], [a/2], [-a/2, (1 + a)/2], t**2/4, pi)
+    # TODO many more formulas. should all be derivable
+
+    # Section 8.4.23
+    add(besselk(a, t), [], [], [a/2, -a/2], [], t**2/4, S.Half)
+    # TODO many more formulas. should all be derivable
+
+    # Complete elliptic integrals K(z) and E(z)
+    add(elliptic_k(t), [S.Half, S.Half], [], [0], [0], -t, S.Half)
+    add(elliptic_e(t), [S.Half, 3*S.Half], [], [0], [0], -t, Rational(-1, 2)/2)
+
+
+####################################################################
+# First some helper functions.
+####################################################################
+
+from sympy.utilities.timeutils import timethis
+timeit = timethis('meijerg')
+
+
+def _mytype(f: Basic, x: Symbol) -> tuple[type[Basic], ...]:
+    """ Create a hashable entity describing the type of f. """
+    def key(x: type[Basic]) -> tuple[int, int, str]:
+        return x.class_key()
+
+    if x not in f.free_symbols:
+        return ()
+    elif f.is_Function:
+        return type(f),
+    return tuple(sorted((t for a in f.args for t in _mytype(a, x)), key=key))
+
+
+class _CoeffExpValueError(ValueError):
+    """
+    Exception raised by _get_coeff_exp, for internal use only.
+    """
+    pass
+
+
+def _get_coeff_exp(expr, x):
+    """
+    When expr is known to be of the form c*x**b, with c and/or b possibly 1,
+    return c, b.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, a, b
+    >>> from sympy.integrals.meijerint import _get_coeff_exp
+    >>> _get_coeff_exp(a*x**b, x)
+    (a, b)
+    >>> _get_coeff_exp(x, x)
+    (1, 1)
+    >>> _get_coeff_exp(2*x, x)
+    (2, 1)
+    >>> _get_coeff_exp(x**3, x)
+    (1, 3)
+    """
+    from sympy.simplify import powsimp
+    (c, m) = expand_power_base(powsimp(expr)).as_coeff_mul(x)
+    if not m:
+        return c, S.Zero
+    [m] = m
+    if m.is_Pow:
+        if m.base != x:
+            raise _CoeffExpValueError('expr not of form a*x**b')
+        return c, m.exp
+    elif m == x:
+        return c, S.One
+    else:
+        raise _CoeffExpValueError('expr not of form a*x**b: %s' % expr)
+
+
+def _exponents(expr, x):
+    """
+    Find the exponents of ``x`` (not including zero) in ``expr``.
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.meijerint import _exponents
+    >>> from sympy.abc import x, y
+    >>> from sympy import sin
+    >>> _exponents(x, x)
+    {1}
+    >>> _exponents(x**2, x)
+    {2}
+    >>> _exponents(x**2 + x, x)
+    {1, 2}
+    >>> _exponents(x**3*sin(x + x**y) + 1/x, x)
+    {-1, 1, 3, y}
+    """
+    def _exponents_(expr, x, res):
+        if expr == x:
+            res.update([1])
+            return
+        if expr.is_Pow and expr.base == x:
+            res.update([expr.exp])
+            return
+        for argument in expr.args:
+            _exponents_(argument, x, res)
+    res = set()
+    _exponents_(expr, x, res)
+    return res
+
+
+def _functions(expr, x):
+    """ Find the types of functions in expr, to estimate the complexity. """
+    return {e.func for e in expr.atoms(Function) if x in e.free_symbols}
+
+
+def _find_splitting_points(expr, x):
+    """
+    Find numbers a such that a linear substitution x -> x + a would
+    (hopefully) simplify expr.
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.meijerint import _find_splitting_points as fsp
+    >>> from sympy import sin
+    >>> from sympy.abc import x
+    >>> fsp(x, x)
+    {0}
+    >>> fsp((x-1)**3, x)
+    {1}
+    >>> fsp(sin(x+3)*x, x)
+    {-3, 0}
+    """
+    p, q = [Wild(n, exclude=[x]) for n in 'pq']
+
+    def compute_innermost(expr, res):
+        if not isinstance(expr, Expr):
+            return
+        m = expr.match(p*x + q)
+        if m and m[p] != 0:
+            res.add(-m[q]/m[p])
+            return
+        if expr.is_Atom:
+            return
+        for argument in expr.args:
+            compute_innermost(argument, res)
+    innermost = set()
+    compute_innermost(expr, innermost)
+    return innermost
+
+
+def _split_mul(f, x):
+    """
+    Split expression ``f`` into fac, po, g, where fac is a constant factor,
+    po = x**s for some s independent of s, and g is "the rest".
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.meijerint import _split_mul
+    >>> from sympy import sin
+    >>> from sympy.abc import s, x
+    >>> _split_mul((3*x)**s*sin(x**2)*x, x)
+    (3**s, x*x**s, sin(x**2))
+    """
+    fac = S.One
+    po = S.One
+    g = S.One
+    f = expand_power_base(f)
+
+    args = Mul.make_args(f)
+    for a in args:
+        if a == x:
+            po *= x
+        elif x not in a.free_symbols:
+            fac *= a
+        else:
+            if a.is_Pow and x not in a.exp.free_symbols:
+                c, t = a.base.as_coeff_mul(x)
+                if t != (x,):
+                    c, t = expand_mul(a.base).as_coeff_mul(x)
+                if t == (x,):
+                    po *= x**a.exp
+                    fac *= unpolarify(polarify(c**a.exp, subs=False))
+                    continue
+            g *= a
+
+    return fac, po, g
+
+
+def _mul_args(f):
+    """
+    Return a list ``L`` such that ``Mul(*L) == f``.
+
+    If ``f`` is not a ``Mul`` or ``Pow``, ``L=[f]``.
+    If ``f=g**n`` for an integer ``n``, ``L=[g]*n``.
+    If ``f`` is a ``Mul``, ``L`` comes from applying ``_mul_args`` to all factors of ``f``.
+    """
+    args = Mul.make_args(f)
+    gs = []
+    for g in args:
+        if g.is_Pow and g.exp.is_Integer:
+            n = g.exp
+            base = g.base
+            if n < 0:
+                n = -n
+                base = 1/base
+            gs += [base]*n
+        else:
+            gs.append(g)
+    return gs
+
+
+def _mul_as_two_parts(f):
+    """
+    Find all the ways to split ``f`` into a product of two terms.
+    Return None on failure.
+
+    Explanation
+    ===========
+
+    Although the order is canonical from multiset_partitions, this is
+    not necessarily the best order to process the terms. For example,
+    if the case of len(gs) == 2 is removed and multiset is allowed to
+    sort the terms, some tests fail.
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.meijerint import _mul_as_two_parts
+    >>> from sympy import sin, exp, ordered
+    >>> from sympy.abc import x
+    >>> list(ordered(_mul_as_two_parts(x*sin(x)*exp(x))))
+    [(x, exp(x)*sin(x)), (x*exp(x), sin(x)), (x*sin(x), exp(x))]
+    """
+
+    gs = _mul_args(f)
+    if len(gs) < 2:
+        return None
+    if len(gs) == 2:
+        return [tuple(gs)]
+    return [(Mul(*x), Mul(*y)) for (x, y) in multiset_partitions(gs, 2)]
+
+
+def _inflate_g(g, n):
+    """ Return C, h such that h is a G function of argument z**n and
+        g = C*h. """
+    # TODO should this be a method of meijerg?
+    # See: [L, page 150, equation (5)]
+    def inflate(params, n):
+        """ (a1, .., ak) -> (a1/n, (a1+1)/n, ..., (ak + n-1)/n) """
+        return [(a + i)/n for a, i in itertools.product(params, range(n))]
+    v = S(len(g.ap) - len(g.bq))
+    C = n**(1 + g.nu + v/2)
+    C /= (2*pi)**((n - 1)*g.delta)
+    return C, meijerg(inflate(g.an, n), inflate(g.aother, n),
+                      inflate(g.bm, n), inflate(g.bother, n),
+                      g.argument**n * n**(n*v))
+
+
+def _flip_g(g):
+    """ Turn the G function into one of inverse argument
+        (i.e. G(1/x) -> G'(x)) """
+    # See [L], section 5.2
+    def tr(l):
+        return [1 - a for a in l]
+    return meijerg(tr(g.bm), tr(g.bother), tr(g.an), tr(g.aother), 1/g.argument)
+
+
+def _inflate_fox_h(g, a):
+    r"""
+    Let d denote the integrand in the definition of the G function ``g``.
+    Consider the function H which is defined in the same way, but with
+    integrand d/Gamma(a*s) (contour conventions as usual).
+
+    If ``a`` is rational, the function H can be written as C*G, for a constant C
+    and a G-function G.
+
+    This function returns C, G.
+    """
+    if a < 0:
+        return _inflate_fox_h(_flip_g(g), -a)
+    p = S(a.p)
+    q = S(a.q)
+    # We use the substitution s->qs, i.e. inflate g by q. We are left with an
+    # extra factor of Gamma(p*s), for which we use Gauss' multiplication
+    # theorem.
+    D, g = _inflate_g(g, q)
+    z = g.argument
+    D /= (2*pi)**((1 - p)/2)*p**Rational(-1, 2)
+    z /= p**p
+    bs = [(n + 1)/p for n in range(p)]
+    return D, meijerg(g.an, g.aother, g.bm, list(g.bother) + bs, z)
+
+
+_dummies: dict[tuple[str, str], Dummy]  = {}
+
+
+def _dummy(name, token, expr, **kwargs):
+    """
+    Return a dummy. This will return the same dummy if the same token+name is
+    requested more than once, and it is not already in expr.
+    This is for being cache-friendly.
+    """
+    d = _dummy_(name, token, **kwargs)
+    if d in expr.free_symbols:
+        return Dummy(name, **kwargs)
+    return d
+
+
+def _dummy_(name, token, **kwargs):
+    """
+    Return a dummy associated to name and token. Same effect as declaring
+    it globally.
+    """
+    if not (name, token) in _dummies:
+        _dummies[(name, token)] = Dummy(name, **kwargs)
+    return _dummies[(name, token)]
+
+
+def _is_analytic(f, x):
+    """ Check if f(x), when expressed using G functions on the positive reals,
+        will in fact agree with the G functions almost everywhere """
+    return not any(x in expr.free_symbols for expr in f.atoms(Heaviside, Abs))
+
+
+def _condsimp(cond, first=True):
+    """
+    Do naive simplifications on ``cond``.
+
+    Explanation
+    ===========
+
+    Note that this routine is completely ad-hoc, simplification rules being
+    added as need arises rather than following any logical pattern.
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.meijerint import _condsimp as simp
+    >>> from sympy import Or, Eq
+    >>> from sympy.abc import x, y
+    >>> simp(Or(x < y, Eq(x, y)))
+    x <= y
+    """
+    if first:
+        cond = cond.replace(lambda _: _.is_Relational, _canonical_coeff)
+        first = False
+    if not isinstance(cond, BooleanFunction):
+        return cond
+    p, q, r = symbols('p q r', cls=Wild)
+    # transforms tests use 0, 4, 5 and 11-14
+    # meijer tests use 0, 2, 11, 14
+    # joint_rv uses 6, 7
+    rules = [
+        (Or(p < q, Eq(p, q)), p <= q),  # 0
+        # The next two obviously are instances of a general pattern, but it is
+        # easier to spell out the few cases we care about.
+        (And(Abs(arg(p)) <= pi, Abs(arg(p) - 2*pi) <= pi),
+         Eq(arg(p) - pi, 0)),  # 1
+        (And(Abs(2*arg(p) + pi) <= pi, Abs(2*arg(p) - pi) <= pi),
+         Eq(arg(p), 0)), # 2
+        (And(Abs(2*arg(p) + pi) < pi, Abs(2*arg(p) - pi) <= pi),
+         S.false),  # 3
+        (And(Abs(arg(p) - pi/2) <= pi/2, Abs(arg(p) + pi/2) <= pi/2),
+         Eq(arg(p), 0)),  # 4
+        (And(Abs(arg(p) - pi/2) <= pi/2, Abs(arg(p) + pi/2) < pi/2),
+         S.false),  # 5
+        (And(Abs(arg(p**2/2 + 1)) < pi, Ne(Abs(arg(p**2/2 + 1)), pi)),
+         S.true),  # 6
+        (Or(Abs(arg(p**2/2 + 1)) < pi, Ne(1/(p**2/2 + 1), 0)),
+         S.true),  # 7
+        (And(Abs(unbranched_argument(p)) <= pi,
+           Abs(unbranched_argument(exp_polar(-2*pi*S.ImaginaryUnit)*p)) <= pi),
+         Eq(unbranched_argument(exp_polar(-S.ImaginaryUnit*pi)*p), 0)),  # 8
+        (And(Abs(unbranched_argument(p)) <= pi/2,
+           Abs(unbranched_argument(exp_polar(-pi*S.ImaginaryUnit)*p)) <= pi/2),
+         Eq(unbranched_argument(exp_polar(-S.ImaginaryUnit*pi/2)*p), 0)),  # 9
+        (Or(p <= q, And(p < q, r)), p <= q),  # 10
+        (Ne(p**2, 1) & (p**2 > 1), p**2 > 1),  # 11
+        (Ne(1/p, 1) & (cos(Abs(arg(p)))*Abs(p) > 1), Abs(p) > 1),  # 12
+        (Ne(p, 2) & (cos(Abs(arg(p)))*Abs(p) > 2), Abs(p) > 2),  # 13
+        ((Abs(arg(p)) < pi/2) & (cos(Abs(arg(p)))*sqrt(Abs(p**2)) > 1), p**2 > 1),  # 14
+    ]
+    cond = cond.func(*[_condsimp(_, first) for _ in cond.args])
+    change = True
+    while change:
+        change = False
+        for irule, (fro, to) in enumerate(rules):
+            if fro.func != cond.func:
+                continue
+            for n, arg1 in enumerate(cond.args):
+                if r in fro.args[0].free_symbols:
+                    m = arg1.match(fro.args[1])
+                    num = 1
+                else:
+                    num = 0
+                    m = arg1.match(fro.args[0])
+                if not m:
+                    continue
+                otherargs = [x.subs(m) for x in fro.args[:num] + fro.args[num + 1:]]
+                otherlist = [n]
+                for arg2 in otherargs:
+                    for k, arg3 in enumerate(cond.args):
+                        if k in otherlist:
+                            continue
+                        if arg2 == arg3:
+                            otherlist += [k]
+                            break
+                        if isinstance(arg3, And) and arg2.args[1] == r and \
+                                isinstance(arg2, And) and arg2.args[0] in arg3.args:
+                            otherlist += [k]
+                            break
+                        if isinstance(arg3, And) and arg2.args[0] == r and \
+                                isinstance(arg2, And) and arg2.args[1] in arg3.args:
+                            otherlist += [k]
+                            break
+                if len(otherlist) != len(otherargs) + 1:
+                    continue
+                newargs = [arg_ for (k, arg_) in enumerate(cond.args)
+                           if k not in otherlist] + [to.subs(m)]
+                if SYMPY_DEBUG:
+                    if irule not in (0, 2, 4, 5, 6, 7, 11, 12, 13, 14):
+                        print('used new rule:', irule)
+                cond = cond.func(*newargs)
+                change = True
+                break
+
+    # final tweak
+    def rel_touchup(rel):
+        if rel.rel_op != '==' or rel.rhs != 0:
+            return rel
+
+        # handle Eq(*, 0)
+        LHS = rel.lhs
+        m = LHS.match(arg(p)**q)
+        if not m:
+            m = LHS.match(unbranched_argument(polar_lift(p)**q))
+        if not m:
+            if isinstance(LHS, periodic_argument) and not LHS.args[0].is_polar \
+                    and LHS.args[1] is S.Infinity:
+                return (LHS.args[0] > 0)
+            return rel
+        return (m[p] > 0)
+    cond = cond.replace(lambda _: _.is_Relational, rel_touchup)
+    if SYMPY_DEBUG:
+        print('_condsimp: ', cond)
+    return cond
+
+def _eval_cond(cond):
+    """ Re-evaluate the conditions. """
+    if isinstance(cond, bool):
+        return cond
+    return _condsimp(cond.doit())
+
+####################################################################
+# Now the "backbone" functions to do actual integration.
+####################################################################
+
+
+def _my_principal_branch(expr, period, full_pb=False):
+    """ Bring expr nearer to its principal branch by removing superfluous
+        factors.
+        This function does *not* guarantee to yield the principal branch,
+        to avoid introducing opaque principal_branch() objects,
+        unless full_pb=True. """
+    res = principal_branch(expr, period)
+    if not full_pb:
+        res = res.replace(principal_branch, lambda x, y: x)
+    return res
+
+
+def _rewrite_saxena_1(fac, po, g, x):
+    """
+    Rewrite the integral fac*po*g dx, from zero to infinity, as
+    integral fac*G, where G has argument a*x. Note po=x**s.
+    Return fac, G.
+    """
+    _, s = _get_coeff_exp(po, x)
+    a, b = _get_coeff_exp(g.argument, x)
+    period = g.get_period()
+    a = _my_principal_branch(a, period)
+
+    # We substitute t = x**b.
+    C = fac/(Abs(b)*a**((s + 1)/b - 1))
+    # Absorb a factor of (at)**((1 + s)/b - 1).
+
+    def tr(l):
+        return [a + (1 + s)/b - 1 for a in l]
+    return C, meijerg(tr(g.an), tr(g.aother), tr(g.bm), tr(g.bother),
+                      a*x)
+
+
+def _check_antecedents_1(g, x, helper=False):
+    r"""
+    Return a condition under which the mellin transform of g exists.
+    Any power of x has already been absorbed into the G function,
+    so this is just $\int_0^\infty g\, dx$.
+
+    See [L, section 5.6.1]. (Note that s=1.)
+
+    If ``helper`` is True, only check if the MT exists at infinity, i.e. if
+    $\int_1^\infty g\, dx$ exists.
+    """
+    # NOTE if you update these conditions, please update the documentation as well
+    delta = g.delta
+    eta, _ = _get_coeff_exp(g.argument, x)
+    m, n, p, q = S([len(g.bm), len(g.an), len(g.ap), len(g.bq)])
+
+    if p > q:
+        def tr(l):
+            return [1 - x for x in l]
+        return _check_antecedents_1(meijerg(tr(g.bm), tr(g.bother),
+                                            tr(g.an), tr(g.aother), x/eta),
+                                    x)
+
+    tmp = [-re(b) < 1 for b in g.bm] + [1 < 1 - re(a) for a in g.an]
+    cond_3 = And(*tmp)
+
+    tmp += [-re(b) < 1 for b in g.bother]
+    tmp += [1 < 1 - re(a) for a in g.aother]
+    cond_3_star = And(*tmp)
+
+    cond_4 = (-re(g.nu) + (q + 1 - p)/2 > q - p)
+
+    def debug(*msg):
+        _debug(*msg)
+
+    def debugf(string, arg):
+        _debugf(string, arg)
+
+    debug('Checking antecedents for 1 function:')
+    debugf('  delta=%s, eta=%s, m=%s, n=%s, p=%s, q=%s',
+           (delta, eta, m, n, p, q))
+    debugf('  ap = %s, %s', (list(g.an), list(g.aother)))
+    debugf('  bq = %s, %s', (list(g.bm), list(g.bother)))
+    debugf('  cond_3=%s, cond_3*=%s, cond_4=%s', (cond_3, cond_3_star, cond_4))
+
+    conds = []
+
+    # case 1
+    case1 = []
+    tmp1 = [1 <= n, p < q, 1 <= m]
+    tmp2 = [1 <= p, 1 <= m, Eq(q, p + 1), Not(And(Eq(n, 0), Eq(m, p + 1)))]
+    tmp3 = [1 <= p, Eq(q, p)]
+    for k in range(ceiling(delta/2) + 1):
+        tmp3 += [Ne(Abs(unbranched_argument(eta)), (delta - 2*k)*pi)]
+    tmp = [delta > 0, Abs(unbranched_argument(eta)) < delta*pi]
+    extra = [Ne(eta, 0), cond_3]
+    if helper:
+        extra = []
+    for t in [tmp1, tmp2, tmp3]:
+        case1 += [And(*(t + tmp + extra))]
+    conds += case1
+    debug('  case 1:', case1)
+
+    # case 2
+    extra = [cond_3]
+    if helper:
+        extra = []
+    case2 = [And(Eq(n, 0), p + 1 <= m, m <= q,
+                 Abs(unbranched_argument(eta)) < delta*pi, *extra)]
+    conds += case2
+    debug('  case 2:', case2)
+
+    # case 3
+    extra = [cond_3, cond_4]
+    if helper:
+        extra = []
+    case3 = [And(p < q, 1 <= m, delta > 0, Eq(Abs(unbranched_argument(eta)), delta*pi),
+                 *extra)]
+    case3 += [And(p <= q - 2, Eq(delta, 0), Eq(Abs(unbranched_argument(eta)), 0), *extra)]
+    conds += case3
+    debug('  case 3:', case3)
+
+    # TODO altered cases 4-7
+
+    # extra case from wofram functions site:
+    # (reproduced verbatim from Prudnikov, section 2.24.2)
+    # https://functions.wolfram.com/HypergeometricFunctions/MeijerG/21/02/01/
+    case_extra = []
+    case_extra += [Eq(p, q), Eq(delta, 0), Eq(unbranched_argument(eta), 0), Ne(eta, 0)]
+    if not helper:
+        case_extra += [cond_3]
+    s = []
+    for a, b in zip(g.ap, g.bq):
+        s += [b - a]
+    case_extra += [re(Add(*s)) < 0]
+    case_extra = And(*case_extra)
+    conds += [case_extra]
+    debug('  extra case:', [case_extra])
+
+    case_extra_2 = [And(delta > 0, Abs(unbranched_argument(eta)) < delta*pi)]
+    if not helper:
+        case_extra_2 += [cond_3]
+    case_extra_2 = And(*case_extra_2)
+    conds += [case_extra_2]
+    debug('  second extra case:', [case_extra_2])
+
+    # TODO This leaves only one case from the three listed by Prudnikov.
+    #      Investigate if these indeed cover everything; if so, remove the rest.
+
+    return Or(*conds)
+
+
+def _int0oo_1(g, x):
+    r"""
+    Evaluate $\int_0^\infty g\, dx$ using G functions,
+    assuming the necessary conditions are fulfilled.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import a, b, c, d, x, y
+    >>> from sympy import meijerg
+    >>> from sympy.integrals.meijerint import _int0oo_1
+    >>> _int0oo_1(meijerg([a], [b], [c], [d], x*y), x)
+    gamma(-a)*gamma(c + 1)/(y*gamma(-d)*gamma(b + 1))
+    """
+    from sympy.simplify import gammasimp
+    # See [L, section 5.6.1]. Note that s=1.
+    eta, _ = _get_coeff_exp(g.argument, x)
+    res = 1/eta
+    # XXX TODO we should reduce order first
+    for b in g.bm:
+        res *= gamma(b + 1)
+    for a in g.an:
+        res *= gamma(1 - a - 1)
+    for b in g.bother:
+        res /= gamma(1 - b - 1)
+    for a in g.aother:
+        res /= gamma(a + 1)
+    return gammasimp(unpolarify(res))
+
+
+def _rewrite_saxena(fac, po, g1, g2, x, full_pb=False):
+    """
+    Rewrite the integral ``fac*po*g1*g2`` from 0 to oo in terms of G
+    functions with argument ``c*x``.
+
+    Explanation
+    ===========
+
+    Return C, f1, f2 such that integral C f1 f2 from 0 to infinity equals
+    integral fac ``po``, ``g1``, ``g2`` from 0 to infinity.
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.meijerint import _rewrite_saxena
+    >>> from sympy.abc import s, t, m
+    >>> from sympy import meijerg
+    >>> g1 = meijerg([], [], [0], [], s*t)
+    >>> g2 = meijerg([], [], [m/2], [-m/2], t**2/4)
+    >>> r = _rewrite_saxena(1, t**0, g1, g2, t)
+    >>> r[0]
+    s/(4*sqrt(pi))
+    >>> r[1]
+    meijerg(((), ()), ((-1/2, 0), ()), s**2*t/4)
+    >>> r[2]
+    meijerg(((), ()), ((m/2,), (-m/2,)), t/4)
+    """
+    def pb(g):
+        a, b = _get_coeff_exp(g.argument, x)
+        per = g.get_period()
+        return meijerg(g.an, g.aother, g.bm, g.bother,
+                       _my_principal_branch(a, per, full_pb)*x**b)
+
+    _, s = _get_coeff_exp(po, x)
+    _, b1 = _get_coeff_exp(g1.argument, x)
+    _, b2 = _get_coeff_exp(g2.argument, x)
+    if (b1 < 0) == True:
+        b1 = -b1
+        g1 = _flip_g(g1)
+    if (b2 < 0) == True:
+        b2 = -b2
+        g2 = _flip_g(g2)
+    if not b1.is_Rational or not b2.is_Rational:
+        return
+    m1, n1 = b1.p, b1.q
+    m2, n2 = b2.p, b2.q
+    tau = ilcm(m1*n2, m2*n1)
+    r1 = tau//(m1*n2)
+    r2 = tau//(m2*n1)
+
+    C1, g1 = _inflate_g(g1, r1)
+    C2, g2 = _inflate_g(g2, r2)
+    g1 = pb(g1)
+    g2 = pb(g2)
+
+    fac *= C1*C2
+    a1, b = _get_coeff_exp(g1.argument, x)
+    a2, _ = _get_coeff_exp(g2.argument, x)
+
+    # arbitrarily tack on the x**s part to g1
+    # TODO should we try both?
+    exp = (s + 1)/b - 1
+    fac = fac/(Abs(b) * a1**exp)
+
+    def tr(l):
+        return [a + exp for a in l]
+    g1 = meijerg(tr(g1.an), tr(g1.aother), tr(g1.bm), tr(g1.bother), a1*x)
+    g2 = meijerg(g2.an, g2.aother, g2.bm, g2.bother, a2*x)
+
+    from sympy.simplify import powdenest
+    return powdenest(fac, polar=True), g1, g2
+
+
+def _check_antecedents(g1, g2, x):
+    """ Return a condition under which the integral theorem applies. """
+    #  Yes, this is madness.
+    # XXX TODO this is a testing *nightmare*
+    # NOTE if you update these conditions, please update the documentation as well
+
+    # The following conditions are found in
+    # [P], Section 2.24.1
+    #
+    # They are also reproduced (verbatim!) at
+    # https://functions.wolfram.com/HypergeometricFunctions/MeijerG/21/02/03/
+    #
+    # Note: k=l=r=alpha=1
+    sigma, _ = _get_coeff_exp(g1.argument, x)
+    omega, _ = _get_coeff_exp(g2.argument, x)
+    s, t, u, v = S([len(g1.bm), len(g1.an), len(g1.ap), len(g1.bq)])
+    m, n, p, q = S([len(g2.bm), len(g2.an), len(g2.ap), len(g2.bq)])
+    bstar = s + t - (u + v)/2
+    cstar = m + n - (p + q)/2
+    rho = g1.nu + (u - v)/2 + 1
+    mu = g2.nu + (p - q)/2 + 1
+    phi = q - p - (v - u)
+    eta = 1 - (v - u) - mu - rho
+    psi = (pi*(q - m - n) + Abs(unbranched_argument(omega)))/(q - p)
+    theta = (pi*(v - s - t) + Abs(unbranched_argument(sigma)))/(v - u)
+
+    _debug('Checking antecedents:')
+    _debugf('  sigma=%s, s=%s, t=%s, u=%s, v=%s, b*=%s, rho=%s',
+            (sigma, s, t, u, v, bstar, rho))
+    _debugf('  omega=%s, m=%s, n=%s, p=%s, q=%s, c*=%s, mu=%s,',
+            (omega, m, n, p, q, cstar, mu))
+    _debugf('  phi=%s, eta=%s, psi=%s, theta=%s', (phi, eta, psi, theta))
+
+    def _c1():
+        for g in [g1, g2]:
+            for i, j in itertools.product(g.an, g.bm):
+                diff = i - j
+                if diff.is_integer and diff.is_positive:
+                    return False
+        return True
+    c1 = _c1()
+    c2 = And(*[re(1 + i + j) > 0 for i in g1.bm for j in g2.bm])
+    c3 = And(*[re(1 + i + j) < 1 + 1 for i in g1.an for j in g2.an])
+    c4 = And(*[(p - q)*re(1 + i - 1) - re(mu) > Rational(-3, 2) for i in g1.an])
+    c5 = And(*[(p - q)*re(1 + i) - re(mu) > Rational(-3, 2) for i in g1.bm])
+    c6 = And(*[(u - v)*re(1 + i - 1) - re(rho) > Rational(-3, 2) for i in g2.an])
+    c7 = And(*[(u - v)*re(1 + i) - re(rho) > Rational(-3, 2) for i in g2.bm])
+    c8 = (Abs(phi) + 2*re((rho - 1)*(q - p) + (v - u)*(q - p) + (mu -
+          1)*(v - u)) > 0)
+    c9 = (Abs(phi) - 2*re((rho - 1)*(q - p) + (v - u)*(q - p) + (mu -
+          1)*(v - u)) > 0)
+    c10 = (Abs(unbranched_argument(sigma)) < bstar*pi)
+    c11 = Eq(Abs(unbranched_argument(sigma)), bstar*pi)
+    c12 = (Abs(unbranched_argument(omega)) < cstar*pi)
+    c13 = Eq(Abs(unbranched_argument(omega)), cstar*pi)
+
+    # The following condition is *not* implemented as stated on the wolfram
+    # function site. In the book of Prudnikov there is an additional part
+    # (the And involving re()). However, I only have this book in russian, and
+    # I don't read any russian. The following condition is what other people
+    # have told me it means.
+    # Worryingly, it is different from the condition implemented in REDUCE.
+    # The REDUCE implementation:
+    #   https://reduce-algebra.svn.sourceforge.net/svnroot/reduce-algebra/trunk/packages/defint/definta.red
+    #   (search for tst14)
+    # The Wolfram alpha version:
+    #   https://functions.wolfram.com/HypergeometricFunctions/MeijerG/21/02/03/03/0014/
+    z0 = exp(-(bstar + cstar)*pi*S.ImaginaryUnit)
+    zos = unpolarify(z0*omega/sigma)
+    zso = unpolarify(z0*sigma/omega)
+    if zos == 1/zso:
+        c14 = And(Eq(phi, 0), bstar + cstar <= 1,
+                  Or(Ne(zos, 1), re(mu + rho + v - u) < 1,
+                     re(mu + rho + q - p) < 1))
+    else:
+        def _cond(z):
+            '''Returns True if abs(arg(1-z)) < pi, avoiding arg(0).
+
+            Explanation
+            ===========
+
+            If ``z`` is 1 then arg is NaN. This raises a
+            TypeError on `NaN < pi`. Previously this gave `False` so
+            this behavior has been hardcoded here but someone should
+            check if this NaN is more serious! This NaN is triggered by
+            test_meijerint() in test_meijerint.py:
+            `meijerint_definite(exp(x), x, 0, I)`
+            '''
+            return z != 1 and Abs(arg(1 - z)) < pi
+
+        c14 = And(Eq(phi, 0), bstar - 1 + cstar <= 0,
+                  Or(And(Ne(zos, 1), _cond(zos)),
+                     And(re(mu + rho + v - u) < 1, Eq(zos, 1))))
+
+        c14_alt = And(Eq(phi, 0), cstar - 1 + bstar <= 0,
+                  Or(And(Ne(zso, 1), _cond(zso)),
+                     And(re(mu + rho + q - p) < 1, Eq(zso, 1))))
+
+        # Since r=k=l=1, in our case there is c14_alt which is the same as calling
+        # us with (g1, g2) = (g2, g1). The conditions below enumerate all cases
+        # (i.e. we don't have to try arguments reversed by hand), and indeed try
+        # all symmetric cases. (i.e. whenever there is a condition involving c14,
+        # there is also a dual condition which is exactly what we would get when g1,
+        # g2 were interchanged, *but c14 was unaltered*).
+        # Hence the following seems correct:
+        c14 = Or(c14, c14_alt)
+
+    '''
+    When `c15` is NaN (e.g. from `psi` being NaN as happens during
+    'test_issue_4992' and/or `theta` is NaN as in 'test_issue_6253',
+    both in `test_integrals.py`) the comparison to 0 formerly gave False
+    whereas now an error is raised. To keep the old behavior, the value
+    of NaN is replaced with False but perhaps a closer look at this condition
+    should be made: XXX how should conditions leading to c15=NaN be handled?
+    '''
+    try:
+        lambda_c = (q - p)*Abs(omega)**(1/(q - p))*cos(psi) \
+            + (v - u)*Abs(sigma)**(1/(v - u))*cos(theta)
+        # the TypeError might be raised here, e.g. if lambda_c is NaN
+        if _eval_cond(lambda_c > 0) != False:
+            c15 = (lambda_c > 0)
+        else:
+            def lambda_s0(c1, c2):
+                return c1*(q - p)*Abs(omega)**(1/(q - p))*sin(psi) \
+                    + c2*(v - u)*Abs(sigma)**(1/(v - u))*sin(theta)
+            lambda_s = Piecewise(
+                ((lambda_s0(+1, +1)*lambda_s0(-1, -1)),
+                 And(Eq(unbranched_argument(sigma), 0), Eq(unbranched_argument(omega), 0))),
+                (lambda_s0(sign(unbranched_argument(omega)), +1)*lambda_s0(sign(unbranched_argument(omega)), -1),
+                 And(Eq(unbranched_argument(sigma), 0), Ne(unbranched_argument(omega), 0))),
+                (lambda_s0(+1, sign(unbranched_argument(sigma)))*lambda_s0(-1, sign(unbranched_argument(sigma))),
+                 And(Ne(unbranched_argument(sigma), 0), Eq(unbranched_argument(omega), 0))),
+                (lambda_s0(sign(unbranched_argument(omega)), sign(unbranched_argument(sigma))), True))
+            tmp = [lambda_c > 0,
+                   And(Eq(lambda_c, 0), Ne(lambda_s, 0), re(eta) > -1),
+                   And(Eq(lambda_c, 0), Eq(lambda_s, 0), re(eta) > 0)]
+            c15 = Or(*tmp)
+    except TypeError:
+        c15 = False
+    for cond, i in [(c1, 1), (c2, 2), (c3, 3), (c4, 4), (c5, 5), (c6, 6),
+                    (c7, 7), (c8, 8), (c9, 9), (c10, 10), (c11, 11),
+                    (c12, 12), (c13, 13), (c14, 14), (c15, 15)]:
+        _debugf('  c%s: %s', (i, cond))
+
+    # We will return Or(*conds)
+    conds = []
+
+    def pr(count):
+        _debugf('  case %s: %s', (count, conds[-1]))
+    conds += [And(m*n*s*t != 0, bstar.is_positive is True, cstar.is_positive is True, c1, c2, c3, c10,
+                  c12)]  # 1
+    pr(1)
+    conds += [And(Eq(u, v), Eq(bstar, 0), cstar.is_positive is True, sigma.is_positive is True, re(rho) < 1,
+                  c1, c2, c3, c12)]  # 2
+    pr(2)
+    conds += [And(Eq(p, q), Eq(cstar, 0), bstar.is_positive is True, omega.is_positive is True, re(mu) < 1,
+                  c1, c2, c3, c10)]  # 3
+    pr(3)
+    conds += [And(Eq(p, q), Eq(u, v), Eq(bstar, 0), Eq(cstar, 0),
+                  sigma.is_positive is True, omega.is_positive is True, re(mu) < 1, re(rho) < 1,
+                  Ne(sigma, omega), c1, c2, c3)]  # 4
+    pr(4)
+    conds += [And(Eq(p, q), Eq(u, v), Eq(bstar, 0), Eq(cstar, 0),
+                  sigma.is_positive is True, omega.is_positive is True, re(mu + rho) < 1,
+                  Ne(omega, sigma), c1, c2, c3)]  # 5
+    pr(5)
+    conds += [And(p > q, s.is_positive is True, bstar.is_positive is True, cstar >= 0,
+                  c1, c2, c3, c5, c10, c13)]  # 6
+    pr(6)
+    conds += [And(p < q, t.is_positive is True, bstar.is_positive is True, cstar >= 0,
+                  c1, c2, c3, c4, c10, c13)]  # 7
+    pr(7)
+    conds += [And(u > v, m.is_positive is True, cstar.is_positive is True, bstar >= 0,
+                  c1, c2, c3, c7, c11, c12)]  # 8
+    pr(8)
+    conds += [And(u < v, n.is_positive is True, cstar.is_positive is True, bstar >= 0,
+                  c1, c2, c3, c6, c11, c12)]  # 9
+    pr(9)
+    conds += [And(p > q, Eq(u, v), Eq(bstar, 0), cstar >= 0, sigma.is_positive is True,
+                  re(rho) < 1, c1, c2, c3, c5, c13)]  # 10
+    pr(10)
+    conds += [And(p < q, Eq(u, v), Eq(bstar, 0), cstar >= 0, sigma.is_positive is True,
+                  re(rho) < 1, c1, c2, c3, c4, c13)]  # 11
+    pr(11)
+    conds += [And(Eq(p, q), u > v, bstar >= 0, Eq(cstar, 0), omega.is_positive is True,
+                  re(mu) < 1, c1, c2, c3, c7, c11)]  # 12
+    pr(12)
+    conds += [And(Eq(p, q), u < v, bstar >= 0, Eq(cstar, 0), omega.is_positive is True,
+                  re(mu) < 1, c1, c2, c3, c6, c11)]  # 13
+    pr(13)
+    conds += [And(p < q, u > v, bstar >= 0, cstar >= 0,
+                  c1, c2, c3, c4, c7, c11, c13)]  # 14
+    pr(14)
+    conds += [And(p > q, u < v, bstar >= 0, cstar >= 0,
+                  c1, c2, c3, c5, c6, c11, c13)]  # 15
+    pr(15)
+    conds += [And(p > q, u > v, bstar >= 0, cstar >= 0,
+                  c1, c2, c3, c5, c7, c8, c11, c13, c14)]  # 16
+    pr(16)
+    conds += [And(p < q, u < v, bstar >= 0, cstar >= 0,
+                  c1, c2, c3, c4, c6, c9, c11, c13, c14)]  # 17
+    pr(17)
+    conds += [And(Eq(t, 0), s.is_positive is True, bstar.is_positive is True, phi.is_positive is True, c1, c2, c10)]  # 18
+    pr(18)
+    conds += [And(Eq(s, 0), t.is_positive is True, bstar.is_positive is True, phi.is_negative is True, c1, c3, c10)]  # 19
+    pr(19)
+    conds += [And(Eq(n, 0), m.is_positive is True, cstar.is_positive is True, phi.is_negative is True, c1, c2, c12)]  # 20
+    pr(20)
+    conds += [And(Eq(m, 0), n.is_positive is True, cstar.is_positive is True, phi.is_positive is True, c1, c3, c12)]  # 21
+    pr(21)
+    conds += [And(Eq(s*t, 0), bstar.is_positive is True, cstar.is_positive is True,
+                  c1, c2, c3, c10, c12)]  # 22
+    pr(22)
+    conds += [And(Eq(m*n, 0), bstar.is_positive is True, cstar.is_positive is True,
+                  c1, c2, c3, c10, c12)]  # 23
+    pr(23)
+
+    # The following case is from [Luke1969]. As far as I can tell, it is *not*
+    # covered by Prudnikov's.
+    # Let G1 and G2 be the two G-functions. Suppose the integral exists from
+    # 0 to a > 0 (this is easy the easy part), that G1 is exponential decay at
+    # infinity, and that the mellin transform of G2 exists.
+    # Then the integral exists.
+    mt1_exists = _check_antecedents_1(g1, x, helper=True)
+    mt2_exists = _check_antecedents_1(g2, x, helper=True)
+    conds += [And(mt2_exists, Eq(t, 0), u < s, bstar.is_positive is True, c10, c1, c2, c3)]
+    pr('E1')
+    conds += [And(mt2_exists, Eq(s, 0), v < t, bstar.is_positive is True, c10, c1, c2, c3)]
+    pr('E2')
+    conds += [And(mt1_exists, Eq(n, 0), p < m, cstar.is_positive is True, c12, c1, c2, c3)]
+    pr('E3')
+    conds += [And(mt1_exists, Eq(m, 0), q < n, cstar.is_positive is True, c12, c1, c2, c3)]
+    pr('E4')
+
+    # Let's short-circuit if this worked ...
+    # the rest is corner-cases and terrible to read.
+    r = Or(*conds)
+    if _eval_cond(r) != False:
+        return r
+
+    conds += [And(m + n > p, Eq(t, 0), Eq(phi, 0), s.is_positive is True, bstar.is_positive is True, cstar.is_negative is True,
+                  Abs(unbranched_argument(omega)) < (m + n - p + 1)*pi,
+                  c1, c2, c10, c14, c15)]  # 24
+    pr(24)
+    conds += [And(m + n > q, Eq(s, 0), Eq(phi, 0), t.is_positive is True, bstar.is_positive is True, cstar.is_negative is True,
+                  Abs(unbranched_argument(omega)) < (m + n - q + 1)*pi,
+                  c1, c3, c10, c14, c15)]  # 25
+    pr(25)
+    conds += [And(Eq(p, q - 1), Eq(t, 0), Eq(phi, 0), s.is_positive is True, bstar.is_positive is True,
+                  cstar >= 0, cstar*pi < Abs(unbranched_argument(omega)),
+                  c1, c2, c10, c14, c15)]  # 26
+    pr(26)
+    conds += [And(Eq(p, q + 1), Eq(s, 0), Eq(phi, 0), t.is_positive is True, bstar.is_positive is True,
+                  cstar >= 0, cstar*pi < Abs(unbranched_argument(omega)),
+                  c1, c3, c10, c14, c15)]  # 27
+    pr(27)
+    conds += [And(p < q - 1, Eq(t, 0), Eq(phi, 0), s.is_positive is True, bstar.is_positive is True,
+                  cstar >= 0, cstar*pi < Abs(unbranched_argument(omega)),
+                  Abs(unbranched_argument(omega)) < (m + n - p + 1)*pi,
+                  c1, c2, c10, c14, c15)]  # 28
+    pr(28)
+    conds += [And(
+        p > q + 1, Eq(s, 0), Eq(phi, 0), t.is_positive is True, bstar.is_positive is True, cstar >= 0,
+                  cstar*pi < Abs(unbranched_argument(omega)),
+                  Abs(unbranched_argument(omega)) < (m + n - q + 1)*pi,
+                  c1, c3, c10, c14, c15)]  # 29
+    pr(29)
+    conds += [And(Eq(n, 0), Eq(phi, 0), s + t > 0, m.is_positive is True, cstar.is_positive is True, bstar.is_negative is True,
+                  Abs(unbranched_argument(sigma)) < (s + t - u + 1)*pi,
+                  c1, c2, c12, c14, c15)]  # 30
+    pr(30)
+    conds += [And(Eq(m, 0), Eq(phi, 0), s + t > v, n.is_positive is True, cstar.is_positive is True, bstar.is_negative is True,
+                  Abs(unbranched_argument(sigma)) < (s + t - v + 1)*pi,
+                  c1, c3, c12, c14, c15)]  # 31
+    pr(31)
+    conds += [And(Eq(n, 0), Eq(phi, 0), Eq(u, v - 1), m.is_positive is True, cstar.is_positive is True,
+                  bstar >= 0, bstar*pi < Abs(unbranched_argument(sigma)),
+                  Abs(unbranched_argument(sigma)) < (bstar + 1)*pi,
+                  c1, c2, c12, c14, c15)]  # 32
+    pr(32)
+    conds += [And(Eq(m, 0), Eq(phi, 0), Eq(u, v + 1), n.is_positive is True, cstar.is_positive is True,
+                  bstar >= 0, bstar*pi < Abs(unbranched_argument(sigma)),
+                  Abs(unbranched_argument(sigma)) < (bstar + 1)*pi,
+                  c1, c3, c12, c14, c15)]  # 33
+    pr(33)
+    conds += [And(
+        Eq(n, 0), Eq(phi, 0), u < v - 1, m.is_positive is True, cstar.is_positive is True, bstar >= 0,
+        bstar*pi < Abs(unbranched_argument(sigma)),
+        Abs(unbranched_argument(sigma)) < (s + t - u + 1)*pi,
+        c1, c2, c12, c14, c15)]  # 34
+    pr(34)
+    conds += [And(
+        Eq(m, 0), Eq(phi, 0), u > v + 1, n.is_positive is True, cstar.is_positive is True, bstar >= 0,
+        bstar*pi < Abs(unbranched_argument(sigma)),
+        Abs(unbranched_argument(sigma)) < (s + t - v + 1)*pi,
+        c1, c3, c12, c14, c15)]  # 35
+    pr(35)
+
+    return Or(*conds)
+
+    # NOTE An alternative, but as far as I can tell weaker, set of conditions
+    #      can be found in [L, section 5.6.2].
+
+
+def _int0oo(g1, g2, x):
+    """
+    Express integral from zero to infinity g1*g2 using a G function,
+    assuming the necessary conditions are fulfilled.
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.meijerint import _int0oo
+    >>> from sympy.abc import s, t, m
+    >>> from sympy import meijerg, S
+    >>> g1 = meijerg([], [], [-S(1)/2, 0], [], s**2*t/4)
+    >>> g2 = meijerg([], [], [m/2], [-m/2], t/4)
+    >>> _int0oo(g1, g2, t)
+    4*meijerg(((0, 1/2), ()), ((m/2,), (-m/2,)), s**(-2))/s**2
+    """
+    # See: [L, section 5.6.2, equation (1)]
+    eta, _ = _get_coeff_exp(g1.argument, x)
+    omega, _ = _get_coeff_exp(g2.argument, x)
+
+    def neg(l):
+        return [-x for x in l]
+    a1 = neg(g1.bm) + list(g2.an)
+    a2 = list(g2.aother) + neg(g1.bother)
+    b1 = neg(g1.an) + list(g2.bm)
+    b2 = list(g2.bother) + neg(g1.aother)
+    return meijerg(a1, a2, b1, b2, omega/eta)/eta
+
+
+def _rewrite_inversion(fac, po, g, x):
+    """ Absorb ``po`` == x**s into g. """
+    _, s = _get_coeff_exp(po, x)
+    a, b = _get_coeff_exp(g.argument, x)
+
+    def tr(l):
+        return [t + s/b for t in l]
+    from sympy.simplify import powdenest
+    return (powdenest(fac/a**(s/b), polar=True),
+            meijerg(tr(g.an), tr(g.aother), tr(g.bm), tr(g.bother), g.argument))
+
+
+def _check_antecedents_inversion(g, x):
+    """ Check antecedents for the laplace inversion integral. """
+    _debug('Checking antecedents for inversion:')
+    z = g.argument
+    _, e = _get_coeff_exp(z, x)
+    if e < 0:
+        _debug('  Flipping G.')
+        # We want to assume that argument gets large as |x| -> oo
+        return _check_antecedents_inversion(_flip_g(g), x)
+
+    def statement_half(a, b, c, z, plus):
+        coeff, exponent = _get_coeff_exp(z, x)
+        a *= exponent
+        b *= coeff**c
+        c *= exponent
+        conds = []
+        wp = b*exp(S.ImaginaryUnit*re(c)*pi/2)
+        wm = b*exp(-S.ImaginaryUnit*re(c)*pi/2)
+        if plus:
+            w = wp
+        else:
+            w = wm
+        conds += [And(Or(Eq(b, 0), re(c) <= 0), re(a) <= -1)]
+        conds += [And(Ne(b, 0), Eq(im(c), 0), re(c) > 0, re(w) < 0)]
+        conds += [And(Ne(b, 0), Eq(im(c), 0), re(c) > 0, re(w) <= 0,
+                      re(a) <= -1)]
+        return Or(*conds)
+
+    def statement(a, b, c, z):
+        """ Provide a convergence statement for z**a * exp(b*z**c),
+             c/f sphinx docs. """
+        return And(statement_half(a, b, c, z, True),
+                   statement_half(a, b, c, z, False))
+
+    # Notations from [L], section 5.7-10
+    m, n, p, q = S([len(g.bm), len(g.an), len(g.ap), len(g.bq)])
+    tau = m + n - p
+    nu = q - m - n
+    rho = (tau - nu)/2
+    sigma = q - p
+    if sigma == 1:
+        epsilon = S.Half
+    elif sigma > 1:
+        epsilon = 1
+    else:
+        epsilon = S.NaN
+    theta = ((1 - sigma)/2 + Add(*g.bq) - Add(*g.ap))/sigma
+    delta = g.delta
+    _debugf('  m=%s, n=%s, p=%s, q=%s, tau=%s, nu=%s, rho=%s, sigma=%s',
+            (m, n, p, q, tau, nu, rho, sigma))
+    _debugf('  epsilon=%s, theta=%s, delta=%s', (epsilon, theta, delta))
+
+    # First check if the computation is valid.
+    if not (g.delta >= e/2 or (p >= 1 and p >= q)):
+        _debug('  Computation not valid for these parameters.')
+        return False
+
+    # Now check if the inversion integral exists.
+
+    # Test "condition A"
+    for a, b in itertools.product(g.an, g.bm):
+        if (a - b).is_integer and a > b:
+            _debug('  Not a valid G function.')
+            return False
+
+    # There are two cases. If p >= q, we can directly use a slater expansion
+    # like [L], 5.2 (11). Note in particular that the asymptotics of such an
+    # expansion even hold when some of the parameters differ by integers, i.e.
+    # the formula itself would not be valid! (b/c G functions are cts. in their
+    # parameters)
+    # When p < q, we need to use the theorems of [L], 5.10.
+
+    if p >= q:
+        _debug('  Using asymptotic Slater expansion.')
+        return And(*[statement(a - 1, 0, 0, z) for a in g.an])
+
+    def E(z):
+        return And(*[statement(a - 1, 0, 0, z) for a in g.an])
+
+    def H(z):
+        return statement(theta, -sigma, 1/sigma, z)
+
+    def Hp(z):
+        return statement_half(theta, -sigma, 1/sigma, z, True)
+
+    def Hm(z):
+        return statement_half(theta, -sigma, 1/sigma, z, False)
+
+    # [L], section 5.10
+    conds = []
+    # Theorem 1 -- p < q from test above
+    conds += [And(1 <= n, 1 <= m, rho*pi - delta >= pi/2, delta > 0,
+                  E(z*exp(S.ImaginaryUnit*pi*(nu + 1))))]
+    # Theorem 2, statements (2) and (3)
+    conds += [And(p + 1 <= m, m + 1 <= q, delta > 0, delta < pi/2, n == 0,
+                  (m - p + 1)*pi - delta >= pi/2,
+                  Hp(z*exp(S.ImaginaryUnit*pi*(q - m))),
+                  Hm(z*exp(-S.ImaginaryUnit*pi*(q - m))))]
+    # Theorem 2, statement (5)  -- p < q from test above
+    conds += [And(m == q, n == 0, delta > 0,
+                  (sigma + epsilon)*pi - delta >= pi/2, H(z))]
+    # Theorem 3, statements (6) and (7)
+    conds += [And(Or(And(p <= q - 2, 1 <= tau, tau <= sigma/2),
+                     And(p + 1 <= m + n, m + n <= (p + q)/2)),
+                  delta > 0, delta < pi/2, (tau + 1)*pi - delta >= pi/2,
+                  Hp(z*exp(S.ImaginaryUnit*pi*nu)),
+                  Hm(z*exp(-S.ImaginaryUnit*pi*nu)))]
+    # Theorem 4, statements (10) and (11)  -- p < q from test above
+    conds += [And(1 <= m, rho > 0, delta > 0, delta + rho*pi < pi/2,
+                  (tau + epsilon)*pi - delta >= pi/2,
+                  Hp(z*exp(S.ImaginaryUnit*pi*nu)),
+                  Hm(z*exp(-S.ImaginaryUnit*pi*nu)))]
+    # Trivial case
+    conds += [m == 0]
+
+    # TODO
+    # Theorem 5 is quite general
+    # Theorem 6 contains special cases for q=p+1
+
+    return Or(*conds)
+
+
+def _int_inversion(g, x, t):
+    """
+    Compute the laplace inversion integral, assuming the formula applies.
+    """
+    b, a = _get_coeff_exp(g.argument, x)
+    C, g = _inflate_fox_h(meijerg(g.an, g.aother, g.bm, g.bother, b/t**a), -a)
+    return C/t*g
+
+
+####################################################################
+# Finally, the real meat.
+####################################################################
+
+_lookup_table = None
+
+
+@cacheit
+@timeit
+def _rewrite_single(f, x, recursive=True):
+    """
+    Try to rewrite f as a sum of single G functions of the form
+    C*x**s*G(a*x**b), where b is a rational number and C is independent of x.
+    We guarantee that result.argument.as_coeff_mul(x) returns (a, (x**b,))
+    or (a, ()).
+    Returns a list of tuples (C, s, G) and a condition cond.
+    Returns None on failure.
+    """
+    from .transforms import (mellin_transform, inverse_mellin_transform,
+        IntegralTransformError, MellinTransformStripError)
+
+    global _lookup_table
+    if not _lookup_table:
+        _lookup_table = {}
+        _create_lookup_table(_lookup_table)
+
+    if isinstance(f, meijerg):
+        coeff, m = factor(f.argument, x).as_coeff_mul(x)
+        if len(m) > 1:
+            return None
+        m = m[0]
+        if m.is_Pow:
+            if m.base != x or not m.exp.is_Rational:
+                return None
+        elif m != x:
+            return None
+        return [(1, 0, meijerg(f.an, f.aother, f.bm, f.bother, coeff*m))], True
+
+    f_ = f
+    f = f.subs(x, z)
+    t = _mytype(f, z)
+    if t in _lookup_table:
+        l = _lookup_table[t]
+        for formula, terms, cond, hint in l:
+            subs = f.match(formula, old=True)
+            if subs:
+                subs_ = {}
+                for fro, to in subs.items():
+                    subs_[fro] = unpolarify(polarify(to, lift=True),
+                                            exponents_only=True)
+                subs = subs_
+                if not isinstance(hint, bool):
+                    hint = hint.subs(subs)
+                if hint == False:
+                    continue
+                if not isinstance(cond, (bool, BooleanAtom)):
+                    cond = unpolarify(cond.subs(subs))
+                if _eval_cond(cond) == False:
+                    continue
+                if not isinstance(terms, list):
+                    terms = terms(subs)
+                res = []
+                for fac, g in terms:
+                    r1 = _get_coeff_exp(unpolarify(fac.subs(subs).subs(z, x),
+                                                   exponents_only=True), x)
+                    try:
+                        g = g.subs(subs).subs(z, x)
+                    except ValueError:
+                        continue
+                    # NOTE these substitutions can in principle introduce oo,
+                    #      zoo and other absurdities. It shouldn't matter,
+                    #      but better be safe.
+                    if Tuple(*(r1 + (g,))).has(S.Infinity, S.ComplexInfinity, S.NegativeInfinity):
+                        continue
+                    g = meijerg(g.an, g.aother, g.bm, g.bother,
+                                unpolarify(g.argument, exponents_only=True))
+                    res.append(r1 + (g,))
+                if res:
+                    return res, cond
+
+    # try recursive mellin transform
+    if not recursive:
+        return None
+    _debug('Trying recursive Mellin transform method.')
+
+    def my_imt(F, s, x, strip):
+        """ Calling simplify() all the time is slow and not helpful, since
+            most of the time it only factors things in a way that has to be
+            un-done anyway. But sometimes it can remove apparent poles. """
+        # XXX should this be in inverse_mellin_transform?
+        try:
+            return inverse_mellin_transform(F, s, x, strip,
+                                            as_meijerg=True, needeval=True)
+        except MellinTransformStripError:
+            from sympy.simplify import simplify
+            return inverse_mellin_transform(
+                simplify(cancel(expand(F))), s, x, strip,
+                as_meijerg=True, needeval=True)
+    f = f_
+    s = _dummy('s', 'rewrite-single', f)
+    # to avoid infinite recursion, we have to force the two g functions case
+
+    def my_integrator(f, x):
+        r = _meijerint_definite_4(f, x, only_double=True)
+        if r is not None:
+            from sympy.simplify import hyperexpand
+            res, cond = r
+            res = _my_unpolarify(hyperexpand(res, rewrite='nonrepsmall'))
+            return Piecewise((res, cond),
+                             (Integral(f, (x, S.Zero, S.Infinity)), True))
+        return Integral(f, (x, S.Zero, S.Infinity))
+    try:
+        F, strip, _ = mellin_transform(f, x, s, integrator=my_integrator,
+                                       simplify=False, needeval=True)
+        g = my_imt(F, s, x, strip)
+    except IntegralTransformError:
+        g = None
+    if g is None:
+        # We try to find an expression by analytic continuation.
+        # (also if the dummy is already in the expression, there is no point in
+        #  putting in another one)
+        a = _dummy_('a', 'rewrite-single')
+        if a not in f.free_symbols and _is_analytic(f, x):
+            try:
+                F, strip, _ = mellin_transform(f.subs(x, a*x), x, s,
+                                               integrator=my_integrator,
+                                               needeval=True, simplify=False)
+                g = my_imt(F, s, x, strip).subs(a, 1)
+            except IntegralTransformError:
+                g = None
+    if g is None or g.has(S.Infinity, S.NaN, S.ComplexInfinity):
+        _debug('Recursive Mellin transform failed.')
+        return None
+    args = Add.make_args(g)
+    res = []
+    for f in args:
+        c, m = f.as_coeff_mul(x)
+        if len(m) > 1:
+            raise NotImplementedError('Unexpected form...')
+        g = m[0]
+        a, b = _get_coeff_exp(g.argument, x)
+        res += [(c, 0, meijerg(g.an, g.aother, g.bm, g.bother,
+                               unpolarify(polarify(
+                                   a, lift=True), exponents_only=True)
+                               *x**b))]
+    _debug('Recursive Mellin transform worked:', g)
+    return res, True
+
+
+def _rewrite1(f, x, recursive=True):
+    """
+    Try to rewrite ``f`` using a (sum of) single G functions with argument a*x**b.
+    Return fac, po, g such that f = fac*po*g, fac is independent of ``x``.
+    and po = x**s.
+    Here g is a result from _rewrite_single.
+    Return None on failure.
+    """
+    fac, po, g = _split_mul(f, x)
+    g = _rewrite_single(g, x, recursive)
+    if g:
+        return fac, po, g[0], g[1]
+
+
+def _rewrite2(f, x):
+    """
+    Try to rewrite ``f`` as a product of two G functions of arguments a*x**b.
+    Return fac, po, g1, g2 such that f = fac*po*g1*g2, where fac is
+    independent of x and po is x**s.
+    Here g1 and g2 are results of _rewrite_single.
+    Returns None on failure.
+    """
+    fac, po, g = _split_mul(f, x)
+    if any(_rewrite_single(expr, x, False) is None for expr in _mul_args(g)):
+        return None
+    l = _mul_as_two_parts(g)
+    if not l:
+        return None
+    l = list(ordered(l, [
+        lambda p: max(len(_exponents(p[0], x)), len(_exponents(p[1], x))),
+        lambda p: max(len(_functions(p[0], x)), len(_functions(p[1], x))),
+        lambda p: max(len(_find_splitting_points(p[0], x)),
+                      len(_find_splitting_points(p[1], x)))]))
+
+    for recursive, (fac1, fac2) in itertools.product((False, True), l):
+        g1 = _rewrite_single(fac1, x, recursive)
+        g2 = _rewrite_single(fac2, x, recursive)
+        if g1 and g2:
+            cond = And(g1[1], g2[1])
+            if cond != False:
+                return fac, po, g1[0], g2[0], cond
+
+
+def meijerint_indefinite(f, x):
+    """
+    Compute an indefinite integral of ``f`` by rewriting it as a G function.
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.meijerint import meijerint_indefinite
+    >>> from sympy import sin
+    >>> from sympy.abc import x
+    >>> meijerint_indefinite(sin(x), x)
+    -cos(x)
+    """
+    f = sympify(f)
+    results = []
+    for a in sorted(_find_splitting_points(f, x) | {S.Zero}, key=default_sort_key):
+        res = _meijerint_indefinite_1(f.subs(x, x + a), x)
+        if not res:
+            continue
+        res = res.subs(x, x - a)
+        if _has(res, hyper, meijerg):
+            results.append(res)
+        else:
+            return res
+    if f.has(HyperbolicFunction):
+        _debug('Try rewriting hyperbolics in terms of exp.')
+        rv = meijerint_indefinite(
+            _rewrite_hyperbolics_as_exp(f), x)
+        if rv:
+            if not isinstance(rv, list):
+                from sympy.simplify.radsimp import collect
+                return collect(factor_terms(rv), rv.atoms(exp))
+            results.extend(rv)
+    if results:
+        return next(ordered(results))
+
+
+def _meijerint_indefinite_1(f, x):
+    """ Helper that does not attempt any substitution. """
+    _debug('Trying to compute the indefinite integral of', f, 'wrt', x)
+    from sympy.simplify import hyperexpand, powdenest
+
+    gs = _rewrite1(f, x)
+    if gs is None:
+        # Note: the code that calls us will do expand() and try again
+        return None
+
+    fac, po, gl, cond = gs
+    _debug(' could rewrite:', gs)
+    res = S.Zero
+    for C, s, g in gl:
+        a, b = _get_coeff_exp(g.argument, x)
+        _, c = _get_coeff_exp(po, x)
+        c += s
+
+        # we do a substitution t=a*x**b, get integrand fac*t**rho*g
+        fac_ = fac * C * x**(1 + c) / b
+        rho = (c + 1)/b
+
+        # we now use t**rho*G(params, t) = G(params + rho, t)
+        # [L, page 150, equation (4)]
+        # and integral G(params, t) dt = G(1, params+1, 0, t)
+        #   (or a similar expression with 1 and 0 exchanged ... pick the one
+        #    which yields a well-defined function)
+        # [R, section 5]
+        # (Note that this dummy will immediately go away again, so we
+        #  can safely pass S.One for ``expr``.)
+        t = _dummy('t', 'meijerint-indefinite', S.One)
+
+        def tr(p):
+            return [a + rho for a in p]
+        if any(b.is_integer and (b <= 0) == True for b in tr(g.bm)):
+            r = -meijerg(
+                list(g.an), list(g.aother) + [1-rho], list(g.bm) + [-rho], list(g.bother), t)
+        else:
+            r = meijerg(
+                list(g.an) + [1-rho], list(g.aother), list(g.bm), list(g.bother) + [-rho], t)
+        # The antiderivative is most often expected to be defined
+        # in the neighborhood of  x = 0.
+        if b.is_extended_nonnegative and not f.subs(x, 0).has(S.NaN, S.ComplexInfinity):
+            place = 0  # Assume we can expand at zero
+        else:
+            place = None
+        r = hyperexpand(r.subs(t, a*x**b), place=place)
+
+        # now substitute back
+        # Note: we really do want the powers of x to combine.
+        res += powdenest(fac_*r, polar=True)
+
+    def _clean(res):
+        """This multiplies out superfluous powers of x we created, and chops off
+        constants:
+
+            >> _clean(x*(exp(x)/x - 1/x) + 3)
+            exp(x)
+
+        cancel is used before mul_expand since it is possible for an
+        expression to have an additive constant that does not become isolated
+        with simple expansion. Such a situation was identified in issue 6369:
+
+        Examples
+        ========
+
+        >>> from sympy import sqrt, cancel
+        >>> from sympy.abc import x
+        >>> a = sqrt(2*x + 1)
+        >>> bad = (3*x*a**5 + 2*x - a**5 + 1)/a**2
+        >>> bad.expand().as_independent(x)[0]
+        0
+        >>> cancel(bad).expand().as_independent(x)[0]
+        1
+        """
+        res = expand_mul(cancel(res), deep=False)
+        return Add._from_args(res.as_coeff_add(x)[1])
+
+    res = piecewise_fold(res, evaluate=None)
+    if res.is_Piecewise:
+        newargs = []
+        for e, c in res.args:
+            e = _my_unpolarify(_clean(e))
+            newargs += [(e, c)]
+        res = Piecewise(*newargs, evaluate=False)
+    else:
+        res = _my_unpolarify(_clean(res))
+    return Piecewise((res, _my_unpolarify(cond)), (Integral(f, x), True))
+
+
+@timeit
+def meijerint_definite(f, x, a, b):
+    """
+    Integrate ``f`` over the interval [``a``, ``b``], by rewriting it as a product
+    of two G functions, or as a single G function.
+
+    Return res, cond, where cond are convergence conditions.
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.meijerint import meijerint_definite
+    >>> from sympy import exp, oo
+    >>> from sympy.abc import x
+    >>> meijerint_definite(exp(-x**2), x, -oo, oo)
+    (sqrt(pi), True)
+
+    This function is implemented as a succession of functions
+    meijerint_definite, _meijerint_definite_2, _meijerint_definite_3,
+    _meijerint_definite_4. Each function in the list calls the next one
+    (presumably) several times. This means that calling meijerint_definite
+    can be very costly.
+    """
+    # This consists of three steps:
+    # 1) Change the integration limits to 0, oo
+    # 2) Rewrite in terms of G functions
+    # 3) Evaluate the integral
+    #
+    # There are usually several ways of doing this, and we want to try all.
+    # This function does (1), calls _meijerint_definite_2 for step (2).
+    _debugf('Integrating %s wrt %s from %s to %s.', (f, x, a, b))
+    f = sympify(f)
+    if f.has(DiracDelta):
+        _debug('Integrand has DiracDelta terms - giving up.')
+        return None
+
+    if f.has(SingularityFunction):
+        _debug('Integrand has Singularity Function terms - giving up.')
+        return None
+
+    f_, x_, a_, b_ = f, x, a, b
+
+    # Let's use a dummy in case any of the boundaries has x.
+    d = Dummy('x')
+    f = f.subs(x, d)
+    x = d
+
+    if a == b:
+        return (S.Zero, True)
+
+    results = []
+    if a is S.NegativeInfinity and b is not S.Infinity:
+        return meijerint_definite(f.subs(x, -x), x, -b, -a)
+
+    elif a is S.NegativeInfinity:
+        # Integrating -oo to oo. We need to find a place to split the integral.
+        _debug('  Integrating -oo to +oo.')
+        innermost = _find_splitting_points(f, x)
+        _debug('  Sensible splitting points:', innermost)
+        for c in sorted(innermost, key=default_sort_key, reverse=True) + [S.Zero]:
+            _debug('  Trying to split at', c)
+            if not c.is_extended_real:
+                _debug('  Non-real splitting point.')
+                continue
+            res1 = _meijerint_definite_2(f.subs(x, x + c), x)
+            if res1 is None:
+                _debug('  But could not compute first integral.')
+                continue
+            res2 = _meijerint_definite_2(f.subs(x, c - x), x)
+            if res2 is None:
+                _debug('  But could not compute second integral.')
+                continue
+            res1, cond1 = res1
+            res2, cond2 = res2
+            cond = _condsimp(And(cond1, cond2))
+            if cond == False:
+                _debug('  But combined condition is always false.')
+                continue
+            res = res1 + res2
+            return res, cond
+
+    elif a is S.Infinity:
+        res = meijerint_definite(f, x, b, S.Infinity)
+        return -res[0], res[1]
+
+    elif (a, b) == (S.Zero, S.Infinity):
+        # This is a common case - try it directly first.
+        res = _meijerint_definite_2(f, x)
+        if res:
+            if _has(res[0], meijerg):
+                results.append(res)
+            else:
+                return res
+
+    else:
+        if b is S.Infinity:
+            for split in _find_splitting_points(f, x):
+                if (a - split >= 0) == True:
+                    _debugf('Trying x -> x + %s', split)
+                    res = _meijerint_definite_2(f.subs(x, x + split)
+                                                *Heaviside(x + split - a), x)
+                    if res:
+                        if _has(res[0], meijerg):
+                            results.append(res)
+                        else:
+                            return res
+
+        f = f.subs(x, x + a)
+        b = b - a
+        a = 0
+        if b is not S.Infinity:
+            phi = exp(S.ImaginaryUnit*arg(b))
+            b = Abs(b)
+            f = f.subs(x, phi*x)
+            f *= Heaviside(b - x)*phi
+            b = S.Infinity
+
+        _debug('Changed limits to', a, b)
+        _debug('Changed function to', f)
+        res = _meijerint_definite_2(f, x)
+        if res:
+            if _has(res[0], meijerg):
+                results.append(res)
+            else:
+                return res
+    if f_.has(HyperbolicFunction):
+        _debug('Try rewriting hyperbolics in terms of exp.')
+        rv = meijerint_definite(
+            _rewrite_hyperbolics_as_exp(f_), x_, a_, b_)
+        if rv:
+            if not isinstance(rv, list):
+                from sympy.simplify.radsimp import collect
+                rv = (collect(factor_terms(rv[0]), rv[0].atoms(exp)),) + rv[1:]
+                return rv
+            results.extend(rv)
+    if results:
+        return next(ordered(results))
+
+
+def _guess_expansion(f, x):
+    """ Try to guess sensible rewritings for integrand f(x). """
+    res = [(f, 'original integrand')]
+
+    orig = res[-1][0]
+    saw = {orig}
+    expanded = expand_mul(orig)
+    if expanded not in saw:
+        res += [(expanded, 'expand_mul')]
+        saw.add(expanded)
+
+    expanded = expand(orig)
+    if expanded not in saw:
+        res += [(expanded, 'expand')]
+        saw.add(expanded)
+
+    if orig.has(TrigonometricFunction, HyperbolicFunction):
+        expanded = expand_mul(expand_trig(orig))
+        if expanded not in saw:
+            res += [(expanded, 'expand_trig, expand_mul')]
+            saw.add(expanded)
+
+    if orig.has(cos, sin):
+        from sympy.simplify.fu import sincos_to_sum
+        reduced = sincos_to_sum(orig)
+        if reduced not in saw:
+            res += [(reduced, 'trig power reduction')]
+            saw.add(reduced)
+
+    return res
+
+
+def _meijerint_definite_2(f, x):
+    """
+    Try to integrate f dx from zero to infinity.
+
+    The body of this function computes various 'simplifications'
+    f1, f2, ... of f (e.g. by calling expand_mul(), trigexpand()
+    - see _guess_expansion) and calls _meijerint_definite_3 with each of
+    these in succession.
+    If _meijerint_definite_3 succeeds with any of the simplified functions,
+    returns this result.
+    """
+    # This function does preparation for (2), calls
+    # _meijerint_definite_3 for (2) and (3) combined.
+
+    # use a positive dummy - we integrate from 0 to oo
+    # XXX if a nonnegative symbol is used there will be test failures
+    dummy = _dummy('x', 'meijerint-definite2', f, positive=True)
+    f = f.subs(x, dummy)
+    x = dummy
+
+    if f == 0:
+        return S.Zero, True
+
+    for g, explanation in _guess_expansion(f, x):
+        _debug('Trying', explanation)
+        res = _meijerint_definite_3(g, x)
+        if res:
+            return res
+
+
+def _meijerint_definite_3(f, x):
+    """
+    Try to integrate f dx from zero to infinity.
+
+    This function calls _meijerint_definite_4 to try to compute the
+    integral. If this fails, it tries using linearity.
+    """
+    res = _meijerint_definite_4(f, x)
+    if res and res[1] != False:
+        return res
+    if f.is_Add:
+        _debug('Expanding and evaluating all terms.')
+        ress = [_meijerint_definite_4(g, x) for g in f.args]
+        if all(r is not None for r in ress):
+            conds = []
+            res = S.Zero
+            for r, c in ress:
+                res += r
+                conds += [c]
+            c = And(*conds)
+            if c != False:
+                return res, c
+
+
+def _my_unpolarify(f):
+    return _eval_cond(unpolarify(f))
+
+
+@timeit
+def _meijerint_definite_4(f, x, only_double=False):
+    """
+    Try to integrate f dx from zero to infinity.
+
+    Explanation
+    ===========
+
+    This function tries to apply the integration theorems found in literature,
+    i.e. it tries to rewrite f as either one or a product of two G-functions.
+
+    The parameter ``only_double`` is used internally in the recursive algorithm
+    to disable trying to rewrite f as a single G-function.
+    """
+    from sympy.simplify import hyperexpand
+    # This function does (2) and (3)
+    _debug('Integrating', f)
+    # Try single G function.
+    if not only_double:
+        gs = _rewrite1(f, x, recursive=False)
+        if gs is not None:
+            fac, po, g, cond = gs
+            _debug('Could rewrite as single G function:', fac, po, g)
+            res = S.Zero
+            for C, s, f in g:
+                if C == 0:
+                    continue
+                C, f = _rewrite_saxena_1(fac*C, po*x**s, f, x)
+                res += C*_int0oo_1(f, x)
+                cond = And(cond, _check_antecedents_1(f, x))
+                if cond == False:
+                    break
+            cond = _my_unpolarify(cond)
+            if cond == False:
+                _debug('But cond is always False.')
+            else:
+                _debug('Result before branch substitutions is:', res)
+                return _my_unpolarify(hyperexpand(res)), cond
+
+    # Try two G functions.
+    gs = _rewrite2(f, x)
+    if gs is not None:
+        for full_pb in [False, True]:
+            fac, po, g1, g2, cond = gs
+            _debug('Could rewrite as two G functions:', fac, po, g1, g2)
+            res = S.Zero
+            for C1, s1, f1 in g1:
+                for C2, s2, f2 in g2:
+                    r = _rewrite_saxena(fac*C1*C2, po*x**(s1 + s2),
+                                        f1, f2, x, full_pb)
+                    if r is None:
+                        _debug('Non-rational exponents.')
+                        return
+                    C, f1_, f2_ = r
+                    _debug('Saxena subst for yielded:', C, f1_, f2_)
+                    cond = And(cond, _check_antecedents(f1_, f2_, x))
+                    if cond == False:
+                        break
+                    res += C*_int0oo(f1_, f2_, x)
+                else:
+                    continue
+                break
+            cond = _my_unpolarify(cond)
+            if cond == False:
+                _debugf('But cond is always False (full_pb=%s).', full_pb)
+            else:
+                _debugf('Result before branch substitutions is: %s', (res, ))
+                if only_double:
+                    return res, cond
+                return _my_unpolarify(hyperexpand(res)), cond
+
+
+def meijerint_inversion(f, x, t):
+    r"""
+    Compute the inverse laplace transform
+    $\int_{c+i\infty}^{c-i\infty} f(x) e^{tx}\, dx$,
+    for real c larger than the real part of all singularities of ``f``.
+
+    Note that ``t`` is always assumed real and positive.
+
+    Return None if the integral does not exist or could not be evaluated.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, t
+    >>> from sympy.integrals.meijerint import meijerint_inversion
+    >>> meijerint_inversion(1/x, x, t)
+    Heaviside(t)
+    """
+    f_ = f
+    t_ = t
+    t = Dummy('t', polar=True)  # We don't want sqrt(t**2) = abs(t) etc
+    f = f.subs(t_, t)
+    _debug('Laplace-inverting', f)
+    if not _is_analytic(f, x):
+        _debug('But expression is not analytic.')
+        return None
+    # Exponentials correspond to shifts; we filter them out and then
+    # shift the result later.  If we are given an Add this will not
+    # work, but the calling code will take care of that.
+    shift = S.Zero
+
+    if f.is_Mul:
+        args = list(f.args)
+    elif isinstance(f, exp):
+        args = [f]
+    else:
+        args = None
+
+    if args:
+        newargs = []
+        exponentials = []
+        while args:
+            arg = args.pop()
+            if isinstance(arg, exp):
+                arg2 = expand(arg)
+                if arg2.is_Mul:
+                    args += arg2.args
+                    continue
+                try:
+                    a, b = _get_coeff_exp(arg.args[0], x)
+                except _CoeffExpValueError:
+                    b = 0
+                if b == 1:
+                    exponentials.append(a)
+                else:
+                    newargs.append(arg)
+            elif arg.is_Pow:
+                arg2 = expand(arg)
+                if arg2.is_Mul:
+                    args += arg2.args
+                    continue
+                if x not in arg.base.free_symbols:
+                    try:
+                        a, b = _get_coeff_exp(arg.exp, x)
+                    except _CoeffExpValueError:
+                        b = 0
+                    if b == 1:
+                        exponentials.append(a*log(arg.base))
+                newargs.append(arg)
+            else:
+                newargs.append(arg)
+        shift = Add(*exponentials)
+        f = Mul(*newargs)
+
+    if x not in f.free_symbols:
+        _debug('Expression consists of constant and exp shift:', f, shift)
+        cond = Eq(im(shift), 0)
+        if cond == False:
+            _debug('but shift is nonreal, cannot be a Laplace transform')
+            return None
+        res = f*DiracDelta(t + shift)
+        _debug('Result is a delta function, possibly conditional:', res, cond)
+        # cond is True or Eq
+        return Piecewise((res.subs(t, t_), cond))
+
+    gs = _rewrite1(f, x)
+    if gs is not None:
+        fac, po, g, cond = gs
+        _debug('Could rewrite as single G function:', fac, po, g)
+        res = S.Zero
+        for C, s, f in g:
+            C, f = _rewrite_inversion(fac*C, po*x**s, f, x)
+            res += C*_int_inversion(f, x, t)
+            cond = And(cond, _check_antecedents_inversion(f, x))
+            if cond == False:
+                break
+        cond = _my_unpolarify(cond)
+        if cond == False:
+            _debug('But cond is always False.')
+        else:
+            _debug('Result before branch substitution:', res)
+            from sympy.simplify import hyperexpand
+            res = _my_unpolarify(hyperexpand(res))
+            if not res.has(Heaviside):
+                res *= Heaviside(t)
+            res = res.subs(t, t + shift)
+            if not isinstance(cond, bool):
+                cond = cond.subs(t, t + shift)
+            from .transforms import InverseLaplaceTransform
+            return Piecewise((res.subs(t, t_), cond),
+                             (InverseLaplaceTransform(f_.subs(t, t_), x, t_, None), True))

.venv/lib/python3.12/site-packages/sympy/integrals/meijerint_doc.py

@@ -0,0 +1,38 @@
+""" This module cooks up a docstring when imported. Its only purpose is to
+    be displayed in the sphinx documentation. """
+
+from __future__ import annotations
+from typing import Any
+
+from sympy.integrals.meijerint import _create_lookup_table
+from sympy.core.add import Add
+from sympy.core.basic import Basic
+from sympy.core.expr import Expr
+from sympy.core.relational import Eq
+from sympy.core.symbol import Symbol
+from sympy.printing.latex import latex
+
+t: dict[tuple[type[Basic], ...], list[Any]] = {}
+_create_lookup_table(t)
+
+
+doc = ""
+for about, category in t.items():
+    if about == ():
+        doc += 'Elementary functions:\n\n'
+    else:
+        doc += 'Functions involving ' + ', '.join('`%s`' % latex(
+            list(category[0][0].atoms(func))[0]) for func in about) + ':\n\n'
+    for formula, gs, cond, hint in category:
+        if not isinstance(gs, list):
+            g: Expr = Symbol('\\text{generated}')
+        else:
+            g = Add(*[fac*f for (fac, f) in gs])
+        obj = Eq(formula, g)
+        if cond is True:
+            cond = ""
+        else:
+            cond = ',\\text{ if } %s' % latex(cond)
+        doc += ".. math::\n  %s%s\n\n" % (latex(obj), cond)
+
+__doc__ = doc