Add files using upload-large-folder tool

llmeval-env/lib/python3.10/site-packages/sympy/calculus/tests/test_finite_diff.py

@@ -0,0 +1,168 @@
+from itertools import product
+
+from sympy.core.function import (Function, diff)
+from sympy.core.numbers import Rational
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.exponential import exp
+from sympy.calculus.finite_diff import (
+    apply_finite_diff, differentiate_finite, finite_diff_weights,
+    _as_finite_diff
+)
+from sympy.testing.pytest import raises, warns_deprecated_sympy
+
+
+def test_apply_finite_diff():
+    x, h = symbols('x h')
+    f = Function('f')
+    assert (apply_finite_diff(1, [x-h, x+h], [f(x-h), f(x+h)], x) -
+            (f(x+h)-f(x-h))/(2*h)).simplify() == 0
+
+    assert (apply_finite_diff(1, [5, 6, 7], [f(5), f(6), f(7)], 5) -
+            (Rational(-3, 2)*f(5) + 2*f(6) - S.Half*f(7))).simplify() == 0
+    raises(ValueError, lambda: apply_finite_diff(1, [x, h], [f(x)]))
+
+
+def test_finite_diff_weights():
+
+    d = finite_diff_weights(1, [5, 6, 7], 5)
+    assert d[1][2] == [Rational(-3, 2), 2, Rational(-1, 2)]
+
+    # Table 1, p. 702 in doi:10.1090/S0025-5718-1988-0935077-0
+    # --------------------------------------------------------
+    xl = [0, 1, -1, 2, -2, 3, -3, 4, -4]
+
+    # d holds all coefficients
+    d = finite_diff_weights(4, xl, S.Zero)
+
+    # Zeroeth derivative
+    for i in range(5):
+        assert d[0][i] == [S.One] + [S.Zero]*8
+
+    # First derivative
+    assert d[1][0] == [S.Zero]*9
+    assert d[1][2] == [S.Zero, S.Half, Rational(-1, 2)] + [S.Zero]*6
+    assert d[1][4] == [S.Zero, Rational(2, 3), Rational(-2, 3), Rational(-1, 12), Rational(1, 12)] + [S.Zero]*4
+    assert d[1][6] == [S.Zero, Rational(3, 4), Rational(-3, 4), Rational(-3, 20), Rational(3, 20),
+                       Rational(1, 60), Rational(-1, 60)] + [S.Zero]*2
+    assert d[1][8] == [S.Zero, Rational(4, 5), Rational(-4, 5), Rational(-1, 5), Rational(1, 5),
+                       Rational(4, 105), Rational(-4, 105), Rational(-1, 280), Rational(1, 280)]
+
+    # Second derivative
+    for i in range(2):
+        assert d[2][i] == [S.Zero]*9
+    assert d[2][2] == [-S(2), S.One, S.One] + [S.Zero]*6
+    assert d[2][4] == [Rational(-5, 2), Rational(4, 3), Rational(4, 3), Rational(-1, 12), Rational(-1, 12)] + [S.Zero]*4
+    assert d[2][6] == [Rational(-49, 18), Rational(3, 2), Rational(3, 2), Rational(-3, 20), Rational(-3, 20),
+                       Rational(1, 90), Rational(1, 90)] + [S.Zero]*2
+    assert d[2][8] == [Rational(-205, 72), Rational(8, 5), Rational(8, 5), Rational(-1, 5), Rational(-1, 5),
+                       Rational(8, 315), Rational(8, 315), Rational(-1, 560), Rational(-1, 560)]
+
+    # Third derivative
+    for i in range(3):
+        assert d[3][i] == [S.Zero]*9
+    assert d[3][4] == [S.Zero, -S.One, S.One, S.Half, Rational(-1, 2)] + [S.Zero]*4
+    assert d[3][6] == [S.Zero, Rational(-13, 8), Rational(13, 8), S.One, -S.One,
+                       Rational(-1, 8), Rational(1, 8)] + [S.Zero]*2
+    assert d[3][8] == [S.Zero, Rational(-61, 30), Rational(61, 30), Rational(169, 120), Rational(-169, 120),
+                       Rational(-3, 10), Rational(3, 10), Rational(7, 240), Rational(-7, 240)]
+
+    # Fourth derivative
+    for i in range(4):
+        assert d[4][i] == [S.Zero]*9
+    assert d[4][4] == [S(6), -S(4), -S(4), S.One, S.One] + [S.Zero]*4
+    assert d[4][6] == [Rational(28, 3), Rational(-13, 2), Rational(-13, 2), S(2), S(2),
+                       Rational(-1, 6), Rational(-1, 6)] + [S.Zero]*2
+    assert d[4][8] == [Rational(91, 8), Rational(-122, 15), Rational(-122, 15), Rational(169, 60), Rational(169, 60),
+                       Rational(-2, 5), Rational(-2, 5), Rational(7, 240), Rational(7, 240)]
+
+    # Table 2, p. 703 in doi:10.1090/S0025-5718-1988-0935077-0
+    # --------------------------------------------------------
+    xl = [[j/S(2) for j in list(range(-i*2+1, 0, 2))+list(range(1, i*2+1, 2))]
+          for i in range(1, 5)]
+
+    # d holds all coefficients
+    d = [finite_diff_weights({0: 1, 1: 2, 2: 4, 3: 4}[i], xl[i], 0) for
+         i in range(4)]
+
+    # Zeroth derivative
+    assert d[0][0][1] == [S.Half, S.Half]
+    assert d[1][0][3] == [Rational(-1, 16), Rational(9, 16), Rational(9, 16), Rational(-1, 16)]
+    assert d[2][0][5] == [Rational(3, 256), Rational(-25, 256), Rational(75, 128), Rational(75, 128),
+                          Rational(-25, 256), Rational(3, 256)]
+    assert d[3][0][7] == [Rational(-5, 2048), Rational(49, 2048), Rational(-245, 2048), Rational(1225, 2048),
+                          Rational(1225, 2048), Rational(-245, 2048), Rational(49, 2048), Rational(-5, 2048)]
+
+    # First derivative
+    assert d[0][1][1] == [-S.One, S.One]
+    assert d[1][1][3] == [Rational(1, 24), Rational(-9, 8), Rational(9, 8), Rational(-1, 24)]
+    assert d[2][1][5] == [Rational(-3, 640), Rational(25, 384), Rational(-75, 64),
+                          Rational(75, 64), Rational(-25, 384), Rational(3, 640)]
+    assert d[3][1][7] == [Rational(5, 7168), Rational(-49, 5120),
+                          Rational(245, 3072), Rational(-1225, 1024),
+                          Rational(1225, 1024), Rational(-245, 3072),
+                          Rational(49, 5120), Rational(-5, 7168)]
+
+    # Reasonably the rest of the table is also correct... (testing of that
+    # deemed excessive at the moment)
+    raises(ValueError, lambda: finite_diff_weights(-1, [1, 2]))
+    raises(ValueError, lambda: finite_diff_weights(1.2, [1, 2]))
+    x = symbols('x')
+    raises(ValueError, lambda: finite_diff_weights(x, [1, 2]))
+
+
+def test_as_finite_diff():
+    x = symbols('x')
+    f = Function('f')
+    dx = Function('dx')
+
+    _as_finite_diff(f(x).diff(x), [x-2, x-1, x, x+1, x+2])
+
+    # Use of undefined functions in ``points``
+    df_true = -f(x+dx(x)/2-dx(x+dx(x)/2)/2) / dx(x+dx(x)/2) \
+              + f(x+dx(x)/2+dx(x+dx(x)/2)/2) / dx(x+dx(x)/2)
+    df_test = diff(f(x), x).as_finite_difference(points=dx(x), x0=x+dx(x)/2)
+    assert (df_test - df_true).simplify() == 0
+
+
+def test_differentiate_finite():
+    x, y, h = symbols('x y h')
+    f = Function('f')
+    with warns_deprecated_sympy():
+        res0 = differentiate_finite(f(x, y) + exp(42), x, y, evaluate=True)
+    xm, xp, ym, yp = [v + sign*S.Half for v, sign in product([x, y], [-1, 1])]
+    ref0 = f(xm, ym) + f(xp, yp) - f(xm, yp) - f(xp, ym)
+    assert (res0 - ref0).simplify() == 0
+
+    g = Function('g')
+    with warns_deprecated_sympy():
+        res1 = differentiate_finite(f(x)*g(x) + 42, x, evaluate=True)
+    ref1 = (-f(x - S.Half) + f(x + S.Half))*g(x) + \
+           (-g(x - S.Half) + g(x + S.Half))*f(x)
+    assert (res1 - ref1).simplify() == 0
+
+    res2 = differentiate_finite(f(x) + x**3 + 42, x, points=[x-1, x+1])
+    ref2 = (f(x + 1) + (x + 1)**3 - f(x - 1) - (x - 1)**3)/2
+    assert (res2 - ref2).simplify() == 0
+    raises(TypeError, lambda: differentiate_finite(f(x)*g(x), x,
+                                                   pints=[x-1, x+1]))
+
+    res3 = differentiate_finite(f(x)*g(x).diff(x), x)
+    ref3 = (-g(x) + g(x + 1))*f(x + S.Half) - (g(x) - g(x - 1))*f(x - S.Half)
+    assert res3 == ref3
+
+    res4 = differentiate_finite(f(x)*g(x).diff(x).diff(x), x)
+    ref4 = -((g(x - Rational(3, 2)) - 2*g(x - S.Half) + g(x + S.Half))*f(x - S.Half)) \
+           + (g(x - S.Half) - 2*g(x + S.Half) + g(x + Rational(3, 2)))*f(x + S.Half)
+    assert res4 == ref4
+
+    res5_expr = f(x).diff(x)*g(x).diff(x)
+    res5 = differentiate_finite(res5_expr, points=[x-h, x, x+h])
+    ref5 = (-2*f(x)/h + f(-h + x)/(2*h) + 3*f(h + x)/(2*h))*(-2*g(x)/h + g(-h + x)/(2*h) \
+           + 3*g(h + x)/(2*h))/(2*h) - (2*f(x)/h - 3*f(-h + x)/(2*h) - \
+           f(h + x)/(2*h))*(2*g(x)/h - 3*g(-h + x)/(2*h) - g(h + x)/(2*h))/(2*h)
+    assert res5 == ref5
+
+    res6 = res5.limit(h, 0).doit()
+    ref6 = diff(res5_expr, x)
+    assert res6 == ref6

llmeval-env/lib/python3.10/site-packages/sympy/calculus/tests/test_util.py

@@ -0,0 +1,331 @@
+from sympy.core.numbers import (E, I, Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import (Abs, re)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (cos, cot, csc, sec, sin, tan)
+from sympy.functions.special.error_functions import expint
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.simplify.simplify import simplify
+from sympy.calculus.util import (function_range, continuous_domain, not_empty_in,
+                                 periodicity, lcim, is_convex,
+                                 stationary_points, minimum, maximum)
+from sympy.sets.sets import (Interval, FiniteSet, Complement, Union)
+from sympy.testing.pytest import raises, _both_exp_pow
+from sympy.abc import x
+
+a = Symbol('a', real=True)
+
+def test_function_range():
+    x, y, a, b = symbols('x y a b')
+    assert function_range(sin(x), x, Interval(-pi/2, pi/2)
+        ) == Interval(-1, 1)
+    assert function_range(sin(x), x, Interval(0, pi)
+        ) == Interval(0, 1)
+    assert function_range(tan(x), x, Interval(0, pi)
+        ) == Interval(-oo, oo)
+    assert function_range(tan(x), x, Interval(pi/2, pi)
+        ) == Interval(-oo, 0)
+    assert function_range((x + 3)/(x - 2), x, Interval(-5, 5)
+        ) == Union(Interval(-oo, Rational(2, 7)), Interval(Rational(8, 3), oo))
+    assert function_range(1/(x**2), x, Interval(-1, 1)
+        ) == Interval(1, oo)
+    assert function_range(exp(x), x, Interval(-1, 1)
+        ) == Interval(exp(-1), exp(1))
+    assert function_range(log(x) - x, x, S.Reals
+        ) == Interval(-oo, -1)
+    assert function_range(sqrt(3*x - 1), x, Interval(0, 2)
+        ) == Interval(0, sqrt(5))
+    assert function_range(x*(x - 1) - (x**2 - x), x, S.Reals
+        ) == FiniteSet(0)
+    assert function_range(x*(x - 1) - (x**2 - x) + y, x, S.Reals
+        ) == FiniteSet(y)
+    assert function_range(sin(x), x, Union(Interval(-5, -3), FiniteSet(4))
+        ) == Union(Interval(-sin(3), 1), FiniteSet(sin(4)))
+    assert function_range(cos(x), x, Interval(-oo, -4)
+        ) == Interval(-1, 1)
+    assert function_range(cos(x), x, S.EmptySet) == S.EmptySet
+    assert function_range(x/sqrt(x**2+1), x, S.Reals) == Interval.open(-1,1)
+    raises(NotImplementedError, lambda : function_range(
+        exp(x)*(sin(x) - cos(x))/2 - x, x, S.Reals))
+    raises(NotImplementedError, lambda : function_range(
+        sin(x) + x, x, S.Reals)) # issue 13273
+    raises(NotImplementedError, lambda : function_range(
+        log(x), x, S.Integers))
+    raises(NotImplementedError, lambda : function_range(
+        sin(x)/2, x, S.Naturals))
+
+
+def test_continuous_domain():
+    x = Symbol('x')
+    assert continuous_domain(sin(x), x, Interval(0, 2*pi)) == Interval(0, 2*pi)
+    assert continuous_domain(tan(x), x, Interval(0, 2*pi)) == \
+        Union(Interval(0, pi/2, False, True), Interval(pi/2, pi*Rational(3, 2), True, True),
+              Interval(pi*Rational(3, 2), 2*pi, True, False))
+    assert continuous_domain((x - 1)/((x - 1)**2), x, S.Reals) == \
+        Union(Interval(-oo, 1, True, True), Interval(1, oo, True, True))
+    assert continuous_domain(log(x) + log(4*x - 1), x, S.Reals) == \
+        Interval(Rational(1, 4), oo, True, True)
+    assert continuous_domain(1/sqrt(x - 3), x, S.Reals) == Interval(3, oo, True, True)
+    assert continuous_domain(1/x - 2, x, S.Reals) == \
+        Union(Interval.open(-oo, 0), Interval.open(0, oo))
+    assert continuous_domain(1/(x**2 - 4) + 2, x, S.Reals) == \
+        Union(Interval.open(-oo, -2), Interval.open(-2, 2), Interval.open(2, oo))
+    domain = continuous_domain(log(tan(x)**2 + 1), x, S.Reals)
+    assert not domain.contains(3*pi/2)
+    assert domain.contains(5)
+    d = Symbol('d', even=True, zero=False)
+    assert continuous_domain(x**(1/d), x, S.Reals) == Interval(0, oo)
+
+
+def test_not_empty_in():
+    assert not_empty_in(FiniteSet(x, 2*x).intersect(Interval(1, 2, True, False)), x) == \
+        Interval(S.Half, 2, True, False)
+    assert not_empty_in(FiniteSet(x, x**2).intersect(Interval(1, 2)), x) == \
+        Union(Interval(-sqrt(2), -1), Interval(1, 2))
+    assert not_empty_in(FiniteSet(x**2 + x, x).intersect(Interval(2, 4)), x) == \
+        Union(Interval(-sqrt(17)/2 - S.Half, -2),
+              Interval(1, Rational(-1, 2) + sqrt(17)/2), Interval(2, 4))
+    assert not_empty_in(FiniteSet(x/(x - 1)).intersect(S.Reals), x) == \
+        Complement(S.Reals, FiniteSet(1))
+    assert not_empty_in(FiniteSet(a/(a - 1)).intersect(S.Reals), a) == \
+        Complement(S.Reals, FiniteSet(1))
+    assert not_empty_in(FiniteSet((x**2 - 3*x + 2)/(x - 1)).intersect(S.Reals), x) == \
+        Complement(S.Reals, FiniteSet(1))
+    assert not_empty_in(FiniteSet(3, 4, x/(x - 1)).intersect(Interval(2, 3)), x) == \
+        Interval(-oo, oo)
+    assert not_empty_in(FiniteSet(4, x/(x - 1)).intersect(Interval(2, 3)), x) == \
+        Interval(S(3)/2, 2)
+    assert not_empty_in(FiniteSet(x/(x**2 - 1)).intersect(S.Reals), x) == \
+        Complement(S.Reals, FiniteSet(-1, 1))
+    assert not_empty_in(FiniteSet(x, x**2).intersect(Union(Interval(1, 3, True, True),
+                                                           Interval(4, 5))), x) == \
+        Union(Interval(-sqrt(5), -2), Interval(-sqrt(3), -1, True, True),
+              Interval(1, 3, True, True), Interval(4, 5))
+    assert not_empty_in(FiniteSet(1).intersect(Interval(3, 4)), x) == S.EmptySet
+    assert not_empty_in(FiniteSet(x**2/(x + 2)).intersect(Interval(1, oo)), x) == \
+        Union(Interval(-2, -1, True, False), Interval(2, oo))
+    raises(ValueError, lambda: not_empty_in(x))
+    raises(ValueError, lambda: not_empty_in(Interval(0, 1), x))
+    raises(NotImplementedError,
+           lambda: not_empty_in(FiniteSet(x).intersect(S.Reals), x, a))
+
+
+@_both_exp_pow
+def test_periodicity():
+    x = Symbol('x')
+    y = Symbol('y')
+    z = Symbol('z', real=True)
+
+    assert periodicity(sin(2*x), x) == pi
+    assert periodicity((-2)*tan(4*x), x) == pi/4
+    assert periodicity(sin(x)**2, x) == 2*pi
+    assert periodicity(3**tan(3*x), x) == pi/3
+    assert periodicity(tan(x)*cos(x), x) == 2*pi
+    assert periodicity(sin(x)**(tan(x)), x) == 2*pi
+    assert periodicity(tan(x)*sec(x), x) == 2*pi
+    assert periodicity(sin(2*x)*cos(2*x) - y, x) == pi/2
+    assert periodicity(tan(x) + cot(x), x) == pi
+    assert periodicity(sin(x) - cos(2*x), x) == 2*pi
+    assert periodicity(sin(x) - 1, x) == 2*pi
+    assert periodicity(sin(4*x) + sin(x)*cos(x), x) == pi
+    assert periodicity(exp(sin(x)), x) == 2*pi
+    assert periodicity(log(cot(2*x)) - sin(cos(2*x)), x) == pi
+    assert periodicity(sin(2*x)*exp(tan(x) - csc(2*x)), x) == pi
+    assert periodicity(cos(sec(x) - csc(2*x)), x) == 2*pi
+    assert periodicity(tan(sin(2*x)), x) == pi
+    assert periodicity(2*tan(x)**2, x) == pi
+    assert periodicity(sin(x%4), x) == 4
+    assert periodicity(sin(x)%4, x) == 2*pi
+    assert periodicity(tan((3*x-2)%4), x) == Rational(4, 3)
+    assert periodicity((sqrt(2)*(x+1)+x) % 3, x) == 3 / (sqrt(2)+1)
+    assert periodicity((x**2+1) % x, x) is None
+    assert periodicity(sin(re(x)), x) == 2*pi
+    assert periodicity(sin(x)**2 + cos(x)**2, x) is S.Zero
+    assert periodicity(tan(x), y) is S.Zero
+    assert periodicity(sin(x) + I*cos(x), x) == 2*pi
+    assert periodicity(x - sin(2*y), y) == pi
+
+    assert periodicity(exp(x), x) is None
+    assert periodicity(exp(I*x), x) == 2*pi
+    assert periodicity(exp(I*z), z) == 2*pi
+    assert periodicity(exp(z), z) is None
+    assert periodicity(exp(log(sin(z) + I*cos(2*z)), evaluate=False), z) == 2*pi
+    assert periodicity(exp(log(sin(2*z) + I*cos(z)), evaluate=False), z) == 2*pi
+    assert periodicity(exp(sin(z)), z) == 2*pi
+    assert periodicity(exp(2*I*z), z) == pi
+    assert periodicity(exp(z + I*sin(z)), z) is None
+    assert periodicity(exp(cos(z/2) + sin(z)), z) == 4*pi
+    assert periodicity(log(x), x) is None
+    assert periodicity(exp(x)**sin(x), x) is None
+    assert periodicity(sin(x)**y, y) is None
+
+    assert periodicity(Abs(sin(Abs(sin(x)))), x) == pi
+    assert all(periodicity(Abs(f(x)), x) == pi for f in (
+        cos, sin, sec, csc, tan, cot))
+    assert periodicity(Abs(sin(tan(x))), x) == pi
+    assert periodicity(Abs(sin(sin(x) + tan(x))), x) == 2*pi
+    assert periodicity(sin(x) > S.Half, x) == 2*pi
+
+    assert periodicity(x > 2, x) is None
+    assert periodicity(x**3 - x**2 + 1, x) is None
+    assert periodicity(Abs(x), x) is None
+    assert periodicity(Abs(x**2 - 1), x) is None
+
+    assert periodicity((x**2 + 4)%2, x) is None
+    assert periodicity((E**x)%3, x) is None
+
+    assert periodicity(sin(expint(1, x))/expint(1, x), x) is None
+    # returning `None` for any Piecewise
+    p = Piecewise((0, x < -1), (x**2, x <= 1), (log(x), True))
+    assert periodicity(p, x) is None
+
+    m = MatrixSymbol('m', 3, 3)
+    raises(NotImplementedError, lambda: periodicity(sin(m), m))
+    raises(NotImplementedError, lambda: periodicity(sin(m[0, 0]), m))
+    raises(NotImplementedError, lambda: periodicity(sin(m), m[0, 0]))
+    raises(NotImplementedError, lambda: periodicity(sin(m[0, 0]), m[0, 0]))
+
+
+def test_periodicity_check():
+    x = Symbol('x')
+    y = Symbol('y')
+
+    assert periodicity(tan(x), x, check=True) == pi
+    assert periodicity(sin(x) + cos(x), x, check=True) == 2*pi
+    assert periodicity(sec(x), x) == 2*pi
+    assert periodicity(sin(x*y), x) == 2*pi/abs(y)
+    assert periodicity(Abs(sec(sec(x))), x) == pi
+
+
+def test_lcim():
+    assert lcim([S.Half, S(2), S(3)]) == 6
+    assert lcim([pi/2, pi/4, pi]) == pi
+    assert lcim([2*pi, pi/2]) == 2*pi
+    assert lcim([S.One, 2*pi]) is None
+    assert lcim([S(2) + 2*E, E/3 + Rational(1, 3), S.One + E]) == S(2) + 2*E
+
+
+def test_is_convex():
+    assert is_convex(1/x, x, domain=Interval.open(0, oo)) == True
+    assert is_convex(1/x, x, domain=Interval(-oo, 0)) == False
+    assert is_convex(x**2, x, domain=Interval(0, oo)) == True
+    assert is_convex(1/x**3, x, domain=Interval.Lopen(0, oo)) == True
+    assert is_convex(-1/x**3, x, domain=Interval.Ropen(-oo, 0)) == True
+    assert is_convex(log(x), x) == False
+    raises(NotImplementedError, lambda: is_convex(log(x), x, a))
+
+
+def test_stationary_points():
+    x, y = symbols('x y')
+
+    assert stationary_points(sin(x), x, Interval(-pi/2, pi/2)
+        ) == {-pi/2, pi/2}
+    assert  stationary_points(sin(x), x, Interval.Ropen(0, pi/4)
+        ) is S.EmptySet
+    assert stationary_points(tan(x), x,
+        ) is S.EmptySet
+    assert stationary_points(sin(x)*cos(x), x, Interval(0, pi)
+        ) == {pi/4, pi*Rational(3, 4)}
+    assert stationary_points(sec(x), x, Interval(0, pi)
+        ) == {0, pi}
+    assert stationary_points((x+3)*(x-2), x
+        ) == FiniteSet(Rational(-1, 2))
+    assert stationary_points((x + 3)/(x - 2), x, Interval(-5, 5)
+        ) is S.EmptySet
+    assert stationary_points((x**2+3)/(x-2), x
+        ) == {2 - sqrt(7), 2 + sqrt(7)}
+    assert stationary_points((x**2+3)/(x-2), x, Interval(0, 5)
+        ) == {2 + sqrt(7)}
+    assert stationary_points(x**4 + x**3 - 5*x**2, x, S.Reals
+        ) == FiniteSet(-2, 0, Rational(5, 4))
+    assert stationary_points(exp(x), x
+        ) is S.EmptySet
+    assert stationary_points(log(x) - x, x, S.Reals
+        ) == {1}
+    assert stationary_points(cos(x), x, Union(Interval(0, 5), Interval(-6, -3))
+        ) == {0, -pi, pi}
+    assert stationary_points(y, x, S.Reals
+        ) == S.Reals
+    assert stationary_points(y, x, S.EmptySet) == S.EmptySet
+
+
+def test_maximum():
+    x, y = symbols('x y')
+    assert maximum(sin(x), x) is S.One
+    assert maximum(sin(x), x, Interval(0, 1)) == sin(1)
+    assert maximum(tan(x), x) is oo
+    assert maximum(tan(x), x, Interval(-pi/4, pi/4)) is S.One
+    assert maximum(sin(x)*cos(x), x, S.Reals) == S.Half
+    assert simplify(maximum(sin(x)*cos(x), x, Interval(pi*Rational(3, 8), pi*Rational(5, 8)))
+        ) == sqrt(2)/4
+    assert maximum((x+3)*(x-2), x) is oo
+    assert maximum((x+3)*(x-2), x, Interval(-5, 0)) == S(14)
+    assert maximum((x+3)/(x-2), x, Interval(-5, 0)) == Rational(2, 7)
+    assert simplify(maximum(-x**4-x**3+x**2+10, x)
+        ) == 41*sqrt(41)/512 + Rational(5419, 512)
+    assert maximum(exp(x), x, Interval(-oo, 2)) == exp(2)
+    assert maximum(log(x) - x, x, S.Reals) is S.NegativeOne
+    assert maximum(cos(x), x, Union(Interval(0, 5), Interval(-6, -3))
+        ) is S.One
+    assert maximum(cos(x)-sin(x), x, S.Reals) == sqrt(2)
+    assert maximum(y, x, S.Reals) == y
+    assert maximum(abs(a**3 + a), a, Interval(0, 2)) == 10
+    assert maximum(abs(60*a**3 + 24*a), a, Interval(0, 2)) == 528
+    assert maximum(abs(12*a*(5*a**2 + 2)), a, Interval(0, 2)) == 528
+    assert maximum(x/sqrt(x**2+1), x, S.Reals) == 1
+
+    raises(ValueError, lambda : maximum(sin(x), x, S.EmptySet))
+    raises(ValueError, lambda : maximum(log(cos(x)), x, S.EmptySet))
+    raises(ValueError, lambda : maximum(1/(x**2 + y**2 + 1), x, S.EmptySet))
+    raises(ValueError, lambda : maximum(sin(x), sin(x)))
+    raises(ValueError, lambda : maximum(sin(x), x*y, S.EmptySet))
+    raises(ValueError, lambda : maximum(sin(x), S.One))
+
+
+def test_minimum():
+    x, y = symbols('x y')
+
+    assert minimum(sin(x), x) is S.NegativeOne
+    assert minimum(sin(x), x, Interval(1, 4)) == sin(4)
+    assert minimum(tan(x), x) is -oo
+    assert minimum(tan(x), x, Interval(-pi/4, pi/4)) is S.NegativeOne
+    assert minimum(sin(x)*cos(x), x, S.Reals) == Rational(-1, 2)
+    assert simplify(minimum(sin(x)*cos(x), x, Interval(pi*Rational(3, 8), pi*Rational(5, 8)))
+        ) == -sqrt(2)/4
+    assert minimum((x+3)*(x-2), x) == Rational(-25, 4)
+    assert minimum((x+3)/(x-2), x, Interval(-5, 0)) == Rational(-3, 2)
+    assert minimum(x**4-x**3+x**2+10, x) == S(10)
+    assert minimum(exp(x), x, Interval(-2, oo)) == exp(-2)
+    assert minimum(log(x) - x, x, S.Reals) is -oo
+    assert minimum(cos(x), x, Union(Interval(0, 5), Interval(-6, -3))
+        ) is S.NegativeOne
+    assert minimum(cos(x)-sin(x), x, S.Reals) == -sqrt(2)
+    assert minimum(y, x, S.Reals) == y
+    assert minimum(x/sqrt(x**2+1), x, S.Reals) == -1
+
+    raises(ValueError, lambda : minimum(sin(x), x, S.EmptySet))
+    raises(ValueError, lambda : minimum(log(cos(x)), x, S.EmptySet))
+    raises(ValueError, lambda : minimum(1/(x**2 + y**2 + 1), x, S.EmptySet))
+    raises(ValueError, lambda : minimum(sin(x), sin(x)))
+    raises(ValueError, lambda : minimum(sin(x), x*y, S.EmptySet))
+    raises(ValueError, lambda : minimum(sin(x), S.One))
+
+
+def test_issue_19869():
+    t = symbols('t')
+    assert (maximum(sqrt(3)*(t - 1)/(3*sqrt(t**2 + 1)), t)
+        ) == sqrt(3)/3
+
+
+def test_issue_16469():
+    x = Symbol("x", real=True)
+    f = abs(x)
+    assert function_range(f, x, S.Reals) == Interval(0, oo, False, True)
+
+
+@_both_exp_pow
+def test_issue_18747():
+    assert periodicity(exp(pi*I*(x/4+S.Half/2)), x) == 8

llmeval-env/lib/python3.10/site-packages/sympy/interactive/tests/test_interactive.py

@@ -0,0 +1,10 @@
+from sympy.interactive.session import int_to_Integer
+
+
+def test_int_to_Integer():
+    assert int_to_Integer("1 + 2.2 + 0x3 + 40") == \
+        'Integer (1 )+2.2 +Integer (0x3 )+Integer (40 )'
+    assert int_to_Integer("0b101") == 'Integer (0b101 )'
+    assert int_to_Integer("ab1 + 1 + '1 + 2'") == "ab1 +Integer (1 )+'1 + 2'"
+    assert int_to_Integer("(2 + \n3)") == '(Integer (2 )+\nInteger (3 ))'
+    assert int_to_Integer("2 + 2.0 + 2j + 2e-10") == 'Integer (2 )+2.0 +2j +2e-10 '

llmeval-env/lib/python3.10/site-packages/sympy/interactive/tests/test_ipython.py

@@ -0,0 +1,278 @@
+"""Tests of tools for setting up interactive IPython sessions. """
+
+from sympy.interactive.session import (init_ipython_session,
+    enable_automatic_symbols, enable_automatic_int_sympification)
+
+from sympy.core import Symbol, Rational, Integer
+from sympy.external import import_module
+from sympy.testing.pytest import raises
+
+# TODO: The code below could be made more granular with something like:
+#
+# @requires('IPython', version=">=0.11")
+# def test_automatic_symbols(ipython):
+
+ipython = import_module("IPython", min_module_version="0.11")
+
+if not ipython:
+    #bin/test will not execute any tests now
+    disabled = True
+
+# WARNING: These tests will modify the existing IPython environment. IPython
+# uses a single instance for its interpreter, so there is no way to isolate
+# the test from another IPython session. It also means that if this test is
+# run twice in the same Python session it will fail. This isn't usually a
+# problem because the test suite is run in a subprocess by default, but if the
+# tests are run with subprocess=False it can pollute the current IPython
+# session. See the discussion in issue #15149.
+
+def test_automatic_symbols():
+    # NOTE: Because of the way the hook works, you have to use run_cell(code,
+    # True).  This means that the code must have no Out, or it will be printed
+    # during the tests.
+    app = init_ipython_session()
+    app.run_cell("from sympy import *")
+
+    enable_automatic_symbols(app)
+
+    symbol = "verylongsymbolname"
+    assert symbol not in app.user_ns
+    app.run_cell("a = %s" % symbol, True)
+    assert symbol not in app.user_ns
+    app.run_cell("a = type(%s)" % symbol, True)
+    assert app.user_ns['a'] == Symbol
+    app.run_cell("%s = Symbol('%s')" % (symbol, symbol), True)
+    assert symbol in app.user_ns
+
+    # Check that built-in names aren't overridden
+    app.run_cell("a = all == __builtin__.all", True)
+    assert "all" not in app.user_ns
+    assert app.user_ns['a'] is True
+
+    # Check that SymPy names aren't overridden
+    app.run_cell("import sympy")
+    app.run_cell("a = factorial == sympy.factorial", True)
+    assert app.user_ns['a'] is True
+
+
+def test_int_to_Integer():
+    # XXX: Warning, don't test with == here.  0.5 == Rational(1, 2) is True!
+    app = init_ipython_session()
+    app.run_cell("from sympy import Integer")
+    app.run_cell("a = 1")
+    assert isinstance(app.user_ns['a'], int)
+
+    enable_automatic_int_sympification(app)
+    app.run_cell("a = 1/2")
+    assert isinstance(app.user_ns['a'], Rational)
+    app.run_cell("a = 1")
+    assert isinstance(app.user_ns['a'], Integer)
+    app.run_cell("a = int(1)")
+    assert isinstance(app.user_ns['a'], int)
+    app.run_cell("a = (1/\n2)")
+    assert app.user_ns['a'] == Rational(1, 2)
+    # TODO: How can we test that the output of a SyntaxError is the original
+    # input, not the transformed input?
+
+
+def test_ipythonprinting():
+    # Initialize and setup IPython session
+    app = init_ipython_session()
+    app.run_cell("ip = get_ipython()")
+    app.run_cell("inst = ip.instance()")
+    app.run_cell("format = inst.display_formatter.format")
+    app.run_cell("from sympy import Symbol")
+
+    # Printing without printing extension
+    app.run_cell("a = format(Symbol('pi'))")
+    app.run_cell("a2 = format(Symbol('pi')**2)")
+    # Deal with API change starting at IPython 1.0
+    if int(ipython.__version__.split(".")[0]) < 1:
+        assert app.user_ns['a']['text/plain'] == "pi"
+        assert app.user_ns['a2']['text/plain'] == "pi**2"
+    else:
+        assert app.user_ns['a'][0]['text/plain'] == "pi"
+        assert app.user_ns['a2'][0]['text/plain'] == "pi**2"
+
+    # Load printing extension
+    app.run_cell("from sympy import init_printing")
+    app.run_cell("init_printing()")
+    # Printing with printing extension
+    app.run_cell("a = format(Symbol('pi'))")
+    app.run_cell("a2 = format(Symbol('pi')**2)")
+    # Deal with API change starting at IPython 1.0
+    if int(ipython.__version__.split(".")[0]) < 1:
+        assert app.user_ns['a']['text/plain'] in ('\N{GREEK SMALL LETTER PI}', 'pi')
+        assert app.user_ns['a2']['text/plain'] in (' 2\n\N{GREEK SMALL LETTER PI} ', '  2\npi ')
+    else:
+        assert app.user_ns['a'][0]['text/plain'] in ('\N{GREEK SMALL LETTER PI}', 'pi')
+        assert app.user_ns['a2'][0]['text/plain'] in (' 2\n\N{GREEK SMALL LETTER PI} ', '  2\npi ')
+
+
+def test_print_builtin_option():
+    # Initialize and setup IPython session
+    app = init_ipython_session()
+    app.run_cell("ip = get_ipython()")
+    app.run_cell("inst = ip.instance()")
+    app.run_cell("format = inst.display_formatter.format")
+    app.run_cell("from sympy import Symbol")
+    app.run_cell("from sympy import init_printing")
+
+    app.run_cell("a = format({Symbol('pi'): 3.14, Symbol('n_i'): 3})")
+    # Deal with API change starting at IPython 1.0
+    if int(ipython.__version__.split(".")[0]) < 1:
+        text = app.user_ns['a']['text/plain']
+        raises(KeyError, lambda: app.user_ns['a']['text/latex'])
+    else:
+        text = app.user_ns['a'][0]['text/plain']
+        raises(KeyError, lambda: app.user_ns['a'][0]['text/latex'])
+    # XXX: How can we make this ignore the terminal width? This test fails if
+    # the terminal is too narrow.
+    assert text in ("{pi: 3.14, n_i: 3}",
+                    '{n\N{LATIN SUBSCRIPT SMALL LETTER I}: 3, \N{GREEK SMALL LETTER PI}: 3.14}',
+                    "{n_i: 3, pi: 3.14}",
+                    '{\N{GREEK SMALL LETTER PI}: 3.14, n\N{LATIN SUBSCRIPT SMALL LETTER I}: 3}')
+
+    # If we enable the default printing, then the dictionary's should render
+    # as a LaTeX version of the whole dict: ${\pi: 3.14, n_i: 3}$
+    app.run_cell("inst.display_formatter.formatters['text/latex'].enabled = True")
+    app.run_cell("init_printing(use_latex=True)")
+    app.run_cell("a = format({Symbol('pi'): 3.14, Symbol('n_i'): 3})")
+    # Deal with API change starting at IPython 1.0
+    if int(ipython.__version__.split(".")[0]) < 1:
+        text = app.user_ns['a']['text/plain']
+        latex = app.user_ns['a']['text/latex']
+    else:
+        text = app.user_ns['a'][0]['text/plain']
+        latex = app.user_ns['a'][0]['text/latex']
+    assert text in ("{pi: 3.14, n_i: 3}",
+                    '{n\N{LATIN SUBSCRIPT SMALL LETTER I}: 3, \N{GREEK SMALL LETTER PI}: 3.14}',
+                    "{n_i: 3, pi: 3.14}",
+                    '{\N{GREEK SMALL LETTER PI}: 3.14, n\N{LATIN SUBSCRIPT SMALL LETTER I}: 3}')
+    assert latex == r'$\displaystyle \left\{ n_{i} : 3, \  \pi : 3.14\right\}$'
+
+    # Objects with an _latex overload should also be handled by our tuple
+    # printer.
+    app.run_cell("""\
+    class WithOverload:
+        def _latex(self, printer):
+            return r"\\LaTeX"
+    """)
+    app.run_cell("a = format((WithOverload(),))")
+    # Deal with API change starting at IPython 1.0
+    if int(ipython.__version__.split(".")[0]) < 1:
+        latex = app.user_ns['a']['text/latex']
+    else:
+        latex = app.user_ns['a'][0]['text/latex']
+    assert latex == r'$\displaystyle \left( \LaTeX,\right)$'
+
+    app.run_cell("inst.display_formatter.formatters['text/latex'].enabled = True")
+    app.run_cell("init_printing(use_latex=True, print_builtin=False)")
+    app.run_cell("a = format({Symbol('pi'): 3.14, Symbol('n_i'): 3})")
+    # Deal with API change starting at IPython 1.0
+    if int(ipython.__version__.split(".")[0]) < 1:
+        text = app.user_ns['a']['text/plain']
+        raises(KeyError, lambda: app.user_ns['a']['text/latex'])
+    else:
+        text = app.user_ns['a'][0]['text/plain']
+        raises(KeyError, lambda: app.user_ns['a'][0]['text/latex'])
+    # Note : In Python 3 we have one text type: str which holds Unicode data
+    # and two byte types bytes and bytearray.
+    # Python 3.3.3 + IPython 0.13.2 gives: '{n_i: 3, pi: 3.14}'
+    # Python 3.3.3 + IPython 1.1.0 gives: '{n_i: 3, pi: 3.14}'
+    assert text in ("{pi: 3.14, n_i: 3}", "{n_i: 3, pi: 3.14}")
+
+
+def test_builtin_containers():
+    # Initialize and setup IPython session
+    app = init_ipython_session()
+    app.run_cell("ip = get_ipython()")
+    app.run_cell("inst = ip.instance()")
+    app.run_cell("format = inst.display_formatter.format")
+    app.run_cell("inst.display_formatter.formatters['text/latex'].enabled = True")
+    app.run_cell("from sympy import init_printing, Matrix")
+    app.run_cell('init_printing(use_latex=True, use_unicode=False)')
+
+    # Make sure containers that shouldn't pretty print don't.
+    app.run_cell('a = format((True, False))')
+    app.run_cell('import sys')
+    app.run_cell('b = format(sys.flags)')
+    app.run_cell('c = format((Matrix([1, 2]),))')
+    # Deal with API change starting at IPython 1.0
+    if int(ipython.__version__.split(".")[0]) < 1:
+        assert app.user_ns['a']['text/plain'] ==  '(True, False)'
+        assert 'text/latex' not in app.user_ns['a']
+        assert app.user_ns['b']['text/plain'][:10] == 'sys.flags('
+        assert 'text/latex' not in app.user_ns['b']
+        assert app.user_ns['c']['text/plain'] == \
+"""\
+ [1]  \n\
+([ ],)
+ [2]  \
+"""
+        assert app.user_ns['c']['text/latex'] == '$\\displaystyle \\left( \\left[\\begin{matrix}1\\\\2\\end{matrix}\\right],\\right)$'
+    else:
+        assert app.user_ns['a'][0]['text/plain'] ==  '(True, False)'
+        assert 'text/latex' not in app.user_ns['a'][0]
+        assert app.user_ns['b'][0]['text/plain'][:10] == 'sys.flags('
+        assert 'text/latex' not in app.user_ns['b'][0]
+        assert app.user_ns['c'][0]['text/plain'] == \
+"""\
+ [1]  \n\
+([ ],)
+ [2]  \
+"""
+        assert app.user_ns['c'][0]['text/latex'] == '$\\displaystyle \\left( \\left[\\begin{matrix}1\\\\2\\end{matrix}\\right],\\right)$'
+
+def test_matplotlib_bad_latex():
+    # Initialize and setup IPython session
+    app = init_ipython_session()
+    app.run_cell("import IPython")
+    app.run_cell("ip = get_ipython()")
+    app.run_cell("inst = ip.instance()")
+    app.run_cell("format = inst.display_formatter.format")
+    app.run_cell("from sympy import init_printing, Matrix")
+    app.run_cell("init_printing(use_latex='matplotlib')")
+
+    # The png formatter is not enabled by default in this context
+    app.run_cell("inst.display_formatter.formatters['image/png'].enabled = True")
+
+    # Make sure no warnings are raised by IPython
+    app.run_cell("import warnings")
+    # IPython.core.formatters.FormatterWarning was introduced in IPython 2.0
+    if int(ipython.__version__.split(".")[0]) < 2:
+        app.run_cell("warnings.simplefilter('error')")
+    else:
+        app.run_cell("warnings.simplefilter('error', IPython.core.formatters.FormatterWarning)")
+
+    # This should not raise an exception
+    app.run_cell("a = format(Matrix([1, 2, 3]))")
+
+    # issue 9799
+    app.run_cell("from sympy import Piecewise, Symbol, Eq")
+    app.run_cell("x = Symbol('x'); pw = format(Piecewise((1, Eq(x, 0)), (0, True)))")
+
+
+def test_override_repr_latex():
+    # Initialize and setup IPython session
+    app = init_ipython_session()
+    app.run_cell("import IPython")
+    app.run_cell("ip = get_ipython()")
+    app.run_cell("inst = ip.instance()")
+    app.run_cell("format = inst.display_formatter.format")
+    app.run_cell("inst.display_formatter.formatters['text/latex'].enabled = True")
+    app.run_cell("from sympy import init_printing")
+    app.run_cell("from sympy import Symbol")
+    app.run_cell("init_printing(use_latex=True)")
+    app.run_cell("""\
+    class SymbolWithOverload(Symbol):
+        def _repr_latex_(self):
+            return r"Hello " + super()._repr_latex_() + " world"
+    """)
+    app.run_cell("a = format(SymbolWithOverload('s'))")
+
+    if int(ipython.__version__.split(".")[0]) < 1:
+        latex = app.user_ns['a']['text/latex']
+    else:
+        latex = app.user_ns['a'][0]['text/latex']
+    assert latex == r'Hello $\displaystyle s$ world'

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

@@ -0,0 +1,60 @@
+"""The module helps converting SymPy expressions into shorter forms of them.
+
+for example:
+the expression E**(pi*I) will be converted into -1
+the expression (x+x)**2 will be converted into 4*x**2
+"""
+from .simplify import (simplify, hypersimp, hypersimilar,
+    logcombine, separatevars, posify, besselsimp, kroneckersimp,
+    signsimp, nsimplify)
+
+from .fu import FU, fu
+
+from .sqrtdenest import sqrtdenest
+
+from .cse_main import cse
+
+from .epathtools import epath, EPath
+
+from .hyperexpand import hyperexpand
+
+from .radsimp import collect, rcollect, radsimp, collect_const, fraction, numer, denom
+
+from .trigsimp import trigsimp, exptrigsimp
+
+from .powsimp import powsimp, powdenest
+
+from .combsimp import combsimp
+
+from .gammasimp import gammasimp
+
+from .ratsimp import ratsimp, ratsimpmodprime
+
+__all__ = [
+    'simplify', 'hypersimp', 'hypersimilar', 'logcombine', 'separatevars',
+    'posify', 'besselsimp', 'kroneckersimp', 'signsimp',
+    'nsimplify',
+
+    'FU', 'fu',
+
+    'sqrtdenest',
+
+    'cse',
+
+    'epath', 'EPath',
+
+    'hyperexpand',
+
+    'collect', 'rcollect', 'radsimp', 'collect_const', 'fraction', 'numer',
+    'denom',
+
+    'trigsimp', 'exptrigsimp',
+
+    'powsimp', 'powdenest',
+
+    'combsimp',
+
+    'gammasimp',
+
+    'ratsimp', 'ratsimpmodprime',
+]

llmeval-env/lib/python3.10/site-packages/sympy/simplify/combsimp.py

@@ -0,0 +1,114 @@
+from sympy.core import Mul
+from sympy.core.function import count_ops
+from sympy.core.traversal import preorder_traversal, bottom_up
+from sympy.functions.combinatorial.factorials import binomial, factorial
+from sympy.functions import gamma
+from sympy.simplify.gammasimp import gammasimp, _gammasimp
+
+from sympy.utilities.timeutils import timethis
+
+
+@timethis('combsimp')
+def combsimp(expr):
+    r"""
+    Simplify combinatorial expressions.
+
+    Explanation
+    ===========
+
+    This function takes as input an expression containing factorials,
+    binomials, Pochhammer symbol and other "combinatorial" functions,
+    and tries to minimize the number of those functions and reduce
+    the size of their arguments.
+
+    The algorithm works by rewriting all combinatorial functions as
+    gamma functions and applying gammasimp() except simplification
+    steps that may make an integer argument non-integer. See docstring
+    of gammasimp for more information.
+
+    Then it rewrites expression in terms of factorials and binomials by
+    rewriting gammas as factorials and converting (a+b)!/a!b! into
+    binomials.
+
+    If expression has gamma functions or combinatorial functions
+    with non-integer argument, it is automatically passed to gammasimp.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify import combsimp
+    >>> from sympy import factorial, binomial, symbols
+    >>> n, k = symbols('n k', integer = True)
+
+    >>> combsimp(factorial(n)/factorial(n - 3))
+    n*(n - 2)*(n - 1)
+    >>> combsimp(binomial(n+1, k+1)/binomial(n, k))
+    (n + 1)/(k + 1)
+
+    """
+
+    expr = expr.rewrite(gamma, piecewise=False)
+    if any(isinstance(node, gamma) and not node.args[0].is_integer
+        for node in preorder_traversal(expr)):
+        return gammasimp(expr);
+
+    expr = _gammasimp(expr, as_comb = True)
+    expr = _gamma_as_comb(expr)
+    return expr
+
+
+def _gamma_as_comb(expr):
+    """
+    Helper function for combsimp.
+
+    Rewrites expression in terms of factorials and binomials
+    """
+
+    expr = expr.rewrite(factorial)
+
+    def f(rv):
+        if not rv.is_Mul:
+            return rv
+        rvd = rv.as_powers_dict()
+        nd_fact_args = [[], []] # numerator, denominator
+
+        for k in rvd:
+            if isinstance(k, factorial) and rvd[k].is_Integer:
+                if rvd[k].is_positive:
+                    nd_fact_args[0].extend([k.args[0]]*rvd[k])
+                else:
+                    nd_fact_args[1].extend([k.args[0]]*-rvd[k])
+                rvd[k] = 0
+        if not nd_fact_args[0] or not nd_fact_args[1]:
+            return rv
+
+        hit = False
+        for m in range(2):
+            i = 0
+            while i < len(nd_fact_args[m]):
+                ai = nd_fact_args[m][i]
+                for j in range(i + 1, len(nd_fact_args[m])):
+                    aj = nd_fact_args[m][j]
+
+                    sum = ai + aj
+                    if sum in nd_fact_args[1 - m]:
+                        hit = True
+
+                        nd_fact_args[1 - m].remove(sum)
+                        del nd_fact_args[m][j]
+                        del nd_fact_args[m][i]
+
+                        rvd[binomial(sum, ai if count_ops(ai) <
+                                count_ops(aj) else aj)] += (
+                                -1 if m == 0 else 1)
+                        break
+                else:
+                    i += 1
+
+        if hit:
+            return Mul(*([k**rvd[k] for k in rvd] + [factorial(k)
+                    for k in nd_fact_args[0]]))/Mul(*[factorial(k)
+                    for k in nd_fact_args[1]])
+        return rv
+
+    return bottom_up(expr, f)

llmeval-env/lib/python3.10/site-packages/sympy/simplify/cse_opts.py

@@ -0,0 +1,52 @@
+""" Optimizations of the expression tree representation for better CSE
+opportunities.
+"""
+from sympy.core import Add, Basic, Mul
+from sympy.core.singleton import S
+from sympy.core.sorting import default_sort_key
+from sympy.core.traversal import preorder_traversal
+
+
+def sub_pre(e):
+    """ Replace y - x with -(x - y) if -1 can be extracted from y - x.
+    """
+    # replacing Add, A, from which -1 can be extracted with -1*-A
+    adds = [a for a in e.atoms(Add) if a.could_extract_minus_sign()]
+    reps = {}
+    ignore = set()
+    for a in adds:
+        na = -a
+        if na.is_Mul:  # e.g. MatExpr
+            ignore.add(a)
+            continue
+        reps[a] = Mul._from_args([S.NegativeOne, na])
+
+    e = e.xreplace(reps)
+
+    # repeat again for persisting Adds but mark these with a leading 1, -1
+    # e.g. y - x -> 1*-1*(x - y)
+    if isinstance(e, Basic):
+        negs = {}
+        for a in sorted(e.atoms(Add), key=default_sort_key):
+            if a in ignore:
+                continue
+            if a in reps:
+                negs[a] = reps[a]
+            elif a.could_extract_minus_sign():
+                negs[a] = Mul._from_args([S.One, S.NegativeOne, -a])
+        e = e.xreplace(negs)
+    return e
+
+
+def sub_post(e):
+    """ Replace 1*-1*x with -x.
+    """
+    replacements = []
+    for node in preorder_traversal(e):
+        if isinstance(node, Mul) and \
+            node.args[0] is S.One and node.args[1] is S.NegativeOne:
+            replacements.append((node, -Mul._from_args(node.args[2:])))
+    for node, replacement in replacements:
+        e = e.xreplace({node: replacement})
+
+    return e

llmeval-env/lib/python3.10/site-packages/sympy/simplify/fu.py

@@ -0,0 +1,2099 @@
+from collections import defaultdict
+
+from sympy.core.add import Add
+from sympy.core.expr import Expr
+from sympy.core.exprtools import Factors, gcd_terms, factor_terms
+from sympy.core.function import expand_mul
+from sympy.core.mul import Mul
+from sympy.core.numbers import pi, I
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.sorting import ordered
+from sympy.core.symbol import Dummy
+from sympy.core.sympify import sympify
+from sympy.core.traversal import bottom_up
+from sympy.functions.combinatorial.factorials import binomial
+from sympy.functions.elementary.hyperbolic import (
+    cosh, sinh, tanh, coth, sech, csch, HyperbolicFunction)
+from sympy.functions.elementary.trigonometric import (
+    cos, sin, tan, cot, sec, csc, sqrt, TrigonometricFunction)
+from sympy.ntheory.factor_ import perfect_power
+from sympy.polys.polytools import factor
+from sympy.strategies.tree import greedy
+from sympy.strategies.core import identity, debug
+
+from sympy import SYMPY_DEBUG
+
+
+# ================== Fu-like tools ===========================
+
+
+def TR0(rv):
+    """Simplification of rational polynomials, trying to simplify
+    the expression, e.g. combine things like 3*x + 2*x, etc....
+    """
+    # although it would be nice to use cancel, it doesn't work
+    # with noncommutatives
+    return rv.normal().factor().expand()
+
+
+def TR1(rv):
+    """Replace sec, csc with 1/cos, 1/sin
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR1, sec, csc
+    >>> from sympy.abc import x
+    >>> TR1(2*csc(x) + sec(x))
+    1/cos(x) + 2/sin(x)
+    """
+
+    def f(rv):
+        if isinstance(rv, sec):
+            a = rv.args[0]
+            return S.One/cos(a)
+        elif isinstance(rv, csc):
+            a = rv.args[0]
+            return S.One/sin(a)
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def TR2(rv):
+    """Replace tan and cot with sin/cos and cos/sin
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR2
+    >>> from sympy.abc import x
+    >>> from sympy import tan, cot, sin, cos
+    >>> TR2(tan(x))
+    sin(x)/cos(x)
+    >>> TR2(cot(x))
+    cos(x)/sin(x)
+    >>> TR2(tan(tan(x) - sin(x)/cos(x)))
+    0
+
+    """
+
+    def f(rv):
+        if isinstance(rv, tan):
+            a = rv.args[0]
+            return sin(a)/cos(a)
+        elif isinstance(rv, cot):
+            a = rv.args[0]
+            return cos(a)/sin(a)
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def TR2i(rv, half=False):
+    """Converts ratios involving sin and cos as follows::
+        sin(x)/cos(x) -> tan(x)
+        sin(x)/(cos(x) + 1) -> tan(x/2) if half=True
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR2i
+    >>> from sympy.abc import x, a
+    >>> from sympy import sin, cos
+    >>> TR2i(sin(x)/cos(x))
+    tan(x)
+
+    Powers of the numerator and denominator are also recognized
+
+    >>> TR2i(sin(x)**2/(cos(x) + 1)**2, half=True)
+    tan(x/2)**2
+
+    The transformation does not take place unless assumptions allow
+    (i.e. the base must be positive or the exponent must be an integer
+    for both numerator and denominator)
+
+    >>> TR2i(sin(x)**a/(cos(x) + 1)**a)
+    sin(x)**a/(cos(x) + 1)**a
+
+    """
+
+    def f(rv):
+        if not rv.is_Mul:
+            return rv
+
+        n, d = rv.as_numer_denom()
+        if n.is_Atom or d.is_Atom:
+            return rv
+
+        def ok(k, e):
+            # initial filtering of factors
+            return (
+                (e.is_integer or k.is_positive) and (
+                k.func in (sin, cos) or (half and
+                k.is_Add and
+                len(k.args) >= 2 and
+                any(any(isinstance(ai, cos) or ai.is_Pow and ai.base is cos
+                for ai in Mul.make_args(a)) for a in k.args))))
+
+        n = n.as_powers_dict()
+        ndone = [(k, n.pop(k)) for k in list(n.keys()) if not ok(k, n[k])]
+        if not n:
+            return rv
+
+        d = d.as_powers_dict()
+        ddone = [(k, d.pop(k)) for k in list(d.keys()) if not ok(k, d[k])]
+        if not d:
+            return rv
+
+        # factoring if necessary
+
+        def factorize(d, ddone):
+            newk = []
+            for k in d:
+                if k.is_Add and len(k.args) > 1:
+                    knew = factor(k) if half else factor_terms(k)
+                    if knew != k:
+                        newk.append((k, knew))
+            if newk:
+                for i, (k, knew) in enumerate(newk):
+                    del d[k]
+                    newk[i] = knew
+                newk = Mul(*newk).as_powers_dict()
+                for k in newk:
+                    v = d[k] + newk[k]
+                    if ok(k, v):
+                        d[k] = v
+                    else:
+                        ddone.append((k, v))
+                del newk
+        factorize(n, ndone)
+        factorize(d, ddone)
+
+        # joining
+        t = []
+        for k in n:
+            if isinstance(k, sin):
+                a = cos(k.args[0], evaluate=False)
+                if a in d and d[a] == n[k]:
+                    t.append(tan(k.args[0])**n[k])
+                    n[k] = d[a] = None
+                elif half:
+                    a1 = 1 + a
+                    if a1 in d and d[a1] == n[k]:
+                        t.append((tan(k.args[0]/2))**n[k])
+                        n[k] = d[a1] = None
+            elif isinstance(k, cos):
+                a = sin(k.args[0], evaluate=False)
+                if a in d and d[a] == n[k]:
+                    t.append(tan(k.args[0])**-n[k])
+                    n[k] = d[a] = None
+            elif half and k.is_Add and k.args[0] is S.One and \
+                    isinstance(k.args[1], cos):
+                a = sin(k.args[1].args[0], evaluate=False)
+                if a in d and d[a] == n[k] and (d[a].is_integer or \
+                        a.is_positive):
+                    t.append(tan(a.args[0]/2)**-n[k])
+                    n[k] = d[a] = None
+
+        if t:
+            rv = Mul(*(t + [b**e for b, e in n.items() if e]))/\
+                Mul(*[b**e for b, e in d.items() if e])
+            rv *= Mul(*[b**e for b, e in ndone])/Mul(*[b**e for b, e in ddone])
+
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def TR3(rv):
+    """Induced formula: example sin(-a) = -sin(a)
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR3
+    >>> from sympy.abc import x, y
+    >>> from sympy import pi
+    >>> from sympy import cos
+    >>> TR3(cos(y - x*(y - x)))
+    cos(x*(x - y) + y)
+    >>> cos(pi/2 + x)
+    -sin(x)
+    >>> cos(30*pi/2 + x)
+    -cos(x)
+
+    """
+    from sympy.simplify.simplify import signsimp
+
+    # Negative argument (already automatic for funcs like sin(-x) -> -sin(x)
+    # but more complicated expressions can use it, too). Also, trig angles
+    # between pi/4 and pi/2 are not reduced to an angle between 0 and pi/4.
+    # The following are automatically handled:
+    #   Argument of type: pi/2 +/- angle
+    #   Argument of type: pi +/- angle
+    #   Argument of type : 2k*pi +/- angle
+
+    def f(rv):
+        if not isinstance(rv, TrigonometricFunction):
+            return rv
+        rv = rv.func(signsimp(rv.args[0]))
+        if not isinstance(rv, TrigonometricFunction):
+            return rv
+        if (rv.args[0] - S.Pi/4).is_positive is (S.Pi/2 - rv.args[0]).is_positive is True:
+            fmap = {cos: sin, sin: cos, tan: cot, cot: tan, sec: csc, csc: sec}
+            rv = fmap[type(rv)](S.Pi/2 - rv.args[0])
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def TR4(rv):
+    """Identify values of special angles.
+
+        a=  0   pi/6        pi/4        pi/3        pi/2
+    ----------------------------------------------------
+    sin(a)  0   1/2         sqrt(2)/2   sqrt(3)/2   1
+    cos(a)  1   sqrt(3)/2   sqrt(2)/2   1/2         0
+    tan(a)  0   sqt(3)/3    1           sqrt(3)     --
+
+    Examples
+    ========
+
+    >>> from sympy import pi
+    >>> from sympy import cos, sin, tan, cot
+    >>> for s in (0, pi/6, pi/4, pi/3, pi/2):
+    ...    print('%s %s %s %s' % (cos(s), sin(s), tan(s), cot(s)))
+    ...
+    1 0 0 zoo
+    sqrt(3)/2 1/2 sqrt(3)/3 sqrt(3)
+    sqrt(2)/2 sqrt(2)/2 1 1
+    1/2 sqrt(3)/2 sqrt(3) sqrt(3)/3
+    0 1 zoo 0
+    """
+    # special values at 0, pi/6, pi/4, pi/3, pi/2 already handled
+    return rv
+
+
+def _TR56(rv, f, g, h, max, pow):
+    """Helper for TR5 and TR6 to replace f**2 with h(g**2)
+
+    Options
+    =======
+
+    max :   controls size of exponent that can appear on f
+            e.g. if max=4 then f**4 will be changed to h(g**2)**2.
+    pow :   controls whether the exponent must be a perfect power of 2
+            e.g. if pow=True (and max >= 6) then f**6 will not be changed
+            but f**8 will be changed to h(g**2)**4
+
+    >>> from sympy.simplify.fu import _TR56 as T
+    >>> from sympy.abc import x
+    >>> from sympy import sin, cos
+    >>> h = lambda x: 1 - x
+    >>> T(sin(x)**3, sin, cos, h, 4, False)
+    (1 - cos(x)**2)*sin(x)
+    >>> T(sin(x)**6, sin, cos, h, 6, False)
+    (1 - cos(x)**2)**3
+    >>> T(sin(x)**6, sin, cos, h, 6, True)
+    sin(x)**6
+    >>> T(sin(x)**8, sin, cos, h, 10, True)
+    (1 - cos(x)**2)**4
+    """
+
+    def _f(rv):
+        # I'm not sure if this transformation should target all even powers
+        # or only those expressible as powers of 2. Also, should it only
+        # make the changes in powers that appear in sums -- making an isolated
+        # change is not going to allow a simplification as far as I can tell.
+        if not (rv.is_Pow and rv.base.func == f):
+            return rv
+        if not rv.exp.is_real:
+            return rv
+
+        if (rv.exp < 0) == True:
+            return rv
+        if (rv.exp > max) == True:
+            return rv
+        if rv.exp == 1:
+            return rv
+        if rv.exp == 2:
+            return h(g(rv.base.args[0])**2)
+        else:
+            if rv.exp % 2 == 1:
+                e = rv.exp//2
+                return f(rv.base.args[0])*h(g(rv.base.args[0])**2)**e
+            elif rv.exp == 4:
+                e = 2
+            elif not pow:
+                if rv.exp % 2:
+                    return rv
+                e = rv.exp//2
+            else:
+                p = perfect_power(rv.exp)
+                if not p:
+                    return rv
+                e = rv.exp//2
+            return h(g(rv.base.args[0])**2)**e
+
+    return bottom_up(rv, _f)
+
+
+def TR5(rv, max=4, pow=False):
+    """Replacement of sin**2 with 1 - cos(x)**2.
+
+    See _TR56 docstring for advanced use of ``max`` and ``pow``.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR5
+    >>> from sympy.abc import x
+    >>> from sympy import sin
+    >>> TR5(sin(x)**2)
+    1 - cos(x)**2
+    >>> TR5(sin(x)**-2)  # unchanged
+    sin(x)**(-2)
+    >>> TR5(sin(x)**4)
+    (1 - cos(x)**2)**2
+    """
+    return _TR56(rv, sin, cos, lambda x: 1 - x, max=max, pow=pow)
+
+
+def TR6(rv, max=4, pow=False):
+    """Replacement of cos**2 with 1 - sin(x)**2.
+
+    See _TR56 docstring for advanced use of ``max`` and ``pow``.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR6
+    >>> from sympy.abc import x
+    >>> from sympy import cos
+    >>> TR6(cos(x)**2)
+    1 - sin(x)**2
+    >>> TR6(cos(x)**-2)  #unchanged
+    cos(x)**(-2)
+    >>> TR6(cos(x)**4)
+    (1 - sin(x)**2)**2
+    """
+    return _TR56(rv, cos, sin, lambda x: 1 - x, max=max, pow=pow)
+
+
+def TR7(rv):
+    """Lowering the degree of cos(x)**2.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR7
+    >>> from sympy.abc import x
+    >>> from sympy import cos
+    >>> TR7(cos(x)**2)
+    cos(2*x)/2 + 1/2
+    >>> TR7(cos(x)**2 + 1)
+    cos(2*x)/2 + 3/2
+
+    """
+
+    def f(rv):
+        if not (rv.is_Pow and rv.base.func == cos and rv.exp == 2):
+            return rv
+        return (1 + cos(2*rv.base.args[0]))/2
+
+    return bottom_up(rv, f)
+
+
+def TR8(rv, first=True):
+    """Converting products of ``cos`` and/or ``sin`` to a sum or
+    difference of ``cos`` and or ``sin`` terms.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR8
+    >>> from sympy import cos, sin
+    >>> TR8(cos(2)*cos(3))
+    cos(5)/2 + cos(1)/2
+    >>> TR8(cos(2)*sin(3))
+    sin(5)/2 + sin(1)/2
+    >>> TR8(sin(2)*sin(3))
+    -cos(5)/2 + cos(1)/2
+    """
+
+    def f(rv):
+        if not (
+            rv.is_Mul or
+            rv.is_Pow and
+            rv.base.func in (cos, sin) and
+            (rv.exp.is_integer or rv.base.is_positive)):
+            return rv
+
+        if first:
+            n, d = [expand_mul(i) for i in rv.as_numer_denom()]
+            newn = TR8(n, first=False)
+            newd = TR8(d, first=False)
+            if newn != n or newd != d:
+                rv = gcd_terms(newn/newd)
+                if rv.is_Mul and rv.args[0].is_Rational and \
+                        len(rv.args) == 2 and rv.args[1].is_Add:
+                    rv = Mul(*rv.as_coeff_Mul())
+            return rv
+
+        args = {cos: [], sin: [], None: []}
+        for a in ordered(Mul.make_args(rv)):
+            if a.func in (cos, sin):
+                args[type(a)].append(a.args[0])
+            elif (a.is_Pow and a.exp.is_Integer and a.exp > 0 and \
+                    a.base.func in (cos, sin)):
+                # XXX this is ok but pathological expression could be handled
+                # more efficiently as in TRmorrie
+                args[type(a.base)].extend([a.base.args[0]]*a.exp)
+            else:
+                args[None].append(a)
+        c = args[cos]
+        s = args[sin]
+        if not (c and s or len(c) > 1 or len(s) > 1):
+            return rv
+
+        args = args[None]
+        n = min(len(c), len(s))
+        for i in range(n):
+            a1 = s.pop()
+            a2 = c.pop()
+            args.append((sin(a1 + a2) + sin(a1 - a2))/2)
+        while len(c) > 1:
+            a1 = c.pop()
+            a2 = c.pop()
+            args.append((cos(a1 + a2) + cos(a1 - a2))/2)
+        if c:
+            args.append(cos(c.pop()))
+        while len(s) > 1:
+            a1 = s.pop()
+            a2 = s.pop()
+            args.append((-cos(a1 + a2) + cos(a1 - a2))/2)
+        if s:
+            args.append(sin(s.pop()))
+        return TR8(expand_mul(Mul(*args)))
+
+    return bottom_up(rv, f)
+
+
+def TR9(rv):
+    """Sum of ``cos`` or ``sin`` terms as a product of ``cos`` or ``sin``.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR9
+    >>> from sympy import cos, sin
+    >>> TR9(cos(1) + cos(2))
+    2*cos(1/2)*cos(3/2)
+    >>> TR9(cos(1) + 2*sin(1) + 2*sin(2))
+    cos(1) + 4*sin(3/2)*cos(1/2)
+
+    If no change is made by TR9, no re-arrangement of the
+    expression will be made. For example, though factoring
+    of common term is attempted, if the factored expression
+    was not changed, the original expression will be returned:
+
+    >>> TR9(cos(3) + cos(3)*cos(2))
+    cos(3) + cos(2)*cos(3)
+
+    """
+
+    def f(rv):
+        if not rv.is_Add:
+            return rv
+
+        def do(rv, first=True):
+            # cos(a)+/-cos(b) can be combined into a product of cosines and
+            # sin(a)+/-sin(b) can be combined into a product of cosine and
+            # sine.
+            #
+            # If there are more than two args, the pairs which "work" will
+            # have a gcd extractable and the remaining two terms will have
+            # the above structure -- all pairs must be checked to find the
+            # ones that work. args that don't have a common set of symbols
+            # are skipped since this doesn't lead to a simpler formula and
+            # also has the arbitrariness of combining, for example, the x
+            # and y term instead of the y and z term in something like
+            # cos(x) + cos(y) + cos(z).
+
+            if not rv.is_Add:
+                return rv
+
+            args = list(ordered(rv.args))
+            if len(args) != 2:
+                hit = False
+                for i in range(len(args)):
+                    ai = args[i]
+                    if ai is None:
+                        continue
+                    for j in range(i + 1, len(args)):
+                        aj = args[j]
+                        if aj is None:
+                            continue
+                        was = ai + aj
+                        new = do(was)
+                        if new != was:
+                            args[i] = new  # update in place
+                            args[j] = None
+                            hit = True
+                            break  # go to next i
+                if hit:
+                    rv = Add(*[_f for _f in args if _f])
+                    if rv.is_Add:
+                        rv = do(rv)
+
+                return rv
+
+            # two-arg Add
+            split = trig_split(*args)
+            if not split:
+                return rv
+            gcd, n1, n2, a, b, iscos = split
+
+            # application of rule if possible
+            if iscos:
+                if n1 == n2:
+                    return gcd*n1*2*cos((a + b)/2)*cos((a - b)/2)
+                if n1 < 0:
+                    a, b = b, a
+                return -2*gcd*sin((a + b)/2)*sin((a - b)/2)
+            else:
+                if n1 == n2:
+                    return gcd*n1*2*sin((a + b)/2)*cos((a - b)/2)
+                if n1 < 0:
+                    a, b = b, a
+                return 2*gcd*cos((a + b)/2)*sin((a - b)/2)
+
+        return process_common_addends(rv, do)  # DON'T sift by free symbols
+
+    return bottom_up(rv, f)
+
+
+def TR10(rv, first=True):
+    """Separate sums in ``cos`` and ``sin``.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR10
+    >>> from sympy.abc import a, b, c
+    >>> from sympy import cos, sin
+    >>> TR10(cos(a + b))
+    -sin(a)*sin(b) + cos(a)*cos(b)
+    >>> TR10(sin(a + b))
+    sin(a)*cos(b) + sin(b)*cos(a)
+    >>> TR10(sin(a + b + c))
+    (-sin(a)*sin(b) + cos(a)*cos(b))*sin(c) + \
+    (sin(a)*cos(b) + sin(b)*cos(a))*cos(c)
+    """
+
+    def f(rv):
+        if rv.func not in (cos, sin):
+            return rv
+
+        f = rv.func
+        arg = rv.args[0]
+        if arg.is_Add:
+            if first:
+                args = list(ordered(arg.args))
+            else:
+                args = list(arg.args)
+            a = args.pop()
+            b = Add._from_args(args)
+            if b.is_Add:
+                if f == sin:
+                    return sin(a)*TR10(cos(b), first=False) + \
+                        cos(a)*TR10(sin(b), first=False)
+                else:
+                    return cos(a)*TR10(cos(b), first=False) - \
+                        sin(a)*TR10(sin(b), first=False)
+            else:
+                if f == sin:
+                    return sin(a)*cos(b) + cos(a)*sin(b)
+                else:
+                    return cos(a)*cos(b) - sin(a)*sin(b)
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def TR10i(rv):
+    """Sum of products to function of sum.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR10i
+    >>> from sympy import cos, sin, sqrt
+    >>> from sympy.abc import x
+
+    >>> TR10i(cos(1)*cos(3) + sin(1)*sin(3))
+    cos(2)
+    >>> TR10i(cos(1)*sin(3) + sin(1)*cos(3) + cos(3))
+    cos(3) + sin(4)
+    >>> TR10i(sqrt(2)*cos(x)*x + sqrt(6)*sin(x)*x)
+    2*sqrt(2)*x*sin(x + pi/6)
+
+    """
+    global _ROOT2, _ROOT3, _invROOT3
+    if _ROOT2 is None:
+        _roots()
+
+    def f(rv):
+        if not rv.is_Add:
+            return rv
+
+        def do(rv, first=True):
+            # args which can be expressed as A*(cos(a)*cos(b)+/-sin(a)*sin(b))
+            # or B*(cos(a)*sin(b)+/-cos(b)*sin(a)) can be combined into
+            # A*f(a+/-b) where f is either sin or cos.
+            #
+            # If there are more than two args, the pairs which "work" will have
+            # a gcd extractable and the remaining two terms will have the above
+            # structure -- all pairs must be checked to find the ones that
+            # work.
+
+            if not rv.is_Add:
+                return rv
+
+            args = list(ordered(rv.args))
+            if len(args) != 2:
+                hit = False
+                for i in range(len(args)):
+                    ai = args[i]
+                    if ai is None:
+                        continue
+                    for j in range(i + 1, len(args)):
+                        aj = args[j]
+                        if aj is None:
+                            continue
+                        was = ai + aj
+                        new = do(was)
+                        if new != was:
+                            args[i] = new  # update in place
+                            args[j] = None
+                            hit = True
+                            break  # go to next i
+                if hit:
+                    rv = Add(*[_f for _f in args if _f])
+                    if rv.is_Add:
+                        rv = do(rv)
+
+                return rv
+
+            # two-arg Add
+            split = trig_split(*args, two=True)
+            if not split:
+                return rv
+            gcd, n1, n2, a, b, same = split
+
+            # identify and get c1 to be cos then apply rule if possible
+            if same:  # coscos, sinsin
+                gcd = n1*gcd
+                if n1 == n2:
+                    return gcd*cos(a - b)
+                return gcd*cos(a + b)
+            else:  #cossin, cossin
+                gcd = n1*gcd
+                if n1 == n2:
+                    return gcd*sin(a + b)
+                return gcd*sin(b - a)
+
+        rv = process_common_addends(
+            rv, do, lambda x: tuple(ordered(x.free_symbols)))
+
+        # need to check for inducible pairs in ratio of sqrt(3):1 that
+        # appeared in different lists when sorting by coefficient
+        while rv.is_Add:
+            byrad = defaultdict(list)
+            for a in rv.args:
+                hit = 0
+                if a.is_Mul:
+                    for ai in a.args:
+                        if ai.is_Pow and ai.exp is S.Half and \
+                                ai.base.is_Integer:
+                            byrad[ai].append(a)
+                            hit = 1
+                            break
+                if not hit:
+                    byrad[S.One].append(a)
+
+            # no need to check all pairs -- just check for the onees
+            # that have the right ratio
+            args = []
+            for a in byrad:
+                for b in [_ROOT3*a, _invROOT3]:
+                    if b in byrad:
+                        for i in range(len(byrad[a])):
+                            if byrad[a][i] is None:
+                                continue
+                            for j in range(len(byrad[b])):
+                                if byrad[b][j] is None:
+                                    continue
+                                was = Add(byrad[a][i] + byrad[b][j])
+                                new = do(was)
+                                if new != was:
+                                    args.append(new)
+                                    byrad[a][i] = None
+                                    byrad[b][j] = None
+                                    break
+            if args:
+                rv = Add(*(args + [Add(*[_f for _f in v if _f])
+                    for v in byrad.values()]))
+            else:
+                rv = do(rv)  # final pass to resolve any new inducible pairs
+                break
+
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def TR11(rv, base=None):
+    """Function of double angle to product. The ``base`` argument can be used
+    to indicate what is the un-doubled argument, e.g. if 3*pi/7 is the base
+    then cosine and sine functions with argument 6*pi/7 will be replaced.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR11
+    >>> from sympy import cos, sin, pi
+    >>> from sympy.abc import x
+    >>> TR11(sin(2*x))
+    2*sin(x)*cos(x)
+    >>> TR11(cos(2*x))
+    -sin(x)**2 + cos(x)**2
+    >>> TR11(sin(4*x))
+    4*(-sin(x)**2 + cos(x)**2)*sin(x)*cos(x)
+    >>> TR11(sin(4*x/3))
+    4*(-sin(x/3)**2 + cos(x/3)**2)*sin(x/3)*cos(x/3)
+
+    If the arguments are simply integers, no change is made
+    unless a base is provided:
+
+    >>> TR11(cos(2))
+    cos(2)
+    >>> TR11(cos(4), 2)
+    -sin(2)**2 + cos(2)**2
+
+    There is a subtle issue here in that autosimplification will convert
+    some higher angles to lower angles
+
+    >>> cos(6*pi/7) + cos(3*pi/7)
+    -cos(pi/7) + cos(3*pi/7)
+
+    The 6*pi/7 angle is now pi/7 but can be targeted with TR11 by supplying
+    the 3*pi/7 base:
+
+    >>> TR11(_, 3*pi/7)
+    -sin(3*pi/7)**2 + cos(3*pi/7)**2 + cos(3*pi/7)
+
+    """
+
+    def f(rv):
+        if rv.func not in (cos, sin):
+            return rv
+
+        if base:
+            f = rv.func
+            t = f(base*2)
+            co = S.One
+            if t.is_Mul:
+                co, t = t.as_coeff_Mul()
+            if t.func not in (cos, sin):
+                return rv
+            if rv.args[0] == t.args[0]:
+                c = cos(base)
+                s = sin(base)
+                if f is cos:
+                    return (c**2 - s**2)/co
+                else:
+                    return 2*c*s/co
+            return rv
+
+        elif not rv.args[0].is_Number:
+            # make a change if the leading coefficient's numerator is
+            # divisible by 2
+            c, m = rv.args[0].as_coeff_Mul(rational=True)
+            if c.p % 2 == 0:
+                arg = c.p//2*m/c.q
+                c = TR11(cos(arg))
+                s = TR11(sin(arg))
+                if rv.func == sin:
+                    rv = 2*s*c
+                else:
+                    rv = c**2 - s**2
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def _TR11(rv):
+    """
+    Helper for TR11 to find half-arguments for sin in factors of
+    num/den that appear in cos or sin factors in the den/num.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR11, _TR11
+    >>> from sympy import cos, sin
+    >>> from sympy.abc import x
+    >>> TR11(sin(x/3)/(cos(x/6)))
+    sin(x/3)/cos(x/6)
+    >>> _TR11(sin(x/3)/(cos(x/6)))
+    2*sin(x/6)
+    >>> TR11(sin(x/6)/(sin(x/3)))
+    sin(x/6)/sin(x/3)
+    >>> _TR11(sin(x/6)/(sin(x/3)))
+    1/(2*cos(x/6))
+
+    """
+    def f(rv):
+        if not isinstance(rv, Expr):
+            return rv
+
+        def sincos_args(flat):
+            # find arguments of sin and cos that
+            # appears as bases in args of flat
+            # and have Integer exponents
+            args = defaultdict(set)
+            for fi in Mul.make_args(flat):
+                b, e = fi.as_base_exp()
+                if e.is_Integer and e > 0:
+                    if b.func in (cos, sin):
+                        args[type(b)].add(b.args[0])
+            return args
+        num_args, den_args = map(sincos_args, rv.as_numer_denom())
+        def handle_match(rv, num_args, den_args):
+            # for arg in sin args of num_args, look for arg/2
+            # in den_args and pass this half-angle to TR11
+            # for handling in rv
+            for narg in num_args[sin]:
+                half = narg/2
+                if half in den_args[cos]:
+                    func = cos
+                elif half in den_args[sin]:
+                    func = sin
+                else:
+                    continue
+                rv = TR11(rv, half)
+                den_args[func].remove(half)
+            return rv
+        # sin in num, sin or cos in den
+        rv = handle_match(rv, num_args, den_args)
+        # sin in den, sin or cos in num
+        rv = handle_match(rv, den_args, num_args)
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def TR12(rv, first=True):
+    """Separate sums in ``tan``.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y
+    >>> from sympy import tan
+    >>> from sympy.simplify.fu import TR12
+    >>> TR12(tan(x + y))
+    (tan(x) + tan(y))/(-tan(x)*tan(y) + 1)
+    """
+
+    def f(rv):
+        if not rv.func == tan:
+            return rv
+
+        arg = rv.args[0]
+        if arg.is_Add:
+            if first:
+                args = list(ordered(arg.args))
+            else:
+                args = list(arg.args)
+            a = args.pop()
+            b = Add._from_args(args)
+            if b.is_Add:
+                tb = TR12(tan(b), first=False)
+            else:
+                tb = tan(b)
+            return (tan(a) + tb)/(1 - tan(a)*tb)
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def TR12i(rv):
+    """Combine tan arguments as
+    (tan(y) + tan(x))/(tan(x)*tan(y) - 1) -> -tan(x + y).
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR12i
+    >>> from sympy import tan
+    >>> from sympy.abc import a, b, c
+    >>> ta, tb, tc = [tan(i) for i in (a, b, c)]
+    >>> TR12i((ta + tb)/(-ta*tb + 1))
+    tan(a + b)
+    >>> TR12i((ta + tb)/(ta*tb - 1))
+    -tan(a + b)
+    >>> TR12i((-ta - tb)/(ta*tb - 1))
+    tan(a + b)
+    >>> eq = (ta + tb)/(-ta*tb + 1)**2*(-3*ta - 3*tc)/(2*(ta*tc - 1))
+    >>> TR12i(eq.expand())
+    -3*tan(a + b)*tan(a + c)/(2*(tan(a) + tan(b) - 1))
+    """
+    def f(rv):
+        if not (rv.is_Add or rv.is_Mul or rv.is_Pow):
+            return rv
+
+        n, d = rv.as_numer_denom()
+        if not d.args or not n.args:
+            return rv
+
+        dok = {}
+
+        def ok(di):
+            m = as_f_sign_1(di)
+            if m:
+                g, f, s = m
+                if s is S.NegativeOne and f.is_Mul and len(f.args) == 2 and \
+                        all(isinstance(fi, tan) for fi in f.args):
+                    return g, f
+
+        d_args = list(Mul.make_args(d))
+        for i, di in enumerate(d_args):
+            m = ok(di)
+            if m:
+                g, t = m
+                s = Add(*[_.args[0] for _ in t.args])
+                dok[s] = S.One
+                d_args[i] = g
+                continue
+            if di.is_Add:
+                di = factor(di)
+                if di.is_Mul:
+                    d_args.extend(di.args)
+                    d_args[i] = S.One
+            elif di.is_Pow and (di.exp.is_integer or di.base.is_positive):
+                m = ok(di.base)
+                if m:
+                    g, t = m
+                    s = Add(*[_.args[0] for _ in t.args])
+                    dok[s] = di.exp
+                    d_args[i] = g**di.exp
+                else:
+                    di = factor(di)
+                    if di.is_Mul:
+                        d_args.extend(di.args)
+                        d_args[i] = S.One
+        if not dok:
+            return rv
+
+        def ok(ni):
+            if ni.is_Add and len(ni.args) == 2:
+                a, b = ni.args
+                if isinstance(a, tan) and isinstance(b, tan):
+                    return a, b
+        n_args = list(Mul.make_args(factor_terms(n)))
+        hit = False
+        for i, ni in enumerate(n_args):
+            m = ok(ni)
+            if not m:
+                m = ok(-ni)
+                if m:
+                    n_args[i] = S.NegativeOne
+                else:
+                    if ni.is_Add:
+                        ni = factor(ni)
+                        if ni.is_Mul:
+                            n_args.extend(ni.args)
+                            n_args[i] = S.One
+                        continue
+                    elif ni.is_Pow and (
+                            ni.exp.is_integer or ni.base.is_positive):
+                        m = ok(ni.base)
+                        if m:
+                            n_args[i] = S.One
+                        else:
+                            ni = factor(ni)
+                            if ni.is_Mul:
+                                n_args.extend(ni.args)
+                                n_args[i] = S.One
+                            continue
+                    else:
+                        continue
+            else:
+                n_args[i] = S.One
+            hit = True
+            s = Add(*[_.args[0] for _ in m])
+            ed = dok[s]
+            newed = ed.extract_additively(S.One)
+            if newed is not None:
+                if newed:
+                    dok[s] = newed
+                else:
+                    dok.pop(s)
+            n_args[i] *= -tan(s)
+
+        if hit:
+            rv = Mul(*n_args)/Mul(*d_args)/Mul(*[(Add(*[
+                tan(a) for a in i.args]) - 1)**e for i, e in dok.items()])
+
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def TR13(rv):
+    """Change products of ``tan`` or ``cot``.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR13
+    >>> from sympy import tan, cot
+    >>> TR13(tan(3)*tan(2))
+    -tan(2)/tan(5) - tan(3)/tan(5) + 1
+    >>> TR13(cot(3)*cot(2))
+    cot(2)*cot(5) + 1 + cot(3)*cot(5)
+    """
+
+    def f(rv):
+        if not rv.is_Mul:
+            return rv
+
+        # XXX handle products of powers? or let power-reducing handle it?
+        args = {tan: [], cot: [], None: []}
+        for a in ordered(Mul.make_args(rv)):
+            if a.func in (tan, cot):
+                args[type(a)].append(a.args[0])
+            else:
+                args[None].append(a)
+        t = args[tan]
+        c = args[cot]
+        if len(t) < 2 and len(c) < 2:
+            return rv
+        args = args[None]
+        while len(t) > 1:
+            t1 = t.pop()
+            t2 = t.pop()
+            args.append(1 - (tan(t1)/tan(t1 + t2) + tan(t2)/tan(t1 + t2)))
+        if t:
+            args.append(tan(t.pop()))
+        while len(c) > 1:
+            t1 = c.pop()
+            t2 = c.pop()
+            args.append(1 + cot(t1)*cot(t1 + t2) + cot(t2)*cot(t1 + t2))
+        if c:
+            args.append(cot(c.pop()))
+        return Mul(*args)
+
+    return bottom_up(rv, f)
+
+
+def TRmorrie(rv):
+    """Returns cos(x)*cos(2*x)*...*cos(2**(k-1)*x) -> sin(2**k*x)/(2**k*sin(x))
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TRmorrie, TR8, TR3
+    >>> from sympy.abc import x
+    >>> from sympy import Mul, cos, pi
+    >>> TRmorrie(cos(x)*cos(2*x))
+    sin(4*x)/(4*sin(x))
+    >>> TRmorrie(7*Mul(*[cos(x) for x in range(10)]))
+    7*sin(12)*sin(16)*cos(5)*cos(7)*cos(9)/(64*sin(1)*sin(3))
+
+    Sometimes autosimplification will cause a power to be
+    not recognized. e.g. in the following, cos(4*pi/7) automatically
+    simplifies to -cos(3*pi/7) so only 2 of the 3 terms are
+    recognized:
+
+    >>> TRmorrie(cos(pi/7)*cos(2*pi/7)*cos(4*pi/7))
+    -sin(3*pi/7)*cos(3*pi/7)/(4*sin(pi/7))
+
+    A touch by TR8 resolves the expression to a Rational
+
+    >>> TR8(_)
+    -1/8
+
+    In this case, if eq is unsimplified, the answer is obtained
+    directly:
+
+    >>> eq = cos(pi/9)*cos(2*pi/9)*cos(3*pi/9)*cos(4*pi/9)
+    >>> TRmorrie(eq)
+    1/16
+
+    But if angles are made canonical with TR3 then the answer
+    is not simplified without further work:
+
+    >>> TR3(eq)
+    sin(pi/18)*cos(pi/9)*cos(2*pi/9)/2
+    >>> TRmorrie(_)
+    sin(pi/18)*sin(4*pi/9)/(8*sin(pi/9))
+    >>> TR8(_)
+    cos(7*pi/18)/(16*sin(pi/9))
+    >>> TR3(_)
+    1/16
+
+    The original expression would have resolve to 1/16 directly with TR8,
+    however:
+
+    >>> TR8(eq)
+    1/16
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Morrie%27s_law
+
+    """
+
+    def f(rv, first=True):
+        if not rv.is_Mul:
+            return rv
+        if first:
+            n, d = rv.as_numer_denom()
+            return f(n, 0)/f(d, 0)
+
+        args = defaultdict(list)
+        coss = {}
+        other = []
+        for c in rv.args:
+            b, e = c.as_base_exp()
+            if e.is_Integer and isinstance(b, cos):
+                co, a = b.args[0].as_coeff_Mul()
+                args[a].append(co)
+                coss[b] = e
+            else:
+                other.append(c)
+
+        new = []
+        for a in args:
+            c = args[a]
+            c.sort()
+            while c:
+                k = 0
+                cc = ci = c[0]
+                while cc in c:
+                    k += 1
+                    cc *= 2
+                if k > 1:
+                    newarg = sin(2**k*ci*a)/2**k/sin(ci*a)
+                    # see how many times this can be taken
+                    take = None
+                    ccs = []
+                    for i in range(k):
+                        cc /= 2
+                        key = cos(a*cc, evaluate=False)
+                        ccs.append(cc)
+                        take = min(coss[key], take or coss[key])
+                    # update exponent counts
+                    for i in range(k):
+                        cc = ccs.pop()
+                        key = cos(a*cc, evaluate=False)
+                        coss[key] -= take
+                        if not coss[key]:
+                            c.remove(cc)
+                    new.append(newarg**take)
+                else:
+                    b = cos(c.pop(0)*a)
+                    other.append(b**coss[b])
+
+        if new:
+            rv = Mul(*(new + other + [
+                cos(k*a, evaluate=False) for a in args for k in args[a]]))
+
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def TR14(rv, first=True):
+    """Convert factored powers of sin and cos identities into simpler
+    expressions.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR14
+    >>> from sympy.abc import x, y
+    >>> from sympy import cos, sin
+    >>> TR14((cos(x) - 1)*(cos(x) + 1))
+    -sin(x)**2
+    >>> TR14((sin(x) - 1)*(sin(x) + 1))
+    -cos(x)**2
+    >>> p1 = (cos(x) + 1)*(cos(x) - 1)
+    >>> p2 = (cos(y) - 1)*2*(cos(y) + 1)
+    >>> p3 = (3*(cos(y) - 1))*(3*(cos(y) + 1))
+    >>> TR14(p1*p2*p3*(x - 1))
+    -18*(x - 1)*sin(x)**2*sin(y)**4
+
+    """
+
+    def f(rv):
+        if not rv.is_Mul:
+            return rv
+
+        if first:
+            # sort them by location in numerator and denominator
+            # so the code below can just deal with positive exponents
+            n, d = rv.as_numer_denom()
+            if d is not S.One:
+                newn = TR14(n, first=False)
+                newd = TR14(d, first=False)
+                if newn != n or newd != d:
+                    rv = newn/newd
+                return rv
+
+        other = []
+        process = []
+        for a in rv.args:
+            if a.is_Pow:
+                b, e = a.as_base_exp()
+                if not (e.is_integer or b.is_positive):
+                    other.append(a)
+                    continue
+                a = b
+            else:
+                e = S.One
+            m = as_f_sign_1(a)
+            if not m or m[1].func not in (cos, sin):
+                if e is S.One:
+                    other.append(a)
+                else:
+                    other.append(a**e)
+                continue
+            g, f, si = m
+            process.append((g, e.is_Number, e, f, si, a))
+
+        # sort them to get like terms next to each other
+        process = list(ordered(process))
+
+        # keep track of whether there was any change
+        nother = len(other)
+
+        # access keys
+        keys = (g, t, e, f, si, a) = list(range(6))
+
+        while process:
+            A = process.pop(0)
+            if process:
+                B = process[0]
+
+                if A[e].is_Number and B[e].is_Number:
+                    # both exponents are numbers
+                    if A[f] == B[f]:
+                        if A[si] != B[si]:
+                            B = process.pop(0)
+                            take = min(A[e], B[e])
+
+                            # reinsert any remainder
+                            # the B will likely sort after A so check it first
+                            if B[e] != take:
+                                rem = [B[i] for i in keys]
+                                rem[e] -= take
+                                process.insert(0, rem)
+                            elif A[e] != take:
+                                rem = [A[i] for i in keys]
+                                rem[e] -= take
+                                process.insert(0, rem)
+
+                            if isinstance(A[f], cos):
+                                t = sin
+                            else:
+                                t = cos
+                            other.append((-A[g]*B[g]*t(A[f].args[0])**2)**take)
+                            continue
+
+                elif A[e] == B[e]:
+                    # both exponents are equal symbols
+                    if A[f] == B[f]:
+                        if A[si] != B[si]:
+                            B = process.pop(0)
+                            take = A[e]
+                            if isinstance(A[f], cos):
+                                t = sin
+                            else:
+                                t = cos
+                            other.append((-A[g]*B[g]*t(A[f].args[0])**2)**take)
+                            continue
+
+            # either we are done or neither condition above applied
+            other.append(A[a]**A[e])
+
+        if len(other) != nother:
+            rv = Mul(*other)
+
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def TR15(rv, max=4, pow=False):
+    """Convert sin(x)**-2 to 1 + cot(x)**2.
+
+    See _TR56 docstring for advanced use of ``max`` and ``pow``.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR15
+    >>> from sympy.abc import x
+    >>> from sympy import sin
+    >>> TR15(1 - 1/sin(x)**2)
+    -cot(x)**2
+
+    """
+
+    def f(rv):
+        if not (isinstance(rv, Pow) and isinstance(rv.base, sin)):
+            return rv
+
+        e = rv.exp
+        if e % 2 == 1:
+            return TR15(rv.base**(e + 1))/rv.base
+
+        ia = 1/rv
+        a = _TR56(ia, sin, cot, lambda x: 1 + x, max=max, pow=pow)
+        if a != ia:
+            rv = a
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def TR16(rv, max=4, pow=False):
+    """Convert cos(x)**-2 to 1 + tan(x)**2.
+
+    See _TR56 docstring for advanced use of ``max`` and ``pow``.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR16
+    >>> from sympy.abc import x
+    >>> from sympy import cos
+    >>> TR16(1 - 1/cos(x)**2)
+    -tan(x)**2
+
+    """
+
+    def f(rv):
+        if not (isinstance(rv, Pow) and isinstance(rv.base, cos)):
+            return rv
+
+        e = rv.exp
+        if e % 2 == 1:
+            return TR15(rv.base**(e + 1))/rv.base
+
+        ia = 1/rv
+        a = _TR56(ia, cos, tan, lambda x: 1 + x, max=max, pow=pow)
+        if a != ia:
+            rv = a
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def TR111(rv):
+    """Convert f(x)**-i to g(x)**i where either ``i`` is an integer
+    or the base is positive and f, g are: tan, cot; sin, csc; or cos, sec.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR111
+    >>> from sympy.abc import x
+    >>> from sympy import tan
+    >>> TR111(1 - 1/tan(x)**2)
+    1 - cot(x)**2
+
+    """
+
+    def f(rv):
+        if not (
+            isinstance(rv, Pow) and
+            (rv.base.is_positive or rv.exp.is_integer and rv.exp.is_negative)):
+            return rv
+
+        if isinstance(rv.base, tan):
+            return cot(rv.base.args[0])**-rv.exp
+        elif isinstance(rv.base, sin):
+            return csc(rv.base.args[0])**-rv.exp
+        elif isinstance(rv.base, cos):
+            return sec(rv.base.args[0])**-rv.exp
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def TR22(rv, max=4, pow=False):
+    """Convert tan(x)**2 to sec(x)**2 - 1 and cot(x)**2 to csc(x)**2 - 1.
+
+    See _TR56 docstring for advanced use of ``max`` and ``pow``.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TR22
+    >>> from sympy.abc import x
+    >>> from sympy import tan, cot
+    >>> TR22(1 + tan(x)**2)
+    sec(x)**2
+    >>> TR22(1 + cot(x)**2)
+    csc(x)**2
+
+    """
+
+    def f(rv):
+        if not (isinstance(rv, Pow) and rv.base.func in (cot, tan)):
+            return rv
+
+        rv = _TR56(rv, tan, sec, lambda x: x - 1, max=max, pow=pow)
+        rv = _TR56(rv, cot, csc, lambda x: x - 1, max=max, pow=pow)
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def TRpower(rv):
+    """Convert sin(x)**n and cos(x)**n with positive n to sums.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import TRpower
+    >>> from sympy.abc import x
+    >>> from sympy import cos, sin
+    >>> TRpower(sin(x)**6)
+    -15*cos(2*x)/32 + 3*cos(4*x)/16 - cos(6*x)/32 + 5/16
+    >>> TRpower(sin(x)**3*cos(2*x)**4)
+    (3*sin(x)/4 - sin(3*x)/4)*(cos(4*x)/2 + cos(8*x)/8 + 3/8)
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/List_of_trigonometric_identities#Power-reduction_formulae
+
+    """
+
+    def f(rv):
+        if not (isinstance(rv, Pow) and isinstance(rv.base, (sin, cos))):
+            return rv
+        b, n = rv.as_base_exp()
+        x = b.args[0]
+        if n.is_Integer and n.is_positive:
+            if n.is_odd and isinstance(b, cos):
+                rv = 2**(1-n)*Add(*[binomial(n, k)*cos((n - 2*k)*x)
+                    for k in range((n + 1)/2)])
+            elif n.is_odd and isinstance(b, sin):
+                rv = 2**(1-n)*S.NegativeOne**((n-1)/2)*Add(*[binomial(n, k)*
+                    S.NegativeOne**k*sin((n - 2*k)*x) for k in range((n + 1)/2)])
+            elif n.is_even and isinstance(b, cos):
+                rv = 2**(1-n)*Add(*[binomial(n, k)*cos((n - 2*k)*x)
+                    for k in range(n/2)])
+            elif n.is_even and isinstance(b, sin):
+                rv = 2**(1-n)*S.NegativeOne**(n/2)*Add(*[binomial(n, k)*
+                    S.NegativeOne**k*cos((n - 2*k)*x) for k in range(n/2)])
+            if n.is_even:
+                rv += 2**(-n)*binomial(n, n/2)
+        return rv
+
+    return bottom_up(rv, f)
+
+
+def L(rv):
+    """Return count of trigonometric functions in expression.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import L
+    >>> from sympy.abc import x
+    >>> from sympy import cos, sin
+    >>> L(cos(x)+sin(x))
+    2
+    """
+    return S(rv.count(TrigonometricFunction))
+
+
+# ============== end of basic Fu-like tools =====================
+
+if SYMPY_DEBUG:
+    (TR0, TR1, TR2, TR3, TR4, TR5, TR6, TR7, TR8, TR9, TR10, TR11, TR12, TR13,
+    TR2i, TRmorrie, TR14, TR15, TR16, TR12i, TR111, TR22
+    )= list(map(debug,
+    (TR0, TR1, TR2, TR3, TR4, TR5, TR6, TR7, TR8, TR9, TR10, TR11, TR12, TR13,
+    TR2i, TRmorrie, TR14, TR15, TR16, TR12i, TR111, TR22)))
+
+
+# tuples are chains  --  (f, g) -> lambda x: g(f(x))
+# lists are choices  --  [f, g] -> lambda x: min(f(x), g(x), key=objective)
+
+CTR1 = [(TR5, TR0), (TR6, TR0), identity]
+
+CTR2 = (TR11, [(TR5, TR0), (TR6, TR0), TR0])
+
+CTR3 = [(TRmorrie, TR8, TR0), (TRmorrie, TR8, TR10i, TR0), identity]
+
+CTR4 = [(TR4, TR10i), identity]
+
+RL1 = (TR4, TR3, TR4, TR12, TR4, TR13, TR4, TR0)
+
+
+# XXX it's a little unclear how this one is to be implemented
+# see Fu paper of reference, page 7. What is the Union symbol referring to?
+# The diagram shows all these as one chain of transformations, but the
+# text refers to them being applied independently. Also, a break
+# if L starts to increase has not been implemented.
+RL2 = [
+    (TR4, TR3, TR10, TR4, TR3, TR11),
+    (TR5, TR7, TR11, TR4),
+    (CTR3, CTR1, TR9, CTR2, TR4, TR9, TR9, CTR4),
+    identity,
+    ]
+
+
+def fu(rv, measure=lambda x: (L(x), x.count_ops())):
+    """Attempt to simplify expression by using transformation rules given
+    in the algorithm by Fu et al.
+
+    :func:`fu` will try to minimize the objective function ``measure``.
+    By default this first minimizes the number of trig terms and then minimizes
+    the number of total operations.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import fu
+    >>> from sympy import cos, sin, tan, pi, S, sqrt
+    >>> from sympy.abc import x, y, a, b
+
+    >>> fu(sin(50)**2 + cos(50)**2 + sin(pi/6))
+    3/2
+    >>> fu(sqrt(6)*cos(x) + sqrt(2)*sin(x))
+    2*sqrt(2)*sin(x + pi/3)
+
+    CTR1 example
+
+    >>> eq = sin(x)**4 - cos(y)**2 + sin(y)**2 + 2*cos(x)**2
+    >>> fu(eq)
+    cos(x)**4 - 2*cos(y)**2 + 2
+
+    CTR2 example
+
+    >>> fu(S.Half - cos(2*x)/2)
+    sin(x)**2
+
+    CTR3 example
+
+    >>> fu(sin(a)*(cos(b) - sin(b)) + cos(a)*(sin(b) + cos(b)))
+    sqrt(2)*sin(a + b + pi/4)
+
+    CTR4 example
+
+    >>> fu(sqrt(3)*cos(x)/2 + sin(x)/2)
+    sin(x + pi/3)
+
+    Example 1
+
+    >>> fu(1-sin(2*x)**2/4-sin(y)**2-cos(x)**4)
+    -cos(x)**2 + cos(y)**2
+
+    Example 2
+
+    >>> fu(cos(4*pi/9))
+    sin(pi/18)
+    >>> fu(cos(pi/9)*cos(2*pi/9)*cos(3*pi/9)*cos(4*pi/9))
+    1/16
+
+    Example 3
+
+    >>> fu(tan(7*pi/18)+tan(5*pi/18)-sqrt(3)*tan(5*pi/18)*tan(7*pi/18))
+    -sqrt(3)
+
+    Objective function example
+
+    >>> fu(sin(x)/cos(x))  # default objective function
+    tan(x)
+    >>> fu(sin(x)/cos(x), measure=lambda x: -x.count_ops()) # maximize op count
+    sin(x)/cos(x)
+
+    References
+    ==========
+
+    .. [1] https://www.sciencedirect.com/science/article/pii/S0895717706001609
+    """
+    fRL1 = greedy(RL1, measure)
+    fRL2 = greedy(RL2, measure)
+
+    was = rv
+    rv = sympify(rv)
+    if not isinstance(rv, Expr):
+        return rv.func(*[fu(a, measure=measure) for a in rv.args])
+    rv = TR1(rv)
+    if rv.has(tan, cot):
+        rv1 = fRL1(rv)
+        if (measure(rv1) < measure(rv)):
+            rv = rv1
+        if rv.has(tan, cot):
+            rv = TR2(rv)
+    if rv.has(sin, cos):
+        rv1 = fRL2(rv)
+        rv2 = TR8(TRmorrie(rv1))
+        rv = min([was, rv, rv1, rv2], key=measure)
+    return min(TR2i(rv), rv, key=measure)
+
+
+def process_common_addends(rv, do, key2=None, key1=True):
+    """Apply ``do`` to addends of ``rv`` that (if ``key1=True``) share at least
+    a common absolute value of their coefficient and the value of ``key2`` when
+    applied to the argument. If ``key1`` is False ``key2`` must be supplied and
+    will be the only key applied.
+    """
+
+    # collect by absolute value of coefficient and key2
+    absc = defaultdict(list)
+    if key1:
+        for a in rv.args:
+            c, a = a.as_coeff_Mul()
+            if c < 0:
+                c = -c
+                a = -a  # put the sign on `a`
+            absc[(c, key2(a) if key2 else 1)].append(a)
+    elif key2:
+        for a in rv.args:
+            absc[(S.One, key2(a))].append(a)
+    else:
+        raise ValueError('must have at least one key')
+
+    args = []
+    hit = False
+    for k in absc:
+        v = absc[k]
+        c, _ = k
+        if len(v) > 1:
+            e = Add(*v, evaluate=False)
+            new = do(e)
+            if new != e:
+                e = new
+                hit = True
+            args.append(c*e)
+        else:
+            args.append(c*v[0])
+    if hit:
+        rv = Add(*args)
+
+    return rv
+
+
+fufuncs = '''
+    TR0 TR1 TR2 TR3 TR4 TR5 TR6 TR7 TR8 TR9 TR10 TR10i TR11
+    TR12 TR13 L TR2i TRmorrie TR12i
+    TR14 TR15 TR16 TR111 TR22'''.split()
+FU = dict(list(zip(fufuncs, list(map(locals().get, fufuncs)))))
+
+
+def _roots():
+    global _ROOT2, _ROOT3, _invROOT3
+    _ROOT2, _ROOT3 = sqrt(2), sqrt(3)
+    _invROOT3 = 1/_ROOT3
+_ROOT2 = None
+
+
+def trig_split(a, b, two=False):
+    """Return the gcd, s1, s2, a1, a2, bool where
+
+    If two is False (default) then::
+        a + b = gcd*(s1*f(a1) + s2*f(a2)) where f = cos if bool else sin
+    else:
+        if bool, a + b was +/- cos(a1)*cos(a2) +/- sin(a1)*sin(a2) and equals
+            n1*gcd*cos(a - b) if n1 == n2 else
+            n1*gcd*cos(a + b)
+        else a + b was +/- cos(a1)*sin(a2) +/- sin(a1)*cos(a2) and equals
+            n1*gcd*sin(a + b) if n1 = n2 else
+            n1*gcd*sin(b - a)
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import trig_split
+    >>> from sympy.abc import x, y, z
+    >>> from sympy import cos, sin, sqrt
+
+    >>> trig_split(cos(x), cos(y))
+    (1, 1, 1, x, y, True)
+    >>> trig_split(2*cos(x), -2*cos(y))
+    (2, 1, -1, x, y, True)
+    >>> trig_split(cos(x)*sin(y), cos(y)*sin(y))
+    (sin(y), 1, 1, x, y, True)
+
+    >>> trig_split(cos(x), -sqrt(3)*sin(x), two=True)
+    (2, 1, -1, x, pi/6, False)
+    >>> trig_split(cos(x), sin(x), two=True)
+    (sqrt(2), 1, 1, x, pi/4, False)
+    >>> trig_split(cos(x), -sin(x), two=True)
+    (sqrt(2), 1, -1, x, pi/4, False)
+    >>> trig_split(sqrt(2)*cos(x), -sqrt(6)*sin(x), two=True)
+    (2*sqrt(2), 1, -1, x, pi/6, False)
+    >>> trig_split(-sqrt(6)*cos(x), -sqrt(2)*sin(x), two=True)
+    (-2*sqrt(2), 1, 1, x, pi/3, False)
+    >>> trig_split(cos(x)/sqrt(6), sin(x)/sqrt(2), two=True)
+    (sqrt(6)/3, 1, 1, x, pi/6, False)
+    >>> trig_split(-sqrt(6)*cos(x)*sin(y), -sqrt(2)*sin(x)*sin(y), two=True)
+    (-2*sqrt(2)*sin(y), 1, 1, x, pi/3, False)
+
+    >>> trig_split(cos(x), sin(x))
+    >>> trig_split(cos(x), sin(z))
+    >>> trig_split(2*cos(x), -sin(x))
+    >>> trig_split(cos(x), -sqrt(3)*sin(x))
+    >>> trig_split(cos(x)*cos(y), sin(x)*sin(z))
+    >>> trig_split(cos(x)*cos(y), sin(x)*sin(y))
+    >>> trig_split(-sqrt(6)*cos(x), sqrt(2)*sin(x)*sin(y), two=True)
+    """
+    global _ROOT2, _ROOT3, _invROOT3
+    if _ROOT2 is None:
+        _roots()
+
+    a, b = [Factors(i) for i in (a, b)]
+    ua, ub = a.normal(b)
+    gcd = a.gcd(b).as_expr()
+    n1 = n2 = 1
+    if S.NegativeOne in ua.factors:
+        ua = ua.quo(S.NegativeOne)
+        n1 = -n1
+    elif S.NegativeOne in ub.factors:
+        ub = ub.quo(S.NegativeOne)
+        n2 = -n2
+    a, b = [i.as_expr() for i in (ua, ub)]
+
+    def pow_cos_sin(a, two):
+        """Return ``a`` as a tuple (r, c, s) such that
+        ``a = (r or 1)*(c or 1)*(s or 1)``.
+
+        Three arguments are returned (radical, c-factor, s-factor) as
+        long as the conditions set by ``two`` are met; otherwise None is
+        returned. If ``two`` is True there will be one or two non-None
+        values in the tuple: c and s or c and r or s and r or s or c with c
+        being a cosine function (if possible) else a sine, and s being a sine
+        function (if possible) else oosine. If ``two`` is False then there
+        will only be a c or s term in the tuple.
+
+        ``two`` also require that either two cos and/or sin be present (with
+        the condition that if the functions are the same the arguments are
+        different or vice versa) or that a single cosine or a single sine
+        be present with an optional radical.
+
+        If the above conditions dictated by ``two`` are not met then None
+        is returned.
+        """
+        c = s = None
+        co = S.One
+        if a.is_Mul:
+            co, a = a.as_coeff_Mul()
+            if len(a.args) > 2 or not two:
+                return None
+            if a.is_Mul:
+                args = list(a.args)
+            else:
+                args = [a]
+            a = args.pop(0)
+            if isinstance(a, cos):
+                c = a
+            elif isinstance(a, sin):
+                s = a
+            elif a.is_Pow and a.exp is S.Half:  # autoeval doesn't allow -1/2
+                co *= a
+            else:
+                return None
+            if args:
+                b = args[0]
+                if isinstance(b, cos):
+                    if c:
+                        s = b
+                    else:
+                        c = b
+                elif isinstance(b, sin):
+                    if s:
+                        c = b
+                    else:
+                        s = b
+                elif b.is_Pow and b.exp is S.Half:
+                    co *= b
+                else:
+                    return None
+            return co if co is not S.One else None, c, s
+        elif isinstance(a, cos):
+            c = a
+        elif isinstance(a, sin):
+            s = a
+        if c is None and s is None:
+            return
+        co = co if co is not S.One else None
+        return co, c, s
+
+    # get the parts
+    m = pow_cos_sin(a, two)
+    if m is None:
+        return
+    coa, ca, sa = m
+    m = pow_cos_sin(b, two)
+    if m is None:
+        return
+    cob, cb, sb = m
+
+    # check them
+    if (not ca) and cb or ca and isinstance(ca, sin):
+        coa, ca, sa, cob, cb, sb = cob, cb, sb, coa, ca, sa
+        n1, n2 = n2, n1
+    if not two:  # need cos(x) and cos(y) or sin(x) and sin(y)
+        c = ca or sa
+        s = cb or sb
+        if not isinstance(c, s.func):
+            return None
+        return gcd, n1, n2, c.args[0], s.args[0], isinstance(c, cos)
+    else:
+        if not coa and not cob:
+            if (ca and cb and sa and sb):
+                if isinstance(ca, sa.func) is not isinstance(cb, sb.func):
+                    return
+                args = {j.args for j in (ca, sa)}
+                if not all(i.args in args for i in (cb, sb)):
+                    return
+                return gcd, n1, n2, ca.args[0], sa.args[0], isinstance(ca, sa.func)
+        if ca and sa or cb and sb or \
+            two and (ca is None and sa is None or cb is None and sb is None):
+            return
+        c = ca or sa
+        s = cb or sb
+        if c.args != s.args:
+            return
+        if not coa:
+            coa = S.One
+        if not cob:
+            cob = S.One
+        if coa is cob:
+            gcd *= _ROOT2
+            return gcd, n1, n2, c.args[0], pi/4, False
+        elif coa/cob == _ROOT3:
+            gcd *= 2*cob
+            return gcd, n1, n2, c.args[0], pi/3, False
+        elif coa/cob == _invROOT3:
+            gcd *= 2*coa
+            return gcd, n1, n2, c.args[0], pi/6, False
+
+
+def as_f_sign_1(e):
+    """If ``e`` is a sum that can be written as ``g*(a + s)`` where
+    ``s`` is ``+/-1``, return ``g``, ``a``, and ``s`` where ``a`` does
+    not have a leading negative coefficient.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import as_f_sign_1
+    >>> from sympy.abc import x
+    >>> as_f_sign_1(x + 1)
+    (1, x, 1)
+    >>> as_f_sign_1(x - 1)
+    (1, x, -1)
+    >>> as_f_sign_1(-x + 1)
+    (-1, x, -1)
+    >>> as_f_sign_1(-x - 1)
+    (-1, x, 1)
+    >>> as_f_sign_1(2*x + 2)
+    (2, x, 1)
+    """
+    if not e.is_Add or len(e.args) != 2:
+        return
+    # exact match
+    a, b = e.args
+    if a in (S.NegativeOne, S.One):
+        g = S.One
+        if b.is_Mul and b.args[0].is_Number and b.args[0] < 0:
+            a, b = -a, -b
+            g = -g
+        return g, b, a
+    # gcd match
+    a, b = [Factors(i) for i in e.args]
+    ua, ub = a.normal(b)
+    gcd = a.gcd(b).as_expr()
+    if S.NegativeOne in ua.factors:
+        ua = ua.quo(S.NegativeOne)
+        n1 = -1
+        n2 = 1
+    elif S.NegativeOne in ub.factors:
+        ub = ub.quo(S.NegativeOne)
+        n1 = 1
+        n2 = -1
+    else:
+        n1 = n2 = 1
+    a, b = [i.as_expr() for i in (ua, ub)]
+    if a is S.One:
+        a, b = b, a
+        n1, n2 = n2, n1
+    if n1 == -1:
+        gcd = -gcd
+        n2 = -n2
+
+    if b is S.One:
+        return gcd, a, n2
+
+
+def _osborne(e, d):
+    """Replace all hyperbolic functions with trig functions using
+    the Osborne rule.
+
+    Notes
+    =====
+
+    ``d`` is a dummy variable to prevent automatic evaluation
+    of trigonometric/hyperbolic functions.
+
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Hyperbolic_function
+    """
+
+    def f(rv):
+        if not isinstance(rv, HyperbolicFunction):
+            return rv
+        a = rv.args[0]
+        a = a*d if not a.is_Add else Add._from_args([i*d for i in a.args])
+        if isinstance(rv, sinh):
+            return I*sin(a)
+        elif isinstance(rv, cosh):
+            return cos(a)
+        elif isinstance(rv, tanh):
+            return I*tan(a)
+        elif isinstance(rv, coth):
+            return cot(a)/I
+        elif isinstance(rv, sech):
+            return sec(a)
+        elif isinstance(rv, csch):
+            return csc(a)/I
+        else:
+            raise NotImplementedError('unhandled %s' % rv.func)
+
+    return bottom_up(e, f)
+
+
+def _osbornei(e, d):
+    """Replace all trig functions with hyperbolic functions using
+    the Osborne rule.
+
+    Notes
+    =====
+
+    ``d`` is a dummy variable to prevent automatic evaluation
+    of trigonometric/hyperbolic functions.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Hyperbolic_function
+    """
+
+    def f(rv):
+        if not isinstance(rv, TrigonometricFunction):
+            return rv
+        const, x = rv.args[0].as_independent(d, as_Add=True)
+        a = x.xreplace({d: S.One}) + const*I
+        if isinstance(rv, sin):
+            return sinh(a)/I
+        elif isinstance(rv, cos):
+            return cosh(a)
+        elif isinstance(rv, tan):
+            return tanh(a)/I
+        elif isinstance(rv, cot):
+            return coth(a)*I
+        elif isinstance(rv, sec):
+            return sech(a)
+        elif isinstance(rv, csc):
+            return csch(a)*I
+        else:
+            raise NotImplementedError('unhandled %s' % rv.func)
+
+    return bottom_up(e, f)
+
+
+def hyper_as_trig(rv):
+    """Return an expression containing hyperbolic functions in terms
+    of trigonometric functions. Any trigonometric functions initially
+    present are replaced with Dummy symbols and the function to undo
+    the masking and the conversion back to hyperbolics is also returned. It
+    should always be true that::
+
+        t, f = hyper_as_trig(expr)
+        expr == f(t)
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import hyper_as_trig, fu
+    >>> from sympy.abc import x
+    >>> from sympy import cosh, sinh
+    >>> eq = sinh(x)**2 + cosh(x)**2
+    >>> t, f = hyper_as_trig(eq)
+    >>> f(fu(t))
+    cosh(2*x)
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Hyperbolic_function
+    """
+    from sympy.simplify.simplify import signsimp
+    from sympy.simplify.radsimp import collect
+
+    # mask off trig functions
+    trigs = rv.atoms(TrigonometricFunction)
+    reps = [(t, Dummy()) for t in trigs]
+    masked = rv.xreplace(dict(reps))
+
+    # get inversion substitutions in place
+    reps = [(v, k) for k, v in reps]
+
+    d = Dummy()
+
+    return _osborne(masked, d), lambda x: collect(signsimp(
+        _osbornei(x, d).xreplace(dict(reps))), S.ImaginaryUnit)
+
+
+def sincos_to_sum(expr):
+    """Convert products and powers of sin and cos to sums.
+
+    Explanation
+    ===========
+
+    Applied power reduction TRpower first, then expands products, and
+    converts products to sums with TR8.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.fu import sincos_to_sum
+    >>> from sympy.abc import x
+    >>> from sympy import cos, sin
+    >>> sincos_to_sum(16*sin(x)**3*cos(2*x)**2)
+    7*sin(x) - 5*sin(3*x) + 3*sin(5*x) - sin(7*x)
+    """
+
+    if not expr.has(cos, sin):
+        return expr
+    else:
+        return TR8(expand_mul(TRpower(expr)))

llmeval-env/lib/python3.10/site-packages/sympy/simplify/gammasimp.py

@@ -0,0 +1,497 @@
+from sympy.core import Function, S, Mul, Pow, Add
+from sympy.core.sorting import ordered, default_sort_key
+from sympy.core.function import expand_func
+from sympy.core.symbol import Dummy
+from sympy.functions import gamma, sqrt, sin
+from sympy.polys import factor, cancel
+from sympy.utilities.iterables import sift, uniq
+
+
+def gammasimp(expr):
+    r"""
+    Simplify expressions with gamma functions.
+
+    Explanation
+    ===========
+
+    This function takes as input an expression containing gamma
+    functions or functions that can be rewritten in terms of gamma
+    functions and tries to minimize the number of those functions and
+    reduce the size of their arguments.
+
+    The algorithm works by rewriting all gamma functions as expressions
+    involving rising factorials (Pochhammer symbols) and applies
+    recurrence relations and other transformations applicable to rising
+    factorials, to reduce their arguments, possibly letting the resulting
+    rising factorial to cancel. Rising factorials with the second argument
+    being an integer are expanded into polynomial forms and finally all
+    other rising factorial are rewritten in terms of gamma functions.
+
+    Then the following two steps are performed.
+
+    1. Reduce the number of gammas by applying the reflection theorem
+       gamma(x)*gamma(1-x) == pi/sin(pi*x).
+    2. Reduce the number of gammas by applying the multiplication theorem
+       gamma(x)*gamma(x+1/n)*...*gamma(x+(n-1)/n) == C*gamma(n*x).
+
+    It then reduces the number of prefactors by absorbing them into gammas
+    where possible and expands gammas with rational argument.
+
+    All transformation rules can be found (or were derived from) here:
+
+    .. [1] https://functions.wolfram.com/GammaBetaErf/Pochhammer/17/01/02/
+    .. [2] https://functions.wolfram.com/GammaBetaErf/Pochhammer/27/01/0005/
+
+    Examples
+    ========
+
+    >>> from sympy.simplify import gammasimp
+    >>> from sympy import gamma, Symbol
+    >>> from sympy.abc import x
+    >>> n = Symbol('n', integer = True)
+
+    >>> gammasimp(gamma(x)/gamma(x - 3))
+    (x - 3)*(x - 2)*(x - 1)
+    >>> gammasimp(gamma(n + 3))
+    gamma(n + 3)
+
+    """
+
+    expr = expr.rewrite(gamma)
+
+    # compute_ST will be looking for Functions and we don't want
+    # it looking for non-gamma functions: issue 22606
+    # so we mask free, non-gamma functions
+    f = expr.atoms(Function)
+    # take out gammas
+    gammas = {i for i in f if isinstance(i, gamma)}
+    if not gammas:
+        return expr  # avoid side effects like factoring
+    f -= gammas
+    # keep only those without bound symbols
+    f = f & expr.as_dummy().atoms(Function)
+    if f:
+        dum, fun, simp = zip(*[
+            (Dummy(), fi, fi.func(*[
+                _gammasimp(a, as_comb=False) for a in fi.args]))
+            for fi in ordered(f)])
+        d = expr.xreplace(dict(zip(fun, dum)))
+        return _gammasimp(d, as_comb=False).xreplace(dict(zip(dum, simp)))
+
+    return _gammasimp(expr, as_comb=False)
+
+
+def _gammasimp(expr, as_comb):
+    """
+    Helper function for gammasimp and combsimp.
+
+    Explanation
+    ===========
+
+    Simplifies expressions written in terms of gamma function. If
+    as_comb is True, it tries to preserve integer arguments. See
+    docstring of gammasimp for more information. This was part of
+    combsimp() in combsimp.py.
+    """
+    expr = expr.replace(gamma,
+        lambda n: _rf(1, (n - 1).expand()))
+
+    if as_comb:
+        expr = expr.replace(_rf,
+            lambda a, b: gamma(b + 1))
+    else:
+        expr = expr.replace(_rf,
+            lambda a, b: gamma(a + b)/gamma(a))
+
+    def rule_gamma(expr, level=0):
+        """ Simplify products of gamma functions further. """
+
+        if expr.is_Atom:
+            return expr
+
+        def gamma_rat(x):
+            # helper to simplify ratios of gammas
+            was = x.count(gamma)
+            xx = x.replace(gamma, lambda n: _rf(1, (n - 1).expand()
+                ).replace(_rf, lambda a, b: gamma(a + b)/gamma(a)))
+            if xx.count(gamma) < was:
+                x = xx
+            return x
+
+        def gamma_factor(x):
+            # return True if there is a gamma factor in shallow args
+            if isinstance(x, gamma):
+                return True
+            if x.is_Add or x.is_Mul:
+                return any(gamma_factor(xi) for xi in x.args)
+            if x.is_Pow and (x.exp.is_integer or x.base.is_positive):
+                return gamma_factor(x.base)
+            return False
+
+        # recursion step
+        if level == 0:
+            expr = expr.func(*[rule_gamma(x, level + 1) for x in expr.args])
+            level += 1
+
+        if not expr.is_Mul:
+            return expr
+
+        # non-commutative step
+        if level == 1:
+            args, nc = expr.args_cnc()
+            if not args:
+                return expr
+            if nc:
+                return rule_gamma(Mul._from_args(args), level + 1)*Mul._from_args(nc)
+            level += 1
+
+        # pure gamma handling, not factor absorption
+        if level == 2:
+            T, F = sift(expr.args, gamma_factor, binary=True)
+            gamma_ind = Mul(*F)
+            d = Mul(*T)
+
+            nd, dd = d.as_numer_denom()
+            for ipass in range(2):
+                args = list(ordered(Mul.make_args(nd)))
+                for i, ni in enumerate(args):
+                    if ni.is_Add:
+                        ni, dd = Add(*[
+                            rule_gamma(gamma_rat(a/dd), level + 1) for a in ni.args]
+                            ).as_numer_denom()
+                        args[i] = ni
+                        if not dd.has(gamma):
+                            break
+                nd = Mul(*args)
+                if ipass ==  0 and not gamma_factor(nd):
+                    break
+                nd, dd = dd, nd  # now process in reversed order
+            expr = gamma_ind*nd/dd
+            if not (expr.is_Mul and (gamma_factor(dd) or gamma_factor(nd))):
+                return expr
+            level += 1
+
+        # iteration until constant
+        if level == 3:
+            while True:
+                was = expr
+                expr = rule_gamma(expr, 4)
+                if expr == was:
+                    return expr
+
+        numer_gammas = []
+        denom_gammas = []
+        numer_others = []
+        denom_others = []
+        def explicate(p):
+            if p is S.One:
+                return None, []
+            b, e = p.as_base_exp()
+            if e.is_Integer:
+                if isinstance(b, gamma):
+                    return True, [b.args[0]]*e
+                else:
+                    return False, [b]*e
+            else:
+                return False, [p]
+
+        newargs = list(ordered(expr.args))
+        while newargs:
+            n, d = newargs.pop().as_numer_denom()
+            isg, l = explicate(n)
+            if isg:
+                numer_gammas.extend(l)
+            elif isg is False:
+                numer_others.extend(l)
+            isg, l = explicate(d)
+            if isg:
+                denom_gammas.extend(l)
+            elif isg is False:
+                denom_others.extend(l)
+
+        # =========== level 2 work: pure gamma manipulation =========
+
+        if not as_comb:
+            # Try to reduce the number of gamma factors by applying the
+            # reflection formula gamma(x)*gamma(1-x) = pi/sin(pi*x)
+            for gammas, numer, denom in [(
+                numer_gammas, numer_others, denom_others),
+                    (denom_gammas, denom_others, numer_others)]:
+                new = []
+                while gammas:
+                    g1 = gammas.pop()
+                    if g1.is_integer:
+                        new.append(g1)
+                        continue
+                    for i, g2 in enumerate(gammas):
+                        n = g1 + g2 - 1
+                        if not n.is_Integer:
+                            continue
+                        numer.append(S.Pi)
+                        denom.append(sin(S.Pi*g1))
+                        gammas.pop(i)
+                        if n > 0:
+                            for k in range(n):
+                                numer.append(1 - g1 + k)
+                        elif n < 0:
+                            for k in range(-n):
+                                denom.append(-g1 - k)
+                        break
+                    else:
+                        new.append(g1)
+                # /!\ updating IN PLACE
+                gammas[:] = new
+
+            # Try to reduce the number of gammas by using the duplication
+            # theorem to cancel an upper and lower: gamma(2*s)/gamma(s) =
+            # 2**(2*s + 1)/(4*sqrt(pi))*gamma(s + 1/2). Although this could
+            # be done with higher argument ratios like gamma(3*x)/gamma(x),
+            # this would not reduce the number of gammas as in this case.
+            for ng, dg, no, do in [(numer_gammas, denom_gammas, numer_others,
+                                    denom_others),
+                                   (denom_gammas, numer_gammas, denom_others,
+                                    numer_others)]:
+
+                while True:
+                    for x in ng:
+                        for y in dg:
+                            n = x - 2*y
+                            if n.is_Integer:
+                                break
+                        else:
+                            continue
+                        break
+                    else:
+                        break
+                    ng.remove(x)
+                    dg.remove(y)
+                    if n > 0:
+                        for k in range(n):
+                            no.append(2*y + k)
+                    elif n < 0:
+                        for k in range(-n):
+                            do.append(2*y - 1 - k)
+                    ng.append(y + S.Half)
+                    no.append(2**(2*y - 1))
+                    do.append(sqrt(S.Pi))
+
+            # Try to reduce the number of gamma factors by applying the
+            # multiplication theorem (used when n gammas with args differing
+            # by 1/n mod 1 are encountered).
+            #
+            # run of 2 with args differing by 1/2
+            #
+            # >>> gammasimp(gamma(x)*gamma(x+S.Half))
+            # 2*sqrt(2)*2**(-2*x - 1/2)*sqrt(pi)*gamma(2*x)
+            #
+            # run of 3 args differing by 1/3 (mod 1)
+            #
+            # >>> gammasimp(gamma(x)*gamma(x+S(1)/3)*gamma(x+S(2)/3))
+            # 6*3**(-3*x - 1/2)*pi*gamma(3*x)
+            # >>> gammasimp(gamma(x)*gamma(x+S(1)/3)*gamma(x+S(5)/3))
+            # 2*3**(-3*x - 1/2)*pi*(3*x + 2)*gamma(3*x)
+            #
+            def _run(coeffs):
+                # find runs in coeffs such that the difference in terms (mod 1)
+                # of t1, t2, ..., tn is 1/n
+                u = list(uniq(coeffs))
+                for i in range(len(u)):
+                    dj = ([((u[j] - u[i]) % 1, j) for j in range(i + 1, len(u))])
+                    for one, j in dj:
+                        if one.p == 1 and one.q != 1:
+                            n = one.q
+                            got = [i]
+                            get = list(range(1, n))
+                            for d, j in dj:
+                                m = n*d
+                                if m.is_Integer and m in get:
+                                    get.remove(m)
+                                    got.append(j)
+                                    if not get:
+                                        break
+                            else:
+                                continue
+                            for i, j in enumerate(got):
+                                c = u[j]
+                                coeffs.remove(c)
+                                got[i] = c
+                            return one.q, got[0], got[1:]
+
+            def _mult_thm(gammas, numer, denom):
+                # pull off and analyze the leading coefficient from each gamma arg
+                # looking for runs in those Rationals
+
+                # expr -> coeff + resid -> rats[resid] = coeff
+                rats = {}
+                for g in gammas:
+                    c, resid = g.as_coeff_Add()
+                    rats.setdefault(resid, []).append(c)
+
+                # look for runs in Rationals for each resid
+                keys = sorted(rats, key=default_sort_key)
+                for resid in keys:
+                    coeffs = sorted(rats[resid])
+                    new = []
+                    while True:
+                        run = _run(coeffs)
+                        if run is None:
+                            break
+
+                        # process the sequence that was found:
+                        # 1) convert all the gamma functions to have the right
+                        #    argument (could be off by an integer)
+                        # 2) append the factors corresponding to the theorem
+                        # 3) append the new gamma function
+
+                        n, ui, other = run
+
+                        # (1)
+                        for u in other:
+                            con = resid + u - 1
+                            for k in range(int(u - ui)):
+                                numer.append(con - k)
+
+                        con = n*(resid + ui)  # for (2) and (3)
+
+                        # (2)
+                        numer.append((2*S.Pi)**(S(n - 1)/2)*
+                                     n**(S.Half - con))
+                        # (3)
+                        new.append(con)
+
+                    # restore resid to coeffs
+                    rats[resid] = [resid + c for c in coeffs] + new
+
+                # rebuild the gamma arguments
+                g = []
+                for resid in keys:
+                    g += rats[resid]
+                # /!\ updating IN PLACE
+                gammas[:] = g
+
+            for l, numer, denom in [(numer_gammas, numer_others, denom_others),
+                                    (denom_gammas, denom_others, numer_others)]:
+                _mult_thm(l, numer, denom)
+
+        # =========== level >= 2 work: factor absorption =========
+
+        if level >= 2:
+            # Try to absorb factors into the gammas: x*gamma(x) -> gamma(x + 1)
+            # and gamma(x)/(x - 1) -> gamma(x - 1)
+            # This code (in particular repeated calls to find_fuzzy) can be very
+            # slow.
+            def find_fuzzy(l, x):
+                if not l:
+                    return
+                S1, T1 = compute_ST(x)
+                for y in l:
+                    S2, T2 = inv[y]
+                    if T1 != T2 or (not S1.intersection(S2) and
+                                    (S1 != set() or S2 != set())):
+                        continue
+                    # XXX we want some simplification (e.g. cancel or
+                    # simplify) but no matter what it's slow.
+                    a = len(cancel(x/y).free_symbols)
+                    b = len(x.free_symbols)
+                    c = len(y.free_symbols)
+                    # TODO is there a better heuristic?
+                    if a == 0 and (b > 0 or c > 0):
+                        return y
+
+            # We thus try to avoid expensive calls by building the following
+            # "invariants": For every factor or gamma function argument
+            #   - the set of free symbols S
+            #   - the set of functional components T
+            # We will only try to absorb if T1==T2 and (S1 intersect S2 != emptyset
+            # or S1 == S2 == emptyset)
+            inv = {}
+
+            def compute_ST(expr):
+                if expr in inv:
+                    return inv[expr]
+                return (expr.free_symbols, expr.atoms(Function).union(
+                        {e.exp for e in expr.atoms(Pow)}))
+
+            def update_ST(expr):
+                inv[expr] = compute_ST(expr)
+            for expr in numer_gammas + denom_gammas + numer_others + denom_others:
+                update_ST(expr)
+
+            for gammas, numer, denom in [(
+                numer_gammas, numer_others, denom_others),
+                    (denom_gammas, denom_others, numer_others)]:
+                new = []
+                while gammas:
+                    g = gammas.pop()
+                    cont = True
+                    while cont:
+                        cont = False
+                        y = find_fuzzy(numer, g)
+                        if y is not None:
+                            numer.remove(y)
+                            if y != g:
+                                numer.append(y/g)
+                                update_ST(y/g)
+                            g += 1
+                            cont = True
+                        y = find_fuzzy(denom, g - 1)
+                        if y is not None:
+                            denom.remove(y)
+                            if y != g - 1:
+                                numer.append((g - 1)/y)
+                                update_ST((g - 1)/y)
+                            g -= 1
+                            cont = True
+                    new.append(g)
+                # /!\ updating IN PLACE
+                gammas[:] = new
+
+        # =========== rebuild expr ==================================
+
+        return Mul(*[gamma(g) for g in numer_gammas]) \
+            / Mul(*[gamma(g) for g in denom_gammas]) \
+            * Mul(*numer_others) / Mul(*denom_others)
+
+    was = factor(expr)
+    # (for some reason we cannot use Basic.replace in this case)
+    expr = rule_gamma(was)
+    if expr != was:
+        expr = factor(expr)
+
+    expr = expr.replace(gamma,
+        lambda n: expand_func(gamma(n)) if n.is_Rational else gamma(n))
+
+    return expr
+
+
+class _rf(Function):
+    @classmethod
+    def eval(cls, a, b):
+        if b.is_Integer:
+            if not b:
+                return S.One
+
+            n = int(b)
+
+            if n > 0:
+                return Mul(*[a + i for i in range(n)])
+            elif n < 0:
+                return 1/Mul(*[a - i for i in range(1, -n + 1)])
+        else:
+            if b.is_Add:
+                c, _b = b.as_coeff_Add()
+
+                if c.is_Integer:
+                    if c > 0:
+                        return _rf(a, _b)*_rf(a + _b, c)
+                    elif c < 0:
+                        return _rf(a, _b)/_rf(a + _b + c, -c)
+
+            if a.is_Add:
+                c, _a = a.as_coeff_Add()
+
+                if c.is_Integer:
+                    if c > 0:
+                        return _rf(_a, b)*_rf(_a + b, c)/_rf(_a, c)
+                    elif c < 0:
+                        return _rf(_a, b)*_rf(_a + c, -c)/_rf(_a + b + c, -c)

llmeval-env/lib/python3.10/site-packages/sympy/simplify/hyperexpand.py

@@ -0,0 +1,2494 @@
+"""
+Expand Hypergeometric (and Meijer G) functions into named
+special functions.
+
+The algorithm for doing this uses a collection of lookup tables of
+hypergeometric functions, and various of their properties, to expand
+many hypergeometric functions in terms of special functions.
+
+It is based on the following paper:
+      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.
+
+It is described in great(er) detail in the Sphinx documentation.
+"""
+# SUMMARY OF EXTENSIONS FOR MEIJER G FUNCTIONS
+#
+# o z**rho G(ap, bq; z) = G(ap + rho, bq + rho; z)
+#
+# o denote z*d/dz by D
+#
+# o It is helpful to keep in mind that ap and bq play essentially symmetric
+#   roles: G(1/z) has slightly altered parameters, with ap and bq interchanged.
+#
+# o There are four shift operators:
+#   A_J = b_J - D,     J = 1, ..., n
+#   B_J = 1 - a_j + D, J = 1, ..., m
+#   C_J = -b_J + D,    J = m+1, ..., q
+#   D_J = a_J - 1 - D, J = n+1, ..., p
+#
+#   A_J, C_J increment b_J
+#   B_J, D_J decrement a_J
+#
+# o The corresponding four inverse-shift operators are defined if there
+#   is no cancellation. Thus e.g. an index a_J (upper or lower) can be
+#   incremented if a_J != b_i for i = 1, ..., q.
+#
+# o Order reduction: if b_j - a_i is a non-negative integer, where
+#   j <= m and i > n, the corresponding quotient of gamma functions reduces
+#   to a polynomial. Hence the G function can be expressed using a G-function
+#   of lower order.
+#   Similarly if j > m and i <= n.
+#
+#   Secondly, there are paired index theorems [Adamchik, The evaluation of
+#   integrals of Bessel functions via G-function identities]. Suppose there
+#   are three parameters a, b, c, where a is an a_i, i <= n, b is a b_j,
+#   j <= m and c is a denominator parameter (i.e. a_i, i > n or b_j, j > m).
+#   Suppose further all three differ by integers.
+#   Then the order can be reduced.
+#   TODO work this out in detail.
+#
+# o An index quadruple is called suitable if its order cannot be reduced.
+#   If there exists a sequence of shift operators transforming one index
+#   quadruple into another, we say one is reachable from the other.
+#
+# o Deciding if one index quadruple is reachable from another is tricky. For
+#   this reason, we use hand-built routines to match and instantiate formulas.
+#
+from collections import defaultdict
+from itertools import product
+from functools import reduce
+from math import prod
+
+from sympy import SYMPY_DEBUG
+from sympy.core import (S, Dummy, symbols, sympify, Tuple, expand, I, pi, Mul,
+    EulerGamma, oo, zoo, expand_func, Add, nan, Expr, Rational)
+from sympy.core.mod import Mod
+from sympy.core.sorting import default_sort_key
+from sympy.functions import (exp, sqrt, root, log, lowergamma, cos,
+        besseli, gamma, uppergamma, expint, erf, sin, besselj, Ei, Ci, Si, Shi,
+        sinh, cosh, Chi, fresnels, fresnelc, polar_lift, exp_polar, floor, ceiling,
+        rf, factorial, lerchphi, Piecewise, re, elliptic_k, elliptic_e)
+from sympy.functions.elementary.complexes import polarify, unpolarify
+from sympy.functions.special.hyper import (hyper, HyperRep_atanh,
+        HyperRep_power1, HyperRep_power2, HyperRep_log1, HyperRep_asin1,
+        HyperRep_asin2, HyperRep_sqrts1, HyperRep_sqrts2, HyperRep_log2,
+        HyperRep_cosasin, HyperRep_sinasin, meijerg)
+from sympy.matrices import Matrix, eye, zeros
+from sympy.polys import apart, poly, Poly
+from sympy.series import residue
+from sympy.simplify.powsimp import powdenest
+from sympy.utilities.iterables import sift
+
+# function to define "buckets"
+def _mod1(x):
+    # TODO see if this can work as Mod(x, 1); this will require
+    # different handling of the "buckets" since these need to
+    # be sorted and that fails when there is a mixture of
+    # integers and expressions with parameters. With the current
+    # Mod behavior, Mod(k, 1) == Mod(1, 1) == 0 if k is an integer.
+    # Although the sorting can be done with Basic.compare, this may
+    # still require different handling of the sorted buckets.
+    if x.is_Number:
+        return Mod(x, 1)
+    c, x = x.as_coeff_Add()
+    return Mod(c, 1) + x
+
+
+# leave add formulae at the top for easy reference
+def add_formulae(formulae):
+    """ Create our knowledge base. """
+    a, b, c, z = symbols('a b c, z', cls=Dummy)
+
+    def add(ap, bq, res):
+        func = Hyper_Function(ap, bq)
+        formulae.append(Formula(func, z, res, (a, b, c)))
+
+    def addb(ap, bq, B, C, M):
+        func = Hyper_Function(ap, bq)
+        formulae.append(Formula(func, z, None, (a, b, c), B, C, M))
+
+    # Luke, Y. L. (1969), The Special Functions and Their Approximations,
+    # Volume 1, section 6.2
+
+    # 0F0
+    add((), (), exp(z))
+
+    # 1F0
+    add((a, ), (), HyperRep_power1(-a, z))
+
+    # 2F1
+    addb((a, a - S.Half), (2*a, ),
+         Matrix([HyperRep_power2(a, z),
+                 HyperRep_power2(a + S.Half, z)/2]),
+         Matrix([[1, 0]]),
+         Matrix([[(a - S.Half)*z/(1 - z), (S.Half - a)*z/(1 - z)],
+                 [a/(1 - z), a*(z - 2)/(1 - z)]]))
+    addb((1, 1), (2, ),
+         Matrix([HyperRep_log1(z), 1]), Matrix([[-1/z, 0]]),
+         Matrix([[0, z/(z - 1)], [0, 0]]))
+    addb((S.Half, 1), (S('3/2'), ),
+         Matrix([HyperRep_atanh(z), 1]),
+         Matrix([[1, 0]]),
+         Matrix([[Rational(-1, 2), 1/(1 - z)/2], [0, 0]]))
+    addb((S.Half, S.Half), (S('3/2'), ),
+         Matrix([HyperRep_asin1(z), HyperRep_power1(Rational(-1, 2), z)]),
+         Matrix([[1, 0]]),
+         Matrix([[Rational(-1, 2), S.Half], [0, z/(1 - z)/2]]))
+    addb((a, S.Half + a), (S.Half, ),
+         Matrix([HyperRep_sqrts1(-a, z), -HyperRep_sqrts2(-a - S.Half, z)]),
+         Matrix([[1, 0]]),
+         Matrix([[0, -a],
+                 [z*(-2*a - 1)/2/(1 - z), S.Half - z*(-2*a - 1)/(1 - z)]]))
+
+    # A. P. Prudnikov, Yu. A. Brychkov and O. I. Marichev (1990).
+    # Integrals and Series: More Special Functions, Vol. 3,.
+    # Gordon and Breach Science Publisher
+    addb([a, -a], [S.Half],
+         Matrix([HyperRep_cosasin(a, z), HyperRep_sinasin(a, z)]),
+         Matrix([[1, 0]]),
+         Matrix([[0, -a], [a*z/(1 - z), 1/(1 - z)/2]]))
+    addb([1, 1], [3*S.Half],
+         Matrix([HyperRep_asin2(z), 1]), Matrix([[1, 0]]),
+         Matrix([[(z - S.Half)/(1 - z), 1/(1 - z)/2], [0, 0]]))
+
+    # Complete elliptic integrals K(z) and E(z), both a 2F1 function
+    addb([S.Half, S.Half], [S.One],
+         Matrix([elliptic_k(z), elliptic_e(z)]),
+         Matrix([[2/pi, 0]]),
+         Matrix([[Rational(-1, 2), -1/(2*z-2)],
+                 [Rational(-1, 2), S.Half]]))
+    addb([Rational(-1, 2), S.Half], [S.One],
+         Matrix([elliptic_k(z), elliptic_e(z)]),
+         Matrix([[0, 2/pi]]),
+         Matrix([[Rational(-1, 2), -1/(2*z-2)],
+                 [Rational(-1, 2), S.Half]]))
+
+    # 3F2
+    addb([Rational(-1, 2), 1, 1], [S.Half, 2],
+         Matrix([z*HyperRep_atanh(z), HyperRep_log1(z), 1]),
+         Matrix([[Rational(-2, 3), -S.One/(3*z), Rational(2, 3)]]),
+         Matrix([[S.Half, 0, z/(1 - z)/2],
+                 [0, 0, z/(z - 1)],
+                 [0, 0, 0]]))
+    # actually the formula for 3/2 is much nicer ...
+    addb([Rational(-1, 2), 1, 1], [2, 2],
+         Matrix([HyperRep_power1(S.Half, z), HyperRep_log2(z), 1]),
+         Matrix([[Rational(4, 9) - 16/(9*z), 4/(3*z), 16/(9*z)]]),
+         Matrix([[z/2/(z - 1), 0, 0], [1/(2*(z - 1)), 0, S.Half], [0, 0, 0]]))
+
+    # 1F1
+    addb([1], [b], Matrix([z**(1 - b) * exp(z) * lowergamma(b - 1, z), 1]),
+         Matrix([[b - 1, 0]]), Matrix([[1 - b + z, 1], [0, 0]]))
+    addb([a], [2*a],
+         Matrix([z**(S.Half - a)*exp(z/2)*besseli(a - S.Half, z/2)
+                 * gamma(a + S.Half)/4**(S.Half - a),
+                 z**(S.Half - a)*exp(z/2)*besseli(a + S.Half, z/2)
+                 * gamma(a + S.Half)/4**(S.Half - a)]),
+         Matrix([[1, 0]]),
+         Matrix([[z/2, z/2], [z/2, (z/2 - 2*a)]]))
+    mz = polar_lift(-1)*z
+    addb([a], [a + 1],
+         Matrix([mz**(-a)*a*lowergamma(a, mz), a*exp(z)]),
+         Matrix([[1, 0]]),
+         Matrix([[-a, 1], [0, z]]))
+    # This one is redundant.
+    add([Rational(-1, 2)], [S.Half], exp(z) - sqrt(pi*z)*(-I)*erf(I*sqrt(z)))
+
+    # Added to get nice results for Laplace transform of Fresnel functions
+    # https://functions.wolfram.com/07.22.03.6437.01
+    # Basic rule
+    #add([1], [Rational(3, 4), Rational(5, 4)],
+    #    sqrt(pi) * (cos(2*sqrt(polar_lift(-1)*z))*fresnelc(2*root(polar_lift(-1)*z,4)/sqrt(pi)) +
+    #                sin(2*sqrt(polar_lift(-1)*z))*fresnels(2*root(polar_lift(-1)*z,4)/sqrt(pi)))
+    #    / (2*root(polar_lift(-1)*z,4)))
+    # Manually tuned rule
+    addb([1], [Rational(3, 4), Rational(5, 4)],
+         Matrix([ sqrt(pi)*(I*sinh(2*sqrt(z))*fresnels(2*root(z, 4)*exp(I*pi/4)/sqrt(pi))
+                            + cosh(2*sqrt(z))*fresnelc(2*root(z, 4)*exp(I*pi/4)/sqrt(pi)))
+                  * exp(-I*pi/4)/(2*root(z, 4)),
+                  sqrt(pi)*root(z, 4)*(sinh(2*sqrt(z))*fresnelc(2*root(z, 4)*exp(I*pi/4)/sqrt(pi))
+                                      + I*cosh(2*sqrt(z))*fresnels(2*root(z, 4)*exp(I*pi/4)/sqrt(pi)))
+                  *exp(-I*pi/4)/2,
+                  1 ]),
+         Matrix([[1, 0, 0]]),
+         Matrix([[Rational(-1, 4),              1, Rational(1, 4)],
+                 [              z, Rational(1, 4),              0],
+                 [              0,              0,              0]]))
+
+    # 2F2
+    addb([S.Half, a], [Rational(3, 2), a + 1],
+         Matrix([a/(2*a - 1)*(-I)*sqrt(pi/z)*erf(I*sqrt(z)),
+                 a/(2*a - 1)*(polar_lift(-1)*z)**(-a)*
+                 lowergamma(a, polar_lift(-1)*z),
+                 a/(2*a - 1)*exp(z)]),
+         Matrix([[1, -1, 0]]),
+         Matrix([[Rational(-1, 2), 0, 1], [0, -a, 1], [0, 0, z]]))
+    # We make a "basis" of four functions instead of three, and give EulerGamma
+    # an extra slot (it could just be a coefficient to 1). The advantage is
+    # that this way Polys will not see multivariate polynomials (it treats
+    # EulerGamma as an indeterminate), which is *way* faster.
+    addb([1, 1], [2, 2],
+         Matrix([Ei(z) - log(z), exp(z), 1, EulerGamma]),
+         Matrix([[1/z, 0, 0, -1/z]]),
+         Matrix([[0, 1, -1, 0], [0, z, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]))
+
+    # 0F1
+    add((), (S.Half, ), cosh(2*sqrt(z)))
+    addb([], [b],
+         Matrix([gamma(b)*z**((1 - b)/2)*besseli(b - 1, 2*sqrt(z)),
+                 gamma(b)*z**(1 - b/2)*besseli(b, 2*sqrt(z))]),
+         Matrix([[1, 0]]), Matrix([[0, 1], [z, (1 - b)]]))
+
+    # 0F3
+    x = 4*z**Rational(1, 4)
+
+    def fp(a, z):
+        return besseli(a, x) + besselj(a, x)
+
+    def fm(a, z):
+        return besseli(a, x) - besselj(a, x)
+
+    # TODO branching
+    addb([], [S.Half, a, a + S.Half],
+         Matrix([fp(2*a - 1, z), fm(2*a, z)*z**Rational(1, 4),
+                 fm(2*a - 1, z)*sqrt(z), fp(2*a, z)*z**Rational(3, 4)])
+         * 2**(-2*a)*gamma(2*a)*z**((1 - 2*a)/4),
+         Matrix([[1, 0, 0, 0]]),
+         Matrix([[0, 1, 0, 0],
+                 [0, S.Half - a, 1, 0],
+                 [0, 0, S.Half, 1],
+                 [z, 0, 0, 1 - a]]))
+    x = 2*(4*z)**Rational(1, 4)*exp_polar(I*pi/4)
+    addb([], [a, a + S.Half, 2*a],
+         (2*sqrt(polar_lift(-1)*z))**(1 - 2*a)*gamma(2*a)**2 *
+         Matrix([besselj(2*a - 1, x)*besseli(2*a - 1, x),
+                 x*(besseli(2*a, x)*besselj(2*a - 1, x)
+                    - besseli(2*a - 1, x)*besselj(2*a, x)),
+                 x**2*besseli(2*a, x)*besselj(2*a, x),
+                 x**3*(besseli(2*a, x)*besselj(2*a - 1, x)
+                       + besseli(2*a - 1, x)*besselj(2*a, x))]),
+         Matrix([[1, 0, 0, 0]]),
+         Matrix([[0, Rational(1, 4), 0, 0],
+                 [0, (1 - 2*a)/2, Rational(-1, 2), 0],
+                 [0, 0, 1 - 2*a, Rational(1, 4)],
+                 [-32*z, 0, 0, 1 - a]]))
+
+    # 1F2
+    addb([a], [a - S.Half, 2*a],
+         Matrix([z**(S.Half - a)*besseli(a - S.Half, sqrt(z))**2,
+                 z**(1 - a)*besseli(a - S.Half, sqrt(z))
+                 *besseli(a - Rational(3, 2), sqrt(z)),
+                 z**(Rational(3, 2) - a)*besseli(a - Rational(3, 2), sqrt(z))**2]),
+         Matrix([[-gamma(a + S.Half)**2/4**(S.Half - a),
+                 2*gamma(a - S.Half)*gamma(a + S.Half)/4**(1 - a),
+                 0]]),
+         Matrix([[1 - 2*a, 1, 0], [z/2, S.Half - a, S.Half], [0, z, 0]]))
+    addb([S.Half], [b, 2 - b],
+         pi*(1 - b)/sin(pi*b)*
+         Matrix([besseli(1 - b, sqrt(z))*besseli(b - 1, sqrt(z)),
+                 sqrt(z)*(besseli(-b, sqrt(z))*besseli(b - 1, sqrt(z))
+                          + besseli(1 - b, sqrt(z))*besseli(b, sqrt(z))),
+                 besseli(-b, sqrt(z))*besseli(b, sqrt(z))]),
+         Matrix([[1, 0, 0]]),
+         Matrix([[b - 1, S.Half, 0],
+                 [z, 0, z],
+                 [0, S.Half, -b]]))
+    addb([S.Half], [Rational(3, 2), Rational(3, 2)],
+         Matrix([Shi(2*sqrt(z))/2/sqrt(z), sinh(2*sqrt(z))/2/sqrt(z),
+                 cosh(2*sqrt(z))]),
+         Matrix([[1, 0, 0]]),
+         Matrix([[Rational(-1, 2), S.Half, 0], [0, Rational(-1, 2), S.Half], [0, 2*z, 0]]))
+
+    # FresnelS
+    # Basic rule
+    #add([Rational(3, 4)], [Rational(3, 2),Rational(7, 4)], 6*fresnels( exp(pi*I/4)*root(z,4)*2/sqrt(pi) ) / ( pi * (exp(pi*I/4)*root(z,4)*2/sqrt(pi))**3 ) )
+    # Manually tuned rule
+    addb([Rational(3, 4)], [Rational(3, 2), Rational(7, 4)],
+         Matrix(
+             [ fresnels(
+                 exp(
+                     pi*I/4)*root(
+                         z, 4)*2/sqrt(
+                             pi) ) / (
+                                 pi * (exp(pi*I/4)*root(z, 4)*2/sqrt(pi))**3 ),
+               sinh(2*sqrt(z))/sqrt(z),
+               cosh(2*sqrt(z)) ]),
+         Matrix([[6, 0, 0]]),
+         Matrix([[Rational(-3, 4),  Rational(1, 16), 0],
+                 [ 0,      Rational(-1, 2),  1],
+                 [ 0,       z,       0]]))
+
+    # FresnelC
+    # Basic rule
+    #add([Rational(1, 4)], [S.Half,Rational(5, 4)], fresnelc( exp(pi*I/4)*root(z,4)*2/sqrt(pi) ) / ( exp(pi*I/4)*root(z,4)*2/sqrt(pi) ) )
+    # Manually tuned rule
+    addb([Rational(1, 4)], [S.Half, Rational(5, 4)],
+         Matrix(
+             [ sqrt(
+                 pi)*exp(
+                     -I*pi/4)*fresnelc(
+                         2*root(z, 4)*exp(I*pi/4)/sqrt(pi))/(2*root(z, 4)),
+               cosh(2*sqrt(z)),
+               sinh(2*sqrt(z))*sqrt(z) ]),
+         Matrix([[1, 0, 0]]),
+         Matrix([[Rational(-1, 4),  Rational(1, 4), 0     ],
+                 [ 0,       0,      1     ],
+                 [ 0,       z,      S.Half]]))
+
+    # 2F3
+    # XXX with this five-parameter formula is pretty slow with the current
+    #     Formula.find_instantiations (creates 2!*3!*3**(2+3) ~ 3000
+    #     instantiations ... But it's not too bad.
+    addb([a, a + S.Half], [2*a, b, 2*a - b + 1],
+         gamma(b)*gamma(2*a - b + 1) * (sqrt(z)/2)**(1 - 2*a) *
+         Matrix([besseli(b - 1, sqrt(z))*besseli(2*a - b, sqrt(z)),
+                 sqrt(z)*besseli(b, sqrt(z))*besseli(2*a - b, sqrt(z)),
+                 sqrt(z)*besseli(b - 1, sqrt(z))*besseli(2*a - b + 1, sqrt(z)),
+                 besseli(b, sqrt(z))*besseli(2*a - b + 1, sqrt(z))]),
+         Matrix([[1, 0, 0, 0]]),
+         Matrix([[0, S.Half, S.Half, 0],
+                 [z/2, 1 - b, 0, z/2],
+                 [z/2, 0, b - 2*a, z/2],
+                 [0, S.Half, S.Half, -2*a]]))
+    # (C/f above comment about eulergamma in the basis).
+    addb([1, 1], [2, 2, Rational(3, 2)],
+         Matrix([Chi(2*sqrt(z)) - log(2*sqrt(z)),
+                 cosh(2*sqrt(z)), sqrt(z)*sinh(2*sqrt(z)), 1, EulerGamma]),
+         Matrix([[1/z, 0, 0, 0, -1/z]]),
+         Matrix([[0, S.Half, 0, Rational(-1, 2), 0],
+                 [0, 0, 1, 0, 0],
+                 [0, z, S.Half, 0, 0],
+                 [0, 0, 0, 0, 0],
+                 [0, 0, 0, 0, 0]]))
+
+    # 3F3
+    # This is rule: https://functions.wolfram.com/07.31.03.0134.01
+    # Initial reason to add it was a nice solution for
+    # integrate(erf(a*z)/z**2, z) and same for erfc and erfi.
+    # Basic rule
+    # add([1, 1, a], [2, 2, a+1], (a/(z*(a-1)**2)) *
+    #     (1 - (-z)**(1-a) * (gamma(a) - uppergamma(a,-z))
+    #      - (a-1) * (EulerGamma + uppergamma(0,-z) + log(-z))
+    #      - exp(z)))
+    # Manually tuned rule
+    addb([1, 1, a], [2, 2, a+1],
+         Matrix([a*(log(-z) + expint(1, -z) + EulerGamma)/(z*(a**2 - 2*a + 1)),
+                 a*(-z)**(-a)*(gamma(a) - uppergamma(a, -z))/(a - 1)**2,
+                 a*exp(z)/(a**2 - 2*a + 1),
+                 a/(z*(a**2 - 2*a + 1))]),
+         Matrix([[1-a, 1, -1/z, 1]]),
+         Matrix([[-1,0,-1/z,1],
+                 [0,-a,1,0],
+                 [0,0,z,0],
+                 [0,0,0,-1]]))
+
+
+def add_meijerg_formulae(formulae):
+    a, b, c, z = list(map(Dummy, 'abcz'))
+    rho = Dummy('rho')
+
+    def add(an, ap, bm, bq, B, C, M, matcher):
+        formulae.append(MeijerFormula(an, ap, bm, bq, z, [a, b, c, rho],
+                                      B, C, M, matcher))
+
+    def detect_uppergamma(func):
+        x = func.an[0]
+        y, z = func.bm
+        swapped = False
+        if not _mod1((x - y).simplify()):
+            swapped = True
+            (y, z) = (z, y)
+        if _mod1((x - z).simplify()) or x - z > 0:
+            return None
+        l = [y, x]
+        if swapped:
+            l = [x, y]
+        return {rho: y, a: x - y}, G_Function([x], [], l, [])
+
+    add([a + rho], [], [rho, a + rho], [],
+        Matrix([gamma(1 - a)*z**rho*exp(z)*uppergamma(a, z),
+                gamma(1 - a)*z**(a + rho)]),
+        Matrix([[1, 0]]),
+        Matrix([[rho + z, -1], [0, a + rho]]),
+        detect_uppergamma)
+
+    def detect_3113(func):
+        """https://functions.wolfram.com/07.34.03.0984.01"""
+        x = func.an[0]
+        u, v, w = func.bm
+        if _mod1((u - v).simplify()) == 0:
+            if _mod1((v - w).simplify()) == 0:
+                return
+            sig = (S.Half, S.Half, S.Zero)
+            x1, x2, y = u, v, w
+        else:
+            if _mod1((x - u).simplify()) == 0:
+                sig = (S.Half, S.Zero, S.Half)
+                x1, y, x2 = u, v, w
+            else:
+                sig = (S.Zero, S.Half, S.Half)
+                y, x1, x2 = u, v, w
+
+        if (_mod1((x - x1).simplify()) != 0 or
+            _mod1((x - x2).simplify()) != 0 or
+            _mod1((x - y).simplify()) != S.Half or
+                x - x1 > 0 or x - x2 > 0):
+            return
+
+        return {a: x}, G_Function([x], [], [x - S.Half + t for t in sig], [])
+
+    s = sin(2*sqrt(z))
+    c_ = cos(2*sqrt(z))
+    S_ = Si(2*sqrt(z)) - pi/2
+    C = Ci(2*sqrt(z))
+    add([a], [], [a, a, a - S.Half], [],
+        Matrix([sqrt(pi)*z**(a - S.Half)*(c_*S_ - s*C),
+                sqrt(pi)*z**a*(s*S_ + c_*C),
+                sqrt(pi)*z**a]),
+        Matrix([[-2, 0, 0]]),
+        Matrix([[a - S.Half, -1, 0], [z, a, S.Half], [0, 0, a]]),
+        detect_3113)
+
+
+def make_simp(z):
+    """ Create a function that simplifies rational functions in ``z``. """
+
+    def simp(expr):
+        """ Efficiently simplify the rational function ``expr``. """
+        numer, denom = expr.as_numer_denom()
+        numer = numer.expand()
+        # denom = denom.expand()  # is this needed?
+        c, numer, denom = poly(numer, z).cancel(poly(denom, z))
+        return c * numer.as_expr() / denom.as_expr()
+
+    return simp
+
+
+def debug(*args):
+    if SYMPY_DEBUG:
+        for a in args:
+            print(a, end="")
+        print()
+
+
+class Hyper_Function(Expr):
+    """ A generalized hypergeometric function. """
+
+    def __new__(cls, ap, bq):
+        obj = super().__new__(cls)
+        obj.ap = Tuple(*list(map(expand, ap)))
+        obj.bq = Tuple(*list(map(expand, bq)))
+        return obj
+
+    @property
+    def args(self):
+        return (self.ap, self.bq)
+
+    @property
+    def sizes(self):
+        return (len(self.ap), len(self.bq))
+
+    @property
+    def gamma(self):
+        """
+        Number of upper parameters that are negative integers
+
+        This is a transformation invariant.
+        """
+        return sum(bool(x.is_integer and x.is_negative) for x in self.ap)
+
+    def _hashable_content(self):
+        return super()._hashable_content() + (self.ap,
+                self.bq)
+
+    def __call__(self, arg):
+        return hyper(self.ap, self.bq, arg)
+
+    def build_invariants(self):
+        """
+        Compute the invariant vector.
+
+        Explanation
+        ===========
+
+        The invariant vector is:
+            (gamma, ((s1, n1), ..., (sk, nk)), ((t1, m1), ..., (tr, mr)))
+        where gamma is the number of integer a < 0,
+              s1 < ... < sk
+              nl is the number of parameters a_i congruent to sl mod 1
+              t1 < ... < tr
+              ml is the number of parameters b_i congruent to tl mod 1
+
+        If the index pair contains parameters, then this is not truly an
+        invariant, since the parameters cannot be sorted uniquely mod1.
+
+        Examples
+        ========
+
+        >>> from sympy.simplify.hyperexpand import Hyper_Function
+        >>> from sympy import S
+        >>> ap = (S.Half, S.One/3, S(-1)/2, -2)
+        >>> bq = (1, 2)
+
+        Here gamma = 1,
+             k = 3, s1 = 0, s2 = 1/3, s3 = 1/2
+                    n1 = 1, n2 = 1,   n2 = 2
+             r = 1, t1 = 0
+                    m1 = 2:
+
+        >>> Hyper_Function(ap, bq).build_invariants()
+        (1, ((0, 1), (1/3, 1), (1/2, 2)), ((0, 2),))
+        """
+        abuckets, bbuckets = sift(self.ap, _mod1), sift(self.bq, _mod1)
+
+        def tr(bucket):
+            bucket = list(bucket.items())
+            if not any(isinstance(x[0], Mod) for x in bucket):
+                bucket.sort(key=lambda x: default_sort_key(x[0]))
+            bucket = tuple([(mod, len(values)) for mod, values in bucket if
+                    values])
+            return bucket
+
+        return (self.gamma, tr(abuckets), tr(bbuckets))
+
+    def difficulty(self, func):
+        """ Estimate how many steps it takes to reach ``func`` from self.
+            Return -1 if impossible. """
+        if self.gamma != func.gamma:
+            return -1
+        oabuckets, obbuckets, abuckets, bbuckets = [sift(params, _mod1) for
+                params in (self.ap, self.bq, func.ap, func.bq)]
+
+        diff = 0
+        for bucket, obucket in [(abuckets, oabuckets), (bbuckets, obbuckets)]:
+            for mod in set(list(bucket.keys()) + list(obucket.keys())):
+                if (mod not in bucket) or (mod not in obucket) \
+                        or len(bucket[mod]) != len(obucket[mod]):
+                    return -1
+                l1 = list(bucket[mod])
+                l2 = list(obucket[mod])
+                l1.sort()
+                l2.sort()
+                for i, j in zip(l1, l2):
+                    diff += abs(i - j)
+
+        return diff
+
+    def _is_suitable_origin(self):
+        """
+        Decide if ``self`` is a suitable origin.
+
+        Explanation
+        ===========
+
+        A function is a suitable origin iff:
+        * none of the ai equals bj + n, with n a non-negative integer
+        * none of the ai is zero
+        * none of the bj is a non-positive integer
+
+        Note that this gives meaningful results only when none of the indices
+        are symbolic.
+
+        """
+        for a in self.ap:
+            for b in self.bq:
+                if (a - b).is_integer and (a - b).is_negative is False:
+                    return False
+        for a in self.ap:
+            if a == 0:
+                return False
+        for b in self.bq:
+            if b.is_integer and b.is_nonpositive:
+                return False
+        return True
+
+
+class G_Function(Expr):
+    """ A Meijer G-function. """
+
+    def __new__(cls, an, ap, bm, bq):
+        obj = super().__new__(cls)
+        obj.an = Tuple(*list(map(expand, an)))
+        obj.ap = Tuple(*list(map(expand, ap)))
+        obj.bm = Tuple(*list(map(expand, bm)))
+        obj.bq = Tuple(*list(map(expand, bq)))
+        return obj
+
+    @property
+    def args(self):
+        return (self.an, self.ap, self.bm, self.bq)
+
+    def _hashable_content(self):
+        return super()._hashable_content() + self.args
+
+    def __call__(self, z):
+        return meijerg(self.an, self.ap, self.bm, self.bq, z)
+
+    def compute_buckets(self):
+        """
+        Compute buckets for the fours sets of parameters.
+
+        Explanation
+        ===========
+
+        We guarantee that any two equal Mod objects returned are actually the
+        same, and that the buckets are sorted by real part (an and bq
+        descendending, bm and ap ascending).
+
+        Examples
+        ========
+
+        >>> from sympy.simplify.hyperexpand import G_Function
+        >>> from sympy.abc import y
+        >>> from sympy import S
+
+        >>> a, b = [1, 3, 2, S(3)/2], [1 + y, y, 2, y + 3]
+        >>> G_Function(a, b, [2], [y]).compute_buckets()
+        ({0: [3, 2, 1], 1/2: [3/2]},
+        {0: [2], y: [y, y + 1, y + 3]}, {0: [2]}, {y: [y]})
+
+        """
+        dicts = pan, pap, pbm, pbq = [defaultdict(list) for i in range(4)]
+        for dic, lis in zip(dicts, (self.an, self.ap, self.bm, self.bq)):
+            for x in lis:
+                dic[_mod1(x)].append(x)
+
+        for dic, flip in zip(dicts, (True, False, False, True)):
+            for m, items in dic.items():
+                x0 = items[0]
+                items.sort(key=lambda x: x - x0, reverse=flip)
+                dic[m] = items
+
+        return tuple([dict(w) for w in dicts])
+
+    @property
+    def signature(self):
+        return (len(self.an), len(self.ap), len(self.bm), len(self.bq))
+
+
+# Dummy variable.
+_x = Dummy('x')
+
+class Formula:
+    """
+    This class represents hypergeometric formulae.
+
+    Explanation
+    ===========
+
+    Its data members are:
+    - z, the argument
+    - closed_form, the closed form expression
+    - symbols, the free symbols (parameters) in the formula
+    - func, the function
+    - B, C, M (see _compute_basis)
+
+    Examples
+    ========
+
+    >>> from sympy.abc import a, b, z
+    >>> from sympy.simplify.hyperexpand import Formula, Hyper_Function
+    >>> func = Hyper_Function((a/2, a/3 + b, (1+a)/2), (a, b, (a+b)/7))
+    >>> f = Formula(func, z, None, [a, b])
+
+    """
+
+    def _compute_basis(self, closed_form):
+        """
+        Compute a set of functions B=(f1, ..., fn), a nxn matrix M
+        and a 1xn matrix C such that:
+           closed_form = C B
+           z d/dz B = M B.
+        """
+        afactors = [_x + a for a in self.func.ap]
+        bfactors = [_x + b - 1 for b in self.func.bq]
+        expr = _x*Mul(*bfactors) - self.z*Mul(*afactors)
+        poly = Poly(expr, _x)
+
+        n = poly.degree() - 1
+        b = [closed_form]
+        for _ in range(n):
+            b.append(self.z*b[-1].diff(self.z))
+
+        self.B = Matrix(b)
+        self.C = Matrix([[1] + [0]*n])
+
+        m = eye(n)
+        m = m.col_insert(0, zeros(n, 1))
+        l = poly.all_coeffs()[1:]
+        l.reverse()
+        self.M = m.row_insert(n, -Matrix([l])/poly.all_coeffs()[0])
+
+    def __init__(self, func, z, res, symbols, B=None, C=None, M=None):
+        z = sympify(z)
+        res = sympify(res)
+        symbols = [x for x in sympify(symbols) if func.has(x)]
+
+        self.z = z
+        self.symbols = symbols
+        self.B = B
+        self.C = C
+        self.M = M
+        self.func = func
+
+        # TODO with symbolic parameters, it could be advantageous
+        #      (for prettier answers) to compute a basis only *after*
+        #      instantiation
+        if res is not None:
+            self._compute_basis(res)
+
+    @property
+    def closed_form(self):
+        return reduce(lambda s,m: s+m[0]*m[1], zip(self.C, self.B), S.Zero)
+
+    def find_instantiations(self, func):
+        """
+        Find substitutions of the free symbols that match ``func``.
+
+        Return the substitution dictionaries as a list. Note that the returned
+        instantiations need not actually match, or be valid!
+
+        """
+        from sympy.solvers import solve
+        ap = func.ap
+        bq = func.bq
+        if len(ap) != len(self.func.ap) or len(bq) != len(self.func.bq):
+            raise TypeError('Cannot instantiate other number of parameters')
+        symbol_values = []
+        for a in self.symbols:
+            if a in self.func.ap.args:
+                symbol_values.append(ap)
+            elif a in self.func.bq.args:
+                symbol_values.append(bq)
+            else:
+                raise ValueError("At least one of the parameters of the "
+                        "formula must be equal to %s" % (a,))
+        base_repl = [dict(list(zip(self.symbols, values)))
+                for values in product(*symbol_values)]
+        abuckets, bbuckets = [sift(params, _mod1) for params in [ap, bq]]
+        a_inv, b_inv = [{a: len(vals) for a, vals in bucket.items()}
+                for bucket in [abuckets, bbuckets]]
+        critical_values = [[0] for _ in self.symbols]
+        result = []
+        _n = Dummy()
+        for repl in base_repl:
+            symb_a, symb_b = [sift(params, lambda x: _mod1(x.xreplace(repl)))
+                for params in [self.func.ap, self.func.bq]]
+            for bucket, obucket in [(abuckets, symb_a), (bbuckets, symb_b)]:
+                for mod in set(list(bucket.keys()) + list(obucket.keys())):
+                    if (mod not in bucket) or (mod not in obucket) \
+                            or len(bucket[mod]) != len(obucket[mod]):
+                        break
+                    for a, vals in zip(self.symbols, critical_values):
+                        if repl[a].free_symbols:
+                            continue
+                        exprs = [expr for expr in obucket[mod] if expr.has(a)]
+                        repl0 = repl.copy()
+                        repl0[a] += _n
+                        for expr in exprs:
+                            for target in bucket[mod]:
+                                n0, = solve(expr.xreplace(repl0) - target, _n)
+                                if n0.free_symbols:
+                                    raise ValueError("Value should not be true")
+                                vals.append(n0)
+            else:
+                values = []
+                for a, vals in zip(self.symbols, critical_values):
+                    a0 = repl[a]
+                    min_ = floor(min(vals))
+                    max_ = ceiling(max(vals))
+                    values.append([a0 + n for n in range(min_, max_ + 1)])
+                result.extend(dict(list(zip(self.symbols, l))) for l in product(*values))
+        return result
+
+
+
+
+class FormulaCollection:
+    """ A collection of formulae to use as origins. """
+
+    def __init__(self):
+        """ Doing this globally at module init time is a pain ... """
+        self.symbolic_formulae = {}
+        self.concrete_formulae = {}
+        self.formulae = []
+
+        add_formulae(self.formulae)
+
+        # Now process the formulae into a helpful form.
+        # These dicts are indexed by (p, q).
+
+        for f in self.formulae:
+            sizes = f.func.sizes
+            if len(f.symbols) > 0:
+                self.symbolic_formulae.setdefault(sizes, []).append(f)
+            else:
+                inv = f.func.build_invariants()
+                self.concrete_formulae.setdefault(sizes, {})[inv] = f
+
+    def lookup_origin(self, func):
+        """
+        Given the suitable target ``func``, try to find an origin in our
+        knowledge base.
+
+        Examples
+        ========
+
+        >>> from sympy.simplify.hyperexpand import (FormulaCollection,
+        ...     Hyper_Function)
+        >>> f = FormulaCollection()
+        >>> f.lookup_origin(Hyper_Function((), ())).closed_form
+        exp(_z)
+        >>> f.lookup_origin(Hyper_Function([1], ())).closed_form
+        HyperRep_power1(-1, _z)
+
+        >>> from sympy import S
+        >>> i = Hyper_Function([S('1/4'), S('3/4 + 4')], [S.Half])
+        >>> f.lookup_origin(i).closed_form
+        HyperRep_sqrts1(-1/4, _z)
+        """
+        inv = func.build_invariants()
+        sizes = func.sizes
+        if sizes in self.concrete_formulae and \
+                inv in self.concrete_formulae[sizes]:
+            return self.concrete_formulae[sizes][inv]
+
+        # We don't have a concrete formula. Try to instantiate.
+        if sizes not in self.symbolic_formulae:
+            return None  # Too bad...
+
+        possible = []
+        for f in self.symbolic_formulae[sizes]:
+            repls = f.find_instantiations(func)
+            for repl in repls:
+                func2 = f.func.xreplace(repl)
+                if not func2._is_suitable_origin():
+                    continue
+                diff = func2.difficulty(func)
+                if diff == -1:
+                    continue
+                possible.append((diff, repl, f, func2))
+
+        # find the nearest origin
+        possible.sort(key=lambda x: x[0])
+        for _, repl, f, func2 in possible:
+            f2 = Formula(func2, f.z, None, [], f.B.subs(repl),
+                    f.C.subs(repl), f.M.subs(repl))
+            if not any(e.has(S.NaN, oo, -oo, zoo) for e in [f2.B, f2.M, f2.C]):
+                return f2
+
+        return None
+
+
+class MeijerFormula:
+    """
+    This class represents a Meijer G-function formula.
+
+    Its data members are:
+    - z, the argument
+    - symbols, the free symbols (parameters) in the formula
+    - func, the function
+    - B, C, M (c/f ordinary Formula)
+    """
+
+    def __init__(self, an, ap, bm, bq, z, symbols, B, C, M, matcher):
+        an, ap, bm, bq = [Tuple(*list(map(expand, w))) for w in [an, ap, bm, bq]]
+        self.func = G_Function(an, ap, bm, bq)
+        self.z = z
+        self.symbols = symbols
+        self._matcher = matcher
+        self.B = B
+        self.C = C
+        self.M = M
+
+    @property
+    def closed_form(self):
+        return reduce(lambda s,m: s+m[0]*m[1], zip(self.C, self.B), S.Zero)
+
+    def try_instantiate(self, func):
+        """
+        Try to instantiate the current formula to (almost) match func.
+        This uses the _matcher passed on init.
+        """
+        if func.signature != self.func.signature:
+            return None
+        res = self._matcher(func)
+        if res is not None:
+            subs, newfunc = res
+            return MeijerFormula(newfunc.an, newfunc.ap, newfunc.bm, newfunc.bq,
+                                 self.z, [],
+                                 self.B.subs(subs), self.C.subs(subs),
+                                 self.M.subs(subs), None)
+
+
+class MeijerFormulaCollection:
+    """
+    This class holds a collection of meijer g formulae.
+    """
+
+    def __init__(self):
+        formulae = []
+        add_meijerg_formulae(formulae)
+        self.formulae = defaultdict(list)
+        for formula in formulae:
+            self.formulae[formula.func.signature].append(formula)
+        self.formulae = dict(self.formulae)
+
+    def lookup_origin(self, func):
+        """ Try to find a formula that matches func. """
+        if func.signature not in self.formulae:
+            return None
+        for formula in self.formulae[func.signature]:
+            res = formula.try_instantiate(func)
+            if res is not None:
+                return res
+
+
+class Operator:
+    """
+    Base class for operators to be applied to our functions.
+
+    Explanation
+    ===========
+
+    These operators are differential operators. They are by convention
+    expressed in the variable D = z*d/dz (although this base class does
+    not actually care).
+    Note that when the operator is applied to an object, we typically do
+    *not* blindly differentiate but instead use a different representation
+    of the z*d/dz operator (see make_derivative_operator).
+
+    To subclass from this, define a __init__ method that initializes a
+    self._poly variable. This variable stores a polynomial. By convention
+    the generator is z*d/dz, and acts to the right of all coefficients.
+
+    Thus this poly
+        x**2 + 2*z*x + 1
+    represents the differential operator
+        (z*d/dz)**2 + 2*z**2*d/dz.
+
+    This class is used only in the implementation of the hypergeometric
+    function expansion algorithm.
+    """
+
+    def apply(self, obj, op):
+        """
+        Apply ``self`` to the object ``obj``, where the generator is ``op``.
+
+        Examples
+        ========
+
+        >>> from sympy.simplify.hyperexpand import Operator
+        >>> from sympy.polys.polytools import Poly
+        >>> from sympy.abc import x, y, z
+        >>> op = Operator()
+        >>> op._poly = Poly(x**2 + z*x + y, x)
+        >>> op.apply(z**7, lambda f: f.diff(z))
+        y*z**7 + 7*z**7 + 42*z**5
+        """
+        coeffs = self._poly.all_coeffs()
+        coeffs.reverse()
+        diffs = [obj]
+        for c in coeffs[1:]:
+            diffs.append(op(diffs[-1]))
+        r = coeffs[0]*diffs[0]
+        for c, d in zip(coeffs[1:], diffs[1:]):
+            r += c*d
+        return r
+
+
+class MultOperator(Operator):
+    """ Simply multiply by a "constant" """
+
+    def __init__(self, p):
+        self._poly = Poly(p, _x)
+
+
+class ShiftA(Operator):
+    """ Increment an upper index. """
+
+    def __init__(self, ai):
+        ai = sympify(ai)
+        if ai == 0:
+            raise ValueError('Cannot increment zero upper index.')
+        self._poly = Poly(_x/ai + 1, _x)
+
+    def __str__(self):
+        return '<Increment upper %s.>' % (1/self._poly.all_coeffs()[0])
+
+
+class ShiftB(Operator):
+    """ Decrement a lower index. """
+
+    def __init__(self, bi):
+        bi = sympify(bi)
+        if bi == 1:
+            raise ValueError('Cannot decrement unit lower index.')
+        self._poly = Poly(_x/(bi - 1) + 1, _x)
+
+    def __str__(self):
+        return '<Decrement lower %s.>' % (1/self._poly.all_coeffs()[0] + 1)
+
+
+class UnShiftA(Operator):
+    """ Decrement an upper index. """
+
+    def __init__(self, ap, bq, i, z):
+        """ Note: i counts from zero! """
+        ap, bq, i = list(map(sympify, [ap, bq, i]))
+
+        self._ap = ap
+        self._bq = bq
+        self._i = i
+
+        ap = list(ap)
+        bq = list(bq)
+        ai = ap.pop(i) - 1
+
+        if ai == 0:
+            raise ValueError('Cannot decrement unit upper index.')
+
+        m = Poly(z*ai, _x)
+        for a in ap:
+            m *= Poly(_x + a, _x)
+
+        A = Dummy('A')
+        n = D = Poly(ai*A - ai, A)
+        for b in bq:
+            n *= D + (b - 1).as_poly(A)
+
+        b0 = -n.nth(0)
+        if b0 == 0:
+            raise ValueError('Cannot decrement upper index: '
+                             'cancels with lower')
+
+        n = Poly(Poly(n.all_coeffs()[:-1], A).as_expr().subs(A, _x/ai + 1), _x)
+
+        self._poly = Poly((n - m)/b0, _x)
+
+    def __str__(self):
+        return '<Decrement upper index #%s of %s, %s.>' % (self._i,
+                                                        self._ap, self._bq)
+
+
+class UnShiftB(Operator):
+    """ Increment a lower index. """
+
+    def __init__(self, ap, bq, i, z):
+        """ Note: i counts from zero! """
+        ap, bq, i = list(map(sympify, [ap, bq, i]))
+
+        self._ap = ap
+        self._bq = bq
+        self._i = i
+
+        ap = list(ap)
+        bq = list(bq)
+        bi = bq.pop(i) + 1
+
+        if bi == 0:
+            raise ValueError('Cannot increment -1 lower index.')
+
+        m = Poly(_x*(bi - 1), _x)
+        for b in bq:
+            m *= Poly(_x + b - 1, _x)
+
+        B = Dummy('B')
+        D = Poly((bi - 1)*B - bi + 1, B)
+        n = Poly(z, B)
+        for a in ap:
+            n *= (D + a.as_poly(B))
+
+        b0 = n.nth(0)
+        if b0 == 0:
+            raise ValueError('Cannot increment index: cancels with upper')
+
+        n = Poly(Poly(n.all_coeffs()[:-1], B).as_expr().subs(
+            B, _x/(bi - 1) + 1), _x)
+
+        self._poly = Poly((m - n)/b0, _x)
+
+    def __str__(self):
+        return '<Increment lower index #%s of %s, %s.>' % (self._i,
+                                                        self._ap, self._bq)
+
+
+class MeijerShiftA(Operator):
+    """ Increment an upper b index. """
+
+    def __init__(self, bi):
+        bi = sympify(bi)
+        self._poly = Poly(bi - _x, _x)
+
+    def __str__(self):
+        return '<Increment upper b=%s.>' % (self._poly.all_coeffs()[1])
+
+
+class MeijerShiftB(Operator):
+    """ Decrement an upper a index. """
+
+    def __init__(self, bi):
+        bi = sympify(bi)
+        self._poly = Poly(1 - bi + _x, _x)
+
+    def __str__(self):
+        return '<Decrement upper a=%s.>' % (1 - self._poly.all_coeffs()[1])
+
+
+class MeijerShiftC(Operator):
+    """ Increment a lower b index. """
+
+    def __init__(self, bi):
+        bi = sympify(bi)
+        self._poly = Poly(-bi + _x, _x)
+
+    def __str__(self):
+        return '<Increment lower b=%s.>' % (-self._poly.all_coeffs()[1])
+
+
+class MeijerShiftD(Operator):
+    """ Decrement a lower a index. """
+
+    def __init__(self, bi):
+        bi = sympify(bi)
+        self._poly = Poly(bi - 1 - _x, _x)
+
+    def __str__(self):
+        return '<Decrement lower a=%s.>' % (self._poly.all_coeffs()[1] + 1)
+
+
+class MeijerUnShiftA(Operator):
+    """ Decrement an upper b index. """
+
+    def __init__(self, an, ap, bm, bq, i, z):
+        """ Note: i counts from zero! """
+        an, ap, bm, bq, i = list(map(sympify, [an, ap, bm, bq, i]))
+
+        self._an = an
+        self._ap = ap
+        self._bm = bm
+        self._bq = bq
+        self._i = i
+
+        an = list(an)
+        ap = list(ap)
+        bm = list(bm)
+        bq = list(bq)
+        bi = bm.pop(i) - 1
+
+        m = Poly(1, _x) * prod(Poly(b - _x, _x) for b in bm) * prod(Poly(_x - b, _x) for b in bq)
+
+        A = Dummy('A')
+        D = Poly(bi - A, A)
+        n = Poly(z, A) * prod((D + 1 - a) for a in an) * prod((-D + a - 1) for a in ap)
+
+        b0 = n.nth(0)
+        if b0 == 0:
+            raise ValueError('Cannot decrement upper b index (cancels)')
+
+        n = Poly(Poly(n.all_coeffs()[:-1], A).as_expr().subs(A, bi - _x), _x)
+
+        self._poly = Poly((m - n)/b0, _x)
+
+    def __str__(self):
+        return '<Decrement upper b index #%s of %s, %s, %s, %s.>' % (self._i,
+                                      self._an, self._ap, self._bm, self._bq)
+
+
+class MeijerUnShiftB(Operator):
+    """ Increment an upper a index. """
+
+    def __init__(self, an, ap, bm, bq, i, z):
+        """ Note: i counts from zero! """
+        an, ap, bm, bq, i = list(map(sympify, [an, ap, bm, bq, i]))
+
+        self._an = an
+        self._ap = ap
+        self._bm = bm
+        self._bq = bq
+        self._i = i
+
+        an = list(an)
+        ap = list(ap)
+        bm = list(bm)
+        bq = list(bq)
+        ai = an.pop(i) + 1
+
+        m = Poly(z, _x)
+        for a in an:
+            m *= Poly(1 - a + _x, _x)
+        for a in ap:
+            m *= Poly(a - 1 - _x, _x)
+
+        B = Dummy('B')
+        D = Poly(B + ai - 1, B)
+        n = Poly(1, B)
+        for b in bm:
+            n *= (-D + b)
+        for b in bq:
+            n *= (D - b)
+
+        b0 = n.nth(0)
+        if b0 == 0:
+            raise ValueError('Cannot increment upper a index (cancels)')
+
+        n = Poly(Poly(n.all_coeffs()[:-1], B).as_expr().subs(
+            B, 1 - ai + _x), _x)
+
+        self._poly = Poly((m - n)/b0, _x)
+
+    def __str__(self):
+        return '<Increment upper a index #%s of %s, %s, %s, %s.>' % (self._i,
+                                      self._an, self._ap, self._bm, self._bq)
+
+
+class MeijerUnShiftC(Operator):
+    """ Decrement a lower b index. """
+    # XXX this is "essentially" the same as MeijerUnShiftA. This "essentially"
+    #     can be made rigorous using the functional equation G(1/z) = G'(z),
+    #     where G' denotes a G function of slightly altered parameters.
+    #     However, sorting out the details seems harder than just coding it
+    #     again.
+
+    def __init__(self, an, ap, bm, bq, i, z):
+        """ Note: i counts from zero! """
+        an, ap, bm, bq, i = list(map(sympify, [an, ap, bm, bq, i]))
+
+        self._an = an
+        self._ap = ap
+        self._bm = bm
+        self._bq = bq
+        self._i = i
+
+        an = list(an)
+        ap = list(ap)
+        bm = list(bm)
+        bq = list(bq)
+        bi = bq.pop(i) - 1
+
+        m = Poly(1, _x)
+        for b in bm:
+            m *= Poly(b - _x, _x)
+        for b in bq:
+            m *= Poly(_x - b, _x)
+
+        C = Dummy('C')
+        D = Poly(bi + C, C)
+        n = Poly(z, C)
+        for a in an:
+            n *= (D + 1 - a)
+        for a in ap:
+            n *= (-D + a - 1)
+
+        b0 = n.nth(0)
+        if b0 == 0:
+            raise ValueError('Cannot decrement lower b index (cancels)')
+
+        n = Poly(Poly(n.all_coeffs()[:-1], C).as_expr().subs(C, _x - bi), _x)
+
+        self._poly = Poly((m - n)/b0, _x)
+
+    def __str__(self):
+        return '<Decrement lower b index #%s of %s, %s, %s, %s.>' % (self._i,
+                                      self._an, self._ap, self._bm, self._bq)
+
+
+class MeijerUnShiftD(Operator):
+    """ Increment a lower a index. """
+    # XXX This is essentially the same as MeijerUnShiftA.
+    #     See comment at MeijerUnShiftC.
+
+    def __init__(self, an, ap, bm, bq, i, z):
+        """ Note: i counts from zero! """
+        an, ap, bm, bq, i = list(map(sympify, [an, ap, bm, bq, i]))
+
+        self._an = an
+        self._ap = ap
+        self._bm = bm
+        self._bq = bq
+        self._i = i
+
+        an = list(an)
+        ap = list(ap)
+        bm = list(bm)
+        bq = list(bq)
+        ai = ap.pop(i) + 1
+
+        m = Poly(z, _x)
+        for a in an:
+            m *= Poly(1 - a + _x, _x)
+        for a in ap:
+            m *= Poly(a - 1 - _x, _x)
+
+        B = Dummy('B')  # - this is the shift operator `D_I`
+        D = Poly(ai - 1 - B, B)
+        n = Poly(1, B)
+        for b in bm:
+            n *= (-D + b)
+        for b in bq:
+            n *= (D - b)
+
+        b0 = n.nth(0)
+        if b0 == 0:
+            raise ValueError('Cannot increment lower a index (cancels)')
+
+        n = Poly(Poly(n.all_coeffs()[:-1], B).as_expr().subs(
+            B, ai - 1 - _x), _x)
+
+        self._poly = Poly((m - n)/b0, _x)
+
+    def __str__(self):
+        return '<Increment lower a index #%s of %s, %s, %s, %s.>' % (self._i,
+                                      self._an, self._ap, self._bm, self._bq)
+
+
+class ReduceOrder(Operator):
+    """ Reduce Order by cancelling an upper and a lower index. """
+
+    def __new__(cls, ai, bj):
+        """ For convenience if reduction is not possible, return None. """
+        ai = sympify(ai)
+        bj = sympify(bj)
+        n = ai - bj
+        if not n.is_Integer or n < 0:
+            return None
+        if bj.is_integer and bj.is_nonpositive:
+            return None
+
+        expr = Operator.__new__(cls)
+
+        p = S.One
+        for k in range(n):
+            p *= (_x + bj + k)/(bj + k)
+
+        expr._poly = Poly(p, _x)
+        expr._a = ai
+        expr._b = bj
+
+        return expr
+
+    @classmethod
+    def _meijer(cls, b, a, sign):
+        """ Cancel b + sign*s and a + sign*s
+            This is for meijer G functions. """
+        b = sympify(b)
+        a = sympify(a)
+        n = b - a
+        if n.is_negative or not n.is_Integer:
+            return None
+
+        expr = Operator.__new__(cls)
+
+        p = S.One
+        for k in range(n):
+            p *= (sign*_x + a + k)
+
+        expr._poly = Poly(p, _x)
+        if sign == -1:
+            expr._a = b
+            expr._b = a
+        else:
+            expr._b = Add(1, a - 1, evaluate=False)
+            expr._a = Add(1, b - 1, evaluate=False)
+
+        return expr
+
+    @classmethod
+    def meijer_minus(cls, b, a):
+        return cls._meijer(b, a, -1)
+
+    @classmethod
+    def meijer_plus(cls, a, b):
+        return cls._meijer(1 - a, 1 - b, 1)
+
+    def __str__(self):
+        return '<Reduce order by cancelling upper %s with lower %s.>' % \
+            (self._a, self._b)
+
+
+def _reduce_order(ap, bq, gen, key):
+    """ Order reduction algorithm used in Hypergeometric and Meijer G """
+    ap = list(ap)
+    bq = list(bq)
+
+    ap.sort(key=key)
+    bq.sort(key=key)
+
+    nap = []
+    # we will edit bq in place
+    operators = []
+    for a in ap:
+        op = None
+        for i in range(len(bq)):
+            op = gen(a, bq[i])
+            if op is not None:
+                bq.pop(i)
+                break
+        if op is None:
+            nap.append(a)
+        else:
+            operators.append(op)
+
+    return nap, bq, operators
+
+
+def reduce_order(func):
+    """
+    Given the hypergeometric function ``func``, find a sequence of operators to
+    reduces order as much as possible.
+
+    Explanation
+    ===========
+
+    Return (newfunc, [operators]), where applying the operators to the
+    hypergeometric function newfunc yields func.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.hyperexpand import reduce_order, Hyper_Function
+    >>> reduce_order(Hyper_Function((1, 2), (3, 4)))
+    (Hyper_Function((1, 2), (3, 4)), [])
+    >>> reduce_order(Hyper_Function((1,), (1,)))
+    (Hyper_Function((), ()), [<Reduce order by cancelling upper 1 with lower 1.>])
+    >>> reduce_order(Hyper_Function((2, 4), (3, 3)))
+    (Hyper_Function((2,), (3,)), [<Reduce order by cancelling
+    upper 4 with lower 3.>])
+    """
+    nap, nbq, operators = _reduce_order(func.ap, func.bq, ReduceOrder, default_sort_key)
+
+    return Hyper_Function(Tuple(*nap), Tuple(*nbq)), operators
+
+
+def reduce_order_meijer(func):
+    """
+    Given the Meijer G function parameters, ``func``, find a sequence of
+    operators that reduces order as much as possible.
+
+    Return newfunc, [operators].
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.hyperexpand import (reduce_order_meijer,
+    ...                                         G_Function)
+    >>> reduce_order_meijer(G_Function([3, 4], [5, 6], [3, 4], [1, 2]))[0]
+    G_Function((4, 3), (5, 6), (3, 4), (2, 1))
+    >>> reduce_order_meijer(G_Function([3, 4], [5, 6], [3, 4], [1, 8]))[0]
+    G_Function((3,), (5, 6), (3, 4), (1,))
+    >>> reduce_order_meijer(G_Function([3, 4], [5, 6], [7, 5], [1, 5]))[0]
+    G_Function((3,), (), (), (1,))
+    >>> reduce_order_meijer(G_Function([3, 4], [5, 6], [7, 5], [5, 3]))[0]
+    G_Function((), (), (), ())
+    """
+
+    nan, nbq, ops1 = _reduce_order(func.an, func.bq, ReduceOrder.meijer_plus,
+                                   lambda x: default_sort_key(-x))
+    nbm, nap, ops2 = _reduce_order(func.bm, func.ap, ReduceOrder.meijer_minus,
+                                   default_sort_key)
+
+    return G_Function(nan, nap, nbm, nbq), ops1 + ops2
+
+
+def make_derivative_operator(M, z):
+    """ Create a derivative operator, to be passed to Operator.apply. """
+    def doit(C):
+        r = z*C.diff(z) + C*M
+        r = r.applyfunc(make_simp(z))
+        return r
+    return doit
+
+
+def apply_operators(obj, ops, op):
+    """
+    Apply the list of operators ``ops`` to object ``obj``, substituting
+    ``op`` for the generator.
+    """
+    res = obj
+    for o in reversed(ops):
+        res = o.apply(res, op)
+    return res
+
+
+def devise_plan(target, origin, z):
+    """
+    Devise a plan (consisting of shift and un-shift operators) to be applied
+    to the hypergeometric function ``target`` to yield ``origin``.
+    Returns a list of operators.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.hyperexpand import devise_plan, Hyper_Function
+    >>> from sympy.abc import z
+
+    Nothing to do:
+
+    >>> devise_plan(Hyper_Function((1, 2), ()), Hyper_Function((1, 2), ()), z)
+    []
+    >>> devise_plan(Hyper_Function((), (1, 2)), Hyper_Function((), (1, 2)), z)
+    []
+
+    Very simple plans:
+
+    >>> devise_plan(Hyper_Function((2,), ()), Hyper_Function((1,), ()), z)
+    [<Increment upper 1.>]
+    >>> devise_plan(Hyper_Function((), (2,)), Hyper_Function((), (1,)), z)
+    [<Increment lower index #0 of [], [1].>]
+
+    Several buckets:
+
+    >>> from sympy import S
+    >>> devise_plan(Hyper_Function((1, S.Half), ()),
+    ...             Hyper_Function((2, S('3/2')), ()), z) #doctest: +NORMALIZE_WHITESPACE
+    [<Decrement upper index #0 of [3/2, 1], [].>,
+    <Decrement upper index #0 of [2, 3/2], [].>]
+
+    A slightly more complicated plan:
+
+    >>> devise_plan(Hyper_Function((1, 3), ()), Hyper_Function((2, 2), ()), z)
+    [<Increment upper 2.>, <Decrement upper index #0 of [2, 2], [].>]
+
+    Another more complicated plan: (note that the ap have to be shifted first!)
+
+    >>> devise_plan(Hyper_Function((1, -1), (2,)), Hyper_Function((3, -2), (4,)), z)
+    [<Decrement lower 3.>, <Decrement lower 4.>,
+    <Decrement upper index #1 of [-1, 2], [4].>,
+    <Decrement upper index #1 of [-1, 3], [4].>, <Increment upper -2.>]
+    """
+    abuckets, bbuckets, nabuckets, nbbuckets = [sift(params, _mod1) for
+            params in (target.ap, target.bq, origin.ap, origin.bq)]
+
+    if len(list(abuckets.keys())) != len(list(nabuckets.keys())) or \
+            len(list(bbuckets.keys())) != len(list(nbbuckets.keys())):
+        raise ValueError('%s not reachable from %s' % (target, origin))
+
+    ops = []
+
+    def do_shifts(fro, to, inc, dec):
+        ops = []
+        for i in range(len(fro)):
+            if to[i] - fro[i] > 0:
+                sh = inc
+                ch = 1
+            else:
+                sh = dec
+                ch = -1
+
+            while to[i] != fro[i]:
+                ops += [sh(fro, i)]
+                fro[i] += ch
+
+        return ops
+
+    def do_shifts_a(nal, nbk, al, aother, bother):
+        """ Shift us from (nal, nbk) to (al, nbk). """
+        return do_shifts(nal, al, lambda p, i: ShiftA(p[i]),
+                         lambda p, i: UnShiftA(p + aother, nbk + bother, i, z))
+
+    def do_shifts_b(nal, nbk, bk, aother, bother):
+        """ Shift us from (nal, nbk) to (nal, bk). """
+        return do_shifts(nbk, bk,
+                         lambda p, i: UnShiftB(nal + aother, p + bother, i, z),
+                         lambda p, i: ShiftB(p[i]))
+
+    for r in sorted(list(abuckets.keys()) + list(bbuckets.keys()), key=default_sort_key):
+        al = ()
+        nal = ()
+        bk = ()
+        nbk = ()
+        if r in abuckets:
+            al = abuckets[r]
+            nal = nabuckets[r]
+        if r in bbuckets:
+            bk = bbuckets[r]
+            nbk = nbbuckets[r]
+        if len(al) != len(nal) or len(bk) != len(nbk):
+            raise ValueError('%s not reachable from %s' % (target, origin))
+
+        al, nal, bk, nbk = [sorted(w, key=default_sort_key)
+            for w in [al, nal, bk, nbk]]
+
+        def others(dic, key):
+            l = []
+            for k, value in dic.items():
+                if k != key:
+                    l += list(dic[k])
+            return l
+        aother = others(nabuckets, r)
+        bother = others(nbbuckets, r)
+
+        if len(al) == 0:
+            # there can be no complications, just shift the bs as we please
+            ops += do_shifts_b([], nbk, bk, aother, bother)
+        elif len(bk) == 0:
+            # there can be no complications, just shift the as as we please
+            ops += do_shifts_a(nal, [], al, aother, bother)
+        else:
+            namax = nal[-1]
+            amax = al[-1]
+
+            if nbk[0] - namax <= 0 or bk[0] - amax <= 0:
+                raise ValueError('Non-suitable parameters.')
+
+            if namax - amax > 0:
+                # we are going to shift down - first do the as, then the bs
+                ops += do_shifts_a(nal, nbk, al, aother, bother)
+                ops += do_shifts_b(al, nbk, bk, aother, bother)
+            else:
+                # we are going to shift up - first do the bs, then the as
+                ops += do_shifts_b(nal, nbk, bk, aother, bother)
+                ops += do_shifts_a(nal, bk, al, aother, bother)
+
+        nabuckets[r] = al
+        nbbuckets[r] = bk
+
+    ops.reverse()
+    return ops
+
+
+def try_shifted_sum(func, z):
+    """ Try to recognise a hypergeometric sum that starts from k > 0. """
+    abuckets, bbuckets = sift(func.ap, _mod1), sift(func.bq, _mod1)
+    if len(abuckets[S.Zero]) != 1:
+        return None
+    r = abuckets[S.Zero][0]
+    if r <= 0:
+        return None
+    if S.Zero not in bbuckets:
+        return None
+    l = list(bbuckets[S.Zero])
+    l.sort()
+    k = l[0]
+    if k <= 0:
+        return None
+
+    nap = list(func.ap)
+    nap.remove(r)
+    nbq = list(func.bq)
+    nbq.remove(k)
+    k -= 1
+    nap = [x - k for x in nap]
+    nbq = [x - k for x in nbq]
+
+    ops = []
+    for n in range(r - 1):
+        ops.append(ShiftA(n + 1))
+    ops.reverse()
+
+    fac = factorial(k)/z**k
+    fac *= Mul(*[rf(b, k) for b in nbq])
+    fac /= Mul(*[rf(a, k) for a in nap])
+
+    ops += [MultOperator(fac)]
+
+    p = 0
+    for n in range(k):
+        m = z**n/factorial(n)
+        m *= Mul(*[rf(a, n) for a in nap])
+        m /= Mul(*[rf(b, n) for b in nbq])
+        p += m
+
+    return Hyper_Function(nap, nbq), ops, -p
+
+
+def try_polynomial(func, z):
+    """ Recognise polynomial cases. Returns None if not such a case.
+        Requires order to be fully reduced. """
+    abuckets, bbuckets = sift(func.ap, _mod1), sift(func.bq, _mod1)
+    a0 = abuckets[S.Zero]
+    b0 = bbuckets[S.Zero]
+    a0.sort()
+    b0.sort()
+    al0 = [x for x in a0 if x <= 0]
+    bl0 = [x for x in b0 if x <= 0]
+
+    if bl0 and all(a < bl0[-1] for a in al0):
+        return oo
+    if not al0:
+        return None
+
+    a = al0[-1]
+    fac = 1
+    res = S.One
+    for n in Tuple(*list(range(-a))):
+        fac *= z
+        fac /= n + 1
+        fac *= Mul(*[a + n for a in func.ap])
+        fac /= Mul(*[b + n for b in func.bq])
+        res += fac
+    return res
+
+
+def try_lerchphi(func):
+    """
+    Try to find an expression for Hyper_Function ``func`` in terms of Lerch
+    Transcendents.
+
+    Return None if no such expression can be found.
+    """
+    # This is actually quite simple, and is described in Roach's paper,
+    # section 18.
+    # We don't need to implement the reduction to polylog here, this
+    # is handled by expand_func.
+
+    # First we need to figure out if the summation coefficient is a rational
+    # function of the summation index, and construct that rational function.
+    abuckets, bbuckets = sift(func.ap, _mod1), sift(func.bq, _mod1)
+
+    paired = {}
+    for key, value in abuckets.items():
+        if key != 0 and key not in bbuckets:
+            return None
+        bvalue = bbuckets[key]
+        paired[key] = (list(value), list(bvalue))
+        bbuckets.pop(key, None)
+    if bbuckets != {}:
+        return None
+    if S.Zero not in abuckets:
+        return None
+    aints, bints = paired[S.Zero]
+    # Account for the additional n! in denominator
+    paired[S.Zero] = (aints, bints + [1])
+
+    t = Dummy('t')
+    numer = S.One
+    denom = S.One
+    for key, (avalue, bvalue) in paired.items():
+        if len(avalue) != len(bvalue):
+            return None
+        # Note that since order has been reduced fully, all the b are
+        # bigger than all the a they differ from by an integer. In particular
+        # if there are any negative b left, this function is not well-defined.
+        for a, b in zip(avalue, bvalue):
+            if (a - b).is_positive:
+                k = a - b
+                numer *= rf(b + t, k)
+                denom *= rf(b, k)
+            else:
+                k = b - a
+                numer *= rf(a, k)
+                denom *= rf(a + t, k)
+
+    # Now do a partial fraction decomposition.
+    # We assemble two structures: a list monomials of pairs (a, b) representing
+    # a*t**b (b a non-negative integer), and a dict terms, where
+    # terms[a] = [(b, c)] means that there is a term b/(t-a)**c.
+    part = apart(numer/denom, t)
+    args = Add.make_args(part)
+    monomials = []
+    terms = {}
+    for arg in args:
+        numer, denom = arg.as_numer_denom()
+        if not denom.has(t):
+            p = Poly(numer, t)
+            if not p.is_monomial:
+                raise TypeError("p should be monomial")
+            ((b, ), a) = p.LT()
+            monomials += [(a/denom, b)]
+            continue
+        if numer.has(t):
+            raise NotImplementedError('Need partial fraction decomposition'
+                                      ' with linear denominators')
+        indep, [dep] = denom.as_coeff_mul(t)
+        n = 1
+        if dep.is_Pow:
+            n = dep.exp
+            dep = dep.base
+        if dep == t:
+            a == 0
+        elif dep.is_Add:
+            a, tmp = dep.as_independent(t)
+            b = 1
+            if tmp != t:
+                b, _ = tmp.as_independent(t)
+            if dep != b*t + a:
+                raise NotImplementedError('unrecognised form %s' % dep)
+            a /= b
+            indep *= b**n
+        else:
+            raise NotImplementedError('unrecognised form of partial fraction')
+        terms.setdefault(a, []).append((numer/indep, n))
+
+    # Now that we have this information, assemble our formula. All the
+    # monomials yield rational functions and go into one basis element.
+    # The terms[a] are related by differentiation. If the largest exponent is
+    # n, we need lerchphi(z, k, a) for k = 1, 2, ..., n.
+    # deriv maps a basis to its derivative, expressed as a C(z)-linear
+    # combination of other basis elements.
+    deriv = {}
+    coeffs = {}
+    z = Dummy('z')
+    monomials.sort(key=lambda x: x[1])
+    mon = {0: 1/(1 - z)}
+    if monomials:
+        for k in range(monomials[-1][1]):
+            mon[k + 1] = z*mon[k].diff(z)
+    for a, n in monomials:
+        coeffs.setdefault(S.One, []).append(a*mon[n])
+    for a, l in terms.items():
+        for c, k in l:
+            coeffs.setdefault(lerchphi(z, k, a), []).append(c)
+        l.sort(key=lambda x: x[1])
+        for k in range(2, l[-1][1] + 1):
+            deriv[lerchphi(z, k, a)] = [(-a, lerchphi(z, k, a)),
+                                        (1, lerchphi(z, k - 1, a))]
+        deriv[lerchphi(z, 1, a)] = [(-a, lerchphi(z, 1, a)),
+                                    (1/(1 - z), S.One)]
+    trans = {}
+    for n, b in enumerate([S.One] + list(deriv.keys())):
+        trans[b] = n
+    basis = [expand_func(b) for (b, _) in sorted(trans.items(),
+                                                 key=lambda x:x[1])]
+    B = Matrix(basis)
+    C = Matrix([[0]*len(B)])
+    for b, c in coeffs.items():
+        C[trans[b]] = Add(*c)
+    M = zeros(len(B))
+    for b, l in deriv.items():
+        for c, b2 in l:
+            M[trans[b], trans[b2]] = c
+    return Formula(func, z, None, [], B, C, M)
+
+
+def build_hypergeometric_formula(func):
+    """
+    Create a formula object representing the hypergeometric function ``func``.
+
+    """
+    # We know that no `ap` are negative integers, otherwise "detect poly"
+    # would have kicked in. However, `ap` could be empty. In this case we can
+    # use a different basis.
+    # I'm not aware of a basis that works in all cases.
+    z = Dummy('z')
+    if func.ap:
+        afactors = [_x + a for a in func.ap]
+        bfactors = [_x + b - 1 for b in func.bq]
+        expr = _x*Mul(*bfactors) - z*Mul(*afactors)
+        poly = Poly(expr, _x)
+        n = poly.degree()
+        basis = []
+        M = zeros(n)
+        for k in range(n):
+            a = func.ap[0] + k
+            basis += [hyper([a] + list(func.ap[1:]), func.bq, z)]
+            if k < n - 1:
+                M[k, k] = -a
+                M[k, k + 1] = a
+        B = Matrix(basis)
+        C = Matrix([[1] + [0]*(n - 1)])
+        derivs = [eye(n)]
+        for k in range(n):
+            derivs.append(M*derivs[k])
+        l = poly.all_coeffs()
+        l.reverse()
+        res = [0]*n
+        for k, c in enumerate(l):
+            for r, d in enumerate(C*derivs[k]):
+                res[r] += c*d
+        for k, c in enumerate(res):
+            M[n - 1, k] = -c/derivs[n - 1][0, n - 1]/poly.all_coeffs()[0]
+        return Formula(func, z, None, [], B, C, M)
+    else:
+        # Since there are no `ap`, none of the `bq` can be non-positive
+        # integers.
+        basis = []
+        bq = list(func.bq[:])
+        for i in range(len(bq)):
+            basis += [hyper([], bq, z)]
+            bq[i] += 1
+        basis += [hyper([], bq, z)]
+        B = Matrix(basis)
+        n = len(B)
+        C = Matrix([[1] + [0]*(n - 1)])
+        M = zeros(n)
+        M[0, n - 1] = z/Mul(*func.bq)
+        for k in range(1, n):
+            M[k, k - 1] = func.bq[k - 1]
+            M[k, k] = -func.bq[k - 1]
+        return Formula(func, z, None, [], B, C, M)
+
+
+def hyperexpand_special(ap, bq, z):
+    """
+    Try to find a closed-form expression for hyper(ap, bq, z), where ``z``
+    is supposed to be a "special" value, e.g. 1.
+
+    This function tries various of the classical summation formulae
+    (Gauss, Saalschuetz, etc).
+    """
+    # This code is very ad-hoc. There are many clever algorithms
+    # (notably Zeilberger's) related to this problem.
+    # For now we just want a few simple cases to work.
+    p, q = len(ap), len(bq)
+    z_ = z
+    z = unpolarify(z)
+    if z == 0:
+        return S.One
+    from sympy.simplify.simplify import simplify
+    if p == 2 and q == 1:
+        # 2F1
+        a, b, c = ap + bq
+        if z == 1:
+            # Gauss
+            return gamma(c - a - b)*gamma(c)/gamma(c - a)/gamma(c - b)
+        if z == -1 and simplify(b - a + c) == 1:
+            b, a = a, b
+        if z == -1 and simplify(a - b + c) == 1:
+            # Kummer
+            if b.is_integer and b.is_negative:
+                return 2*cos(pi*b/2)*gamma(-b)*gamma(b - a + 1) \
+                    /gamma(-b/2)/gamma(b/2 - a + 1)
+            else:
+                return gamma(b/2 + 1)*gamma(b - a + 1) \
+                    /gamma(b + 1)/gamma(b/2 - a + 1)
+    # TODO tons of more formulae
+    #      investigate what algorithms exist
+    return hyper(ap, bq, z_)
+
+_collection = None
+
+
+def _hyperexpand(func, z, ops0=[], z0=Dummy('z0'), premult=1, prem=0,
+                 rewrite='default'):
+    """
+    Try to find an expression for the hypergeometric function ``func``.
+
+    Explanation
+    ===========
+
+    The result is expressed in terms of a dummy variable ``z0``. Then it
+    is multiplied by ``premult``. Then ``ops0`` is applied.
+    ``premult`` must be a*z**prem for some a independent of ``z``.
+    """
+
+    if z.is_zero:
+        return S.One
+
+    from sympy.simplify.simplify import simplify
+
+    z = polarify(z, subs=False)
+    if rewrite == 'default':
+        rewrite = 'nonrepsmall'
+
+    def carryout_plan(f, ops):
+        C = apply_operators(f.C.subs(f.z, z0), ops,
+                            make_derivative_operator(f.M.subs(f.z, z0), z0))
+        C = apply_operators(C, ops0,
+                            make_derivative_operator(f.M.subs(f.z, z0)
+                                         + prem*eye(f.M.shape[0]), z0))
+
+        if premult == 1:
+            C = C.applyfunc(make_simp(z0))
+        r = reduce(lambda s,m: s+m[0]*m[1], zip(C, f.B.subs(f.z, z0)), S.Zero)*premult
+        res = r.subs(z0, z)
+        if rewrite:
+            res = res.rewrite(rewrite)
+        return res
+
+    # TODO
+    # The following would be possible:
+    # *) PFD Duplication (see Kelly Roach's paper)
+    # *) In a similar spirit, try_lerchphi() can be generalised considerably.
+
+    global _collection
+    if _collection is None:
+        _collection = FormulaCollection()
+
+    debug('Trying to expand hypergeometric function ', func)
+
+    # First reduce order as much as possible.
+    func, ops = reduce_order(func)
+    if ops:
+        debug('  Reduced order to ', func)
+    else:
+        debug('  Could not reduce order.')
+
+    # Now try polynomial cases
+    res = try_polynomial(func, z0)
+    if res is not None:
+        debug('  Recognised polynomial.')
+        p = apply_operators(res, ops, lambda f: z0*f.diff(z0))
+        p = apply_operators(p*premult, ops0, lambda f: z0*f.diff(z0))
+        return unpolarify(simplify(p).subs(z0, z))
+
+    # Try to recognise a shifted sum.
+    p = S.Zero
+    res = try_shifted_sum(func, z0)
+    if res is not None:
+        func, nops, p = res
+        debug('  Recognised shifted sum, reduced order to ', func)
+        ops += nops
+
+    # apply the plan for poly
+    p = apply_operators(p, ops, lambda f: z0*f.diff(z0))
+    p = apply_operators(p*premult, ops0, lambda f: z0*f.diff(z0))
+    p = simplify(p).subs(z0, z)
+
+    # Try special expansions early.
+    if unpolarify(z) in [1, -1] and (len(func.ap), len(func.bq)) == (2, 1):
+        f = build_hypergeometric_formula(func)
+        r = carryout_plan(f, ops).replace(hyper, hyperexpand_special)
+        if not r.has(hyper):
+            return r + p
+
+    # Try to find a formula in our collection
+    formula = _collection.lookup_origin(func)
+
+    # Now try a lerch phi formula
+    if formula is None:
+        formula = try_lerchphi(func)
+
+    if formula is None:
+        debug('  Could not find an origin. ',
+              'Will return answer in terms of '
+              'simpler hypergeometric functions.')
+        formula = build_hypergeometric_formula(func)
+
+    debug('  Found an origin: ', formula.closed_form, ' ', formula.func)
+
+    # We need to find the operators that convert formula into func.
+    ops += devise_plan(func, formula.func, z0)
+
+    # Now carry out the plan.
+    r = carryout_plan(formula, ops) + p
+
+    return powdenest(r, polar=True).replace(hyper, hyperexpand_special)
+
+
+def devise_plan_meijer(fro, to, z):
+    """
+    Find operators to convert G-function ``fro`` into G-function ``to``.
+
+    Explanation
+    ===========
+
+    It is assumed that ``fro`` and ``to`` have the same signatures, and that in fact
+    any corresponding pair of parameters differs by integers, and a direct path
+    is possible. I.e. if there are parameters a1 b1 c1  and a2 b2 c2 it is
+    assumed that a1 can be shifted to a2, etc. The only thing this routine
+    determines is the order of shifts to apply, nothing clever will be tried.
+    It is also assumed that ``fro`` is suitable.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.hyperexpand import (devise_plan_meijer,
+    ...                                         G_Function)
+    >>> from sympy.abc import z
+
+    Empty plan:
+
+    >>> devise_plan_meijer(G_Function([1], [2], [3], [4]),
+    ...                    G_Function([1], [2], [3], [4]), z)
+    []
+
+    Very simple plans:
+
+    >>> devise_plan_meijer(G_Function([0], [], [], []),
+    ...                    G_Function([1], [], [], []), z)
+    [<Increment upper a index #0 of [0], [], [], [].>]
+    >>> devise_plan_meijer(G_Function([0], [], [], []),
+    ...                    G_Function([-1], [], [], []), z)
+    [<Decrement upper a=0.>]
+    >>> devise_plan_meijer(G_Function([], [1], [], []),
+    ...                    G_Function([], [2], [], []), z)
+    [<Increment lower a index #0 of [], [1], [], [].>]
+
+    Slightly more complicated plans:
+
+    >>> devise_plan_meijer(G_Function([0], [], [], []),
+    ...                    G_Function([2], [], [], []), z)
+    [<Increment upper a index #0 of [1], [], [], [].>,
+    <Increment upper a index #0 of [0], [], [], [].>]
+    >>> devise_plan_meijer(G_Function([0], [], [0], []),
+    ...                    G_Function([-1], [], [1], []), z)
+    [<Increment upper b=0.>, <Decrement upper a=0.>]
+
+    Order matters:
+
+    >>> devise_plan_meijer(G_Function([0], [], [0], []),
+    ...                    G_Function([1], [], [1], []), z)
+    [<Increment upper a index #0 of [0], [], [1], [].>, <Increment upper b=0.>]
+    """
+    # TODO for now, we use the following simple heuristic: inverse-shift
+    #      when possible, shift otherwise. Give up if we cannot make progress.
+
+    def try_shift(f, t, shifter, diff, counter):
+        """ Try to apply ``shifter`` in order to bring some element in ``f``
+            nearer to its counterpart in ``to``. ``diff`` is +/- 1 and
+            determines the effect of ``shifter``. Counter is a list of elements
+            blocking the shift.
+
+            Return an operator if change was possible, else None.
+        """
+        for idx, (a, b) in enumerate(zip(f, t)):
+            if (
+                (a - b).is_integer and (b - a)/diff > 0 and
+                    all(a != x for x in counter)):
+                sh = shifter(idx)
+                f[idx] += diff
+                return sh
+    fan = list(fro.an)
+    fap = list(fro.ap)
+    fbm = list(fro.bm)
+    fbq = list(fro.bq)
+    ops = []
+    change = True
+    while change:
+        change = False
+        op = try_shift(fan, to.an,
+                       lambda i: MeijerUnShiftB(fan, fap, fbm, fbq, i, z),
+                       1, fbm + fbq)
+        if op is not None:
+            ops += [op]
+            change = True
+            continue
+        op = try_shift(fap, to.ap,
+                       lambda i: MeijerUnShiftD(fan, fap, fbm, fbq, i, z),
+                       1, fbm + fbq)
+        if op is not None:
+            ops += [op]
+            change = True
+            continue
+        op = try_shift(fbm, to.bm,
+                       lambda i: MeijerUnShiftA(fan, fap, fbm, fbq, i, z),
+                       -1, fan + fap)
+        if op is not None:
+            ops += [op]
+            change = True
+            continue
+        op = try_shift(fbq, to.bq,
+                       lambda i: MeijerUnShiftC(fan, fap, fbm, fbq, i, z),
+                       -1, fan + fap)
+        if op is not None:
+            ops += [op]
+            change = True
+            continue
+        op = try_shift(fan, to.an, lambda i: MeijerShiftB(fan[i]), -1, [])
+        if op is not None:
+            ops += [op]
+            change = True
+            continue
+        op = try_shift(fap, to.ap, lambda i: MeijerShiftD(fap[i]), -1, [])
+        if op is not None:
+            ops += [op]
+            change = True
+            continue
+        op = try_shift(fbm, to.bm, lambda i: MeijerShiftA(fbm[i]), 1, [])
+        if op is not None:
+            ops += [op]
+            change = True
+            continue
+        op = try_shift(fbq, to.bq, lambda i: MeijerShiftC(fbq[i]), 1, [])
+        if op is not None:
+            ops += [op]
+            change = True
+            continue
+    if fan != list(to.an) or fap != list(to.ap) or fbm != list(to.bm) or \
+            fbq != list(to.bq):
+        raise NotImplementedError('Could not devise plan.')
+    ops.reverse()
+    return ops
+
+_meijercollection = None
+
+
+def _meijergexpand(func, z0, allow_hyper=False, rewrite='default',
+                   place=None):
+    """
+    Try to find an expression for the Meijer G function specified
+    by the G_Function ``func``. If ``allow_hyper`` is True, then returning
+    an expression in terms of hypergeometric functions is allowed.
+
+    Currently this just does Slater's theorem.
+    If expansions exist both at zero and at infinity, ``place``
+    can be set to ``0`` or ``zoo`` for the preferred choice.
+    """
+    global _meijercollection
+    if _meijercollection is None:
+        _meijercollection = MeijerFormulaCollection()
+    if rewrite == 'default':
+        rewrite = None
+
+    func0 = func
+    debug('Try to expand Meijer G function corresponding to ', func)
+
+    # We will play games with analytic continuation - rather use a fresh symbol
+    z = Dummy('z')
+
+    func, ops = reduce_order_meijer(func)
+    if ops:
+        debug('  Reduced order to ', func)
+    else:
+        debug('  Could not reduce order.')
+
+    # Try to find a direct formula
+    f = _meijercollection.lookup_origin(func)
+    if f is not None:
+        debug('  Found a Meijer G formula: ', f.func)
+        ops += devise_plan_meijer(f.func, func, z)
+
+        # Now carry out the plan.
+        C = apply_operators(f.C.subs(f.z, z), ops,
+                            make_derivative_operator(f.M.subs(f.z, z), z))
+
+        C = C.applyfunc(make_simp(z))
+        r = C*f.B.subs(f.z, z)
+        r = r[0].subs(z, z0)
+        return powdenest(r, polar=True)
+
+    debug("  Could not find a direct formula. Trying Slater's theorem.")
+
+    # TODO the following would be possible:
+    # *) Paired Index Theorems
+    # *) PFD Duplication
+    #    (See Kelly Roach's paper for details on either.)
+    #
+    # TODO Also, we tend to create combinations of gamma functions that can be
+    #      simplified.
+
+    def can_do(pbm, pap):
+        """ Test if slater applies. """
+        for i in pbm:
+            if len(pbm[i]) > 1:
+                l = 0
+                if i in pap:
+                    l = len(pap[i])
+                if l + 1 < len(pbm[i]):
+                    return False
+        return True
+
+    def do_slater(an, bm, ap, bq, z, zfinal):
+        # zfinal is the value that will eventually be substituted for z.
+        # We pass it to _hyperexpand to improve performance.
+        func = G_Function(an, bm, ap, bq)
+        _, pbm, pap, _ = func.compute_buckets()
+        if not can_do(pbm, pap):
+            return S.Zero, False
+
+        cond = len(an) + len(ap) < len(bm) + len(bq)
+        if len(an) + len(ap) == len(bm) + len(bq):
+            cond = abs(z) < 1
+        if cond is False:
+            return S.Zero, False
+
+        res = S.Zero
+        for m in pbm:
+            if len(pbm[m]) == 1:
+                bh = pbm[m][0]
+                fac = 1
+                bo = list(bm)
+                bo.remove(bh)
+                for bj in bo:
+                    fac *= gamma(bj - bh)
+                for aj in an:
+                    fac *= gamma(1 + bh - aj)
+                for bj in bq:
+                    fac /= gamma(1 + bh - bj)
+                for aj in ap:
+                    fac /= gamma(aj - bh)
+                nap = [1 + bh - a for a in list(an) + list(ap)]
+                nbq = [1 + bh - b for b in list(bo) + list(bq)]
+
+                k = polar_lift(S.NegativeOne**(len(ap) - len(bm)))
+                harg = k*zfinal
+                # NOTE even though k "is" +-1, this has to be t/k instead of
+                #      t*k ... we are using polar numbers for consistency!
+                premult = (t/k)**bh
+                hyp = _hyperexpand(Hyper_Function(nap, nbq), harg, ops,
+                                   t, premult, bh, rewrite=None)
+                res += fac * hyp
+            else:
+                b_ = pbm[m][0]
+                ki = [bi - b_ for bi in pbm[m][1:]]
+                u = len(ki)
+                li = [ai - b_ for ai in pap[m][:u + 1]]
+                bo = list(bm)
+                for b in pbm[m]:
+                    bo.remove(b)
+                ao = list(ap)
+                for a in pap[m][:u]:
+                    ao.remove(a)
+                lu = li[-1]
+                di = [l - k for (l, k) in zip(li, ki)]
+
+                # We first work out the integrand:
+                s = Dummy('s')
+                integrand = z**s
+                for b in bm:
+                    if not Mod(b, 1) and b.is_Number:
+                        b = int(round(b))
+                    integrand *= gamma(b - s)
+                for a in an:
+                    integrand *= gamma(1 - a + s)
+                for b in bq:
+                    integrand /= gamma(1 - b + s)
+                for a in ap:
+                    integrand /= gamma(a - s)
+
+                # Now sum the finitely many residues:
+                # XXX This speeds up some cases - is it a good idea?
+                integrand = expand_func(integrand)
+                for r in range(int(round(lu))):
+                    resid = residue(integrand, s, b_ + r)
+                    resid = apply_operators(resid, ops, lambda f: z*f.diff(z))
+                    res -= resid
+
+                # Now the hypergeometric term.
+                au = b_ + lu
+                k = polar_lift(S.NegativeOne**(len(ao) + len(bo) + 1))
+                harg = k*zfinal
+                premult = (t/k)**au
+                nap = [1 + au - a for a in list(an) + list(ap)] + [1]
+                nbq = [1 + au - b for b in list(bm) + list(bq)]
+
+                hyp = _hyperexpand(Hyper_Function(nap, nbq), harg, ops,
+                                   t, premult, au, rewrite=None)
+
+                C = S.NegativeOne**(lu)/factorial(lu)
+                for i in range(u):
+                    C *= S.NegativeOne**di[i]/rf(lu - li[i] + 1, di[i])
+                for a in an:
+                    C *= gamma(1 - a + au)
+                for b in bo:
+                    C *= gamma(b - au)
+                for a in ao:
+                    C /= gamma(a - au)
+                for b in bq:
+                    C /= gamma(1 - b + au)
+
+                res += C*hyp
+
+        return res, cond
+
+    t = Dummy('t')
+    slater1, cond1 = do_slater(func.an, func.bm, func.ap, func.bq, z, z0)
+
+    def tr(l):
+        return [1 - x for x in l]
+
+    for op in ops:
+        op._poly = Poly(op._poly.subs({z: 1/t, _x: -_x}), _x)
+    slater2, cond2 = do_slater(tr(func.bm), tr(func.an), tr(func.bq), tr(func.ap),
+                               t, 1/z0)
+
+    slater1 = powdenest(slater1.subs(z, z0), polar=True)
+    slater2 = powdenest(slater2.subs(t, 1/z0), polar=True)
+    if not isinstance(cond2, bool):
+        cond2 = cond2.subs(t, 1/z)
+
+    m = func(z)
+    if m.delta > 0 or \
+        (m.delta == 0 and len(m.ap) == len(m.bq) and
+            (re(m.nu) < -1) is not False and polar_lift(z0) == polar_lift(1)):
+        # The condition delta > 0 means that the convergence region is
+        # connected. Any expression we find can be continued analytically
+        # to the entire convergence region.
+        # The conditions delta==0, p==q, re(nu) < -1 imply that G is continuous
+        # on the positive reals, so the values at z=1 agree.
+        if cond1 is not False:
+            cond1 = True
+        if cond2 is not False:
+            cond2 = True
+
+    if cond1 is True:
+        slater1 = slater1.rewrite(rewrite or 'nonrep')
+    else:
+        slater1 = slater1.rewrite(rewrite or 'nonrepsmall')
+    if cond2 is True:
+        slater2 = slater2.rewrite(rewrite or 'nonrep')
+    else:
+        slater2 = slater2.rewrite(rewrite or 'nonrepsmall')
+
+    if cond1 is not False and cond2 is not False:
+        # If one condition is False, there is no choice.
+        if place == 0:
+            cond2 = False
+        if place == zoo:
+            cond1 = False
+
+    if not isinstance(cond1, bool):
+        cond1 = cond1.subs(z, z0)
+    if not isinstance(cond2, bool):
+        cond2 = cond2.subs(z, z0)
+
+    def weight(expr, cond):
+        if cond is True:
+            c0 = 0
+        elif cond is False:
+            c0 = 1
+        else:
+            c0 = 2
+        if expr.has(oo, zoo, -oo, nan):
+            # XXX this actually should not happen, but consider
+            # S('meijerg(((0, -1/2, 0, -1/2, 1/2), ()), ((0,),
+            #   (-1/2, -1/2, -1/2, -1)), exp_polar(I*pi))/4')
+            c0 = 3
+        return (c0, expr.count(hyper), expr.count_ops())
+
+    w1 = weight(slater1, cond1)
+    w2 = weight(slater2, cond2)
+    if min(w1, w2) <= (0, 1, oo):
+        if w1 < w2:
+            return slater1
+        else:
+            return slater2
+    if max(w1[0], w2[0]) <= 1 and max(w1[1], w2[1]) <= 1:
+        return Piecewise((slater1, cond1), (slater2, cond2), (func0(z0), True))
+
+    # We couldn't find an expression without hypergeometric functions.
+    # TODO it would be helpful to give conditions under which the integral
+    #      is known to diverge.
+    r = Piecewise((slater1, cond1), (slater2, cond2), (func0(z0), True))
+    if r.has(hyper) and not allow_hyper:
+        debug('  Could express using hypergeometric functions, '
+              'but not allowed.')
+    if not r.has(hyper) or allow_hyper:
+        return r
+
+    return func0(z0)
+
+
+def hyperexpand(f, allow_hyper=False, rewrite='default', place=None):
+    """
+    Expand hypergeometric functions. If allow_hyper is True, allow partial
+    simplification (that is a result different from input,
+    but still containing hypergeometric functions).
+
+    If a G-function has expansions both at zero and at infinity,
+    ``place`` can be set to ``0`` or ``zoo`` to indicate the
+    preferred choice.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.hyperexpand import hyperexpand
+    >>> from sympy.functions import hyper
+    >>> from sympy.abc import z
+    >>> hyperexpand(hyper([], [], z))
+    exp(z)
+
+    Non-hyperegeometric parts of the expression and hypergeometric expressions
+    that are not recognised are left unchanged:
+
+    >>> hyperexpand(1 + hyper([1, 1, 1], [], z))
+    hyper((1, 1, 1), (), z) + 1
+    """
+    f = sympify(f)
+
+    def do_replace(ap, bq, z):
+        r = _hyperexpand(Hyper_Function(ap, bq), z, rewrite=rewrite)
+        if r is None:
+            return hyper(ap, bq, z)
+        else:
+            return r
+
+    def do_meijer(ap, bq, z):
+        r = _meijergexpand(G_Function(ap[0], ap[1], bq[0], bq[1]), z,
+                   allow_hyper, rewrite=rewrite, place=place)
+        if not r.has(nan, zoo, oo, -oo):
+            return r
+    return f.replace(hyper, do_replace).replace(meijerg, do_meijer)

llmeval-env/lib/python3.10/site-packages/sympy/simplify/ratsimp.py

@@ -0,0 +1,222 @@
+from itertools import combinations_with_replacement
+from sympy.core import symbols, Add, Dummy
+from sympy.core.numbers import Rational
+from sympy.polys import cancel, ComputationFailed, parallel_poly_from_expr, reduced, Poly
+from sympy.polys.monomials import Monomial, monomial_div
+from sympy.polys.polyerrors import DomainError, PolificationFailed
+from sympy.utilities.misc import debug, debugf
+
+def ratsimp(expr):
+    """
+    Put an expression over a common denominator, cancel and reduce.
+
+    Examples
+    ========
+
+    >>> from sympy import ratsimp
+    >>> from sympy.abc import x, y
+    >>> ratsimp(1/x + 1/y)
+    (x + y)/(x*y)
+    """
+
+    f, g = cancel(expr).as_numer_denom()
+    try:
+        Q, r = reduced(f, [g], field=True, expand=False)
+    except ComputationFailed:
+        return f/g
+
+    return Add(*Q) + cancel(r/g)
+
+
+def ratsimpmodprime(expr, G, *gens, quick=True, polynomial=False, **args):
+    """
+    Simplifies a rational expression ``expr`` modulo the prime ideal
+    generated by ``G``.  ``G`` should be a Groebner basis of the
+    ideal.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.ratsimp import ratsimpmodprime
+    >>> from sympy.abc import x, y
+    >>> eq = (x + y**5 + y)/(x - y)
+    >>> ratsimpmodprime(eq, [x*y**5 - x - y], x, y, order='lex')
+    (-x**2 - x*y - x - y)/(-x**2 + x*y)
+
+    If ``polynomial`` is ``False``, the algorithm computes a rational
+    simplification which minimizes the sum of the total degrees of
+    the numerator and the denominator.
+
+    If ``polynomial`` is ``True``, this function just brings numerator and
+    denominator into a canonical form. This is much faster, but has
+    potentially worse results.
+
+    References
+    ==========
+
+    .. [1] M. Monagan, R. Pearce, Rational Simplification Modulo a Polynomial
+        Ideal, https://dl.acm.org/doi/pdf/10.1145/1145768.1145809
+        (specifically, the second algorithm)
+    """
+    from sympy.solvers.solvers import solve
+
+    debug('ratsimpmodprime', expr)
+
+    # usual preparation of polynomials:
+
+    num, denom = cancel(expr).as_numer_denom()
+
+    try:
+        polys, opt = parallel_poly_from_expr([num, denom] + G, *gens, **args)
+    except PolificationFailed:
+        return expr
+
+    domain = opt.domain
+
+    if domain.has_assoc_Field:
+        opt.domain = domain.get_field()
+    else:
+        raise DomainError(
+            "Cannot compute rational simplification over %s" % domain)
+
+    # compute only once
+    leading_monomials = [g.LM(opt.order) for g in polys[2:]]
+    tested = set()
+
+    def staircase(n):
+        """
+        Compute all monomials with degree less than ``n`` that are
+        not divisible by any element of ``leading_monomials``.
+        """
+        if n == 0:
+            return [1]
+        S = []
+        for mi in combinations_with_replacement(range(len(opt.gens)), n):
+            m = [0]*len(opt.gens)
+            for i in mi:
+                m[i] += 1
+            if all(monomial_div(m, lmg) is None for lmg in
+                   leading_monomials):
+                S.append(m)
+
+        return [Monomial(s).as_expr(*opt.gens) for s in S] + staircase(n - 1)
+
+    def _ratsimpmodprime(a, b, allsol, N=0, D=0):
+        r"""
+        Computes a rational simplification of ``a/b`` which minimizes
+        the sum of the total degrees of the numerator and the denominator.
+
+        Explanation
+        ===========
+
+        The algorithm proceeds by looking at ``a * d - b * c`` modulo
+        the ideal generated by ``G`` for some ``c`` and ``d`` with degree
+        less than ``a`` and ``b`` respectively.
+        The coefficients of ``c`` and ``d`` are indeterminates and thus
+        the coefficients of the normalform of ``a * d - b * c`` are
+        linear polynomials in these indeterminates.
+        If these linear polynomials, considered as system of
+        equations, have a nontrivial solution, then `\frac{a}{b}
+        \equiv \frac{c}{d}` modulo the ideal generated by ``G``. So,
+        by construction, the degree of ``c`` and ``d`` is less than
+        the degree of ``a`` and ``b``, so a simpler representation
+        has been found.
+        After a simpler representation has been found, the algorithm
+        tries to reduce the degree of the numerator and denominator
+        and returns the result afterwards.
+
+        As an extension, if quick=False, we look at all possible degrees such
+        that the total degree is less than *or equal to* the best current
+        solution. We retain a list of all solutions of minimal degree, and try
+        to find the best one at the end.
+        """
+        c, d = a, b
+        steps = 0
+
+        maxdeg = a.total_degree() + b.total_degree()
+        if quick:
+            bound = maxdeg - 1
+        else:
+            bound = maxdeg
+        while N + D <= bound:
+            if (N, D) in tested:
+                break
+            tested.add((N, D))
+
+            M1 = staircase(N)
+            M2 = staircase(D)
+            debugf('%s / %s: %s, %s', (N, D, M1, M2))
+
+            Cs = symbols("c:%d" % len(M1), cls=Dummy)
+            Ds = symbols("d:%d" % len(M2), cls=Dummy)
+            ng = Cs + Ds
+
+            c_hat = Poly(
+                sum([Cs[i] * M1[i] for i in range(len(M1))]), opt.gens + ng)
+            d_hat = Poly(
+                sum([Ds[i] * M2[i] for i in range(len(M2))]), opt.gens + ng)
+
+            r = reduced(a * d_hat - b * c_hat, G, opt.gens + ng,
+                        order=opt.order, polys=True)[1]
+
+            S = Poly(r, gens=opt.gens).coeffs()
+            sol = solve(S, Cs + Ds, particular=True, quick=True)
+
+            if sol and not all(s == 0 for s in sol.values()):
+                c = c_hat.subs(sol)
+                d = d_hat.subs(sol)
+
+                # The "free" variables occurring before as parameters
+                # might still be in the substituted c, d, so set them
+                # to the value chosen before:
+                c = c.subs(dict(list(zip(Cs + Ds, [1] * (len(Cs) + len(Ds))))))
+                d = d.subs(dict(list(zip(Cs + Ds, [1] * (len(Cs) + len(Ds))))))
+
+                c = Poly(c, opt.gens)
+                d = Poly(d, opt.gens)
+                if d == 0:
+                    raise ValueError('Ideal not prime?')
+
+                allsol.append((c_hat, d_hat, S, Cs + Ds))
+                if N + D != maxdeg:
+                    allsol = [allsol[-1]]
+
+                break
+
+            steps += 1
+            N += 1
+            D += 1
+
+        if steps > 0:
+            c, d, allsol = _ratsimpmodprime(c, d, allsol, N, D - steps)
+            c, d, allsol = _ratsimpmodprime(c, d, allsol, N - steps, D)
+
+        return c, d, allsol
+
+    # preprocessing. this improves performance a bit when deg(num)
+    # and deg(denom) are large:
+    num = reduced(num, G, opt.gens, order=opt.order)[1]
+    denom = reduced(denom, G, opt.gens, order=opt.order)[1]
+
+    if polynomial:
+        return (num/denom).cancel()
+
+    c, d, allsol = _ratsimpmodprime(
+        Poly(num, opt.gens, domain=opt.domain), Poly(denom, opt.gens, domain=opt.domain), [])
+    if not quick and allsol:
+        debugf('Looking for best minimal solution. Got: %s', len(allsol))
+        newsol = []
+        for c_hat, d_hat, S, ng in allsol:
+            sol = solve(S, ng, particular=True, quick=False)
+            # all values of sol should be numbers; if not, solve is broken
+            newsol.append((c_hat.subs(sol), d_hat.subs(sol)))
+        c, d = min(newsol, key=lambda x: len(x[0].terms()) + len(x[1].terms()))
+
+    if not domain.is_Field:
+        cn, c = c.clear_denoms(convert=True)
+        dn, d = d.clear_denoms(convert=True)
+        r = Rational(cn, dn)
+    else:
+        r = Rational(1)
+
+    return (c*r.q)/(d*r.p)