Add files using upload-large-folder tool

env-llmeval/lib/python3.10/site-packages/sympy/diffgeom/rn.py

@@ -0,0 +1,143 @@
+"""Predefined R^n manifolds together with common coord. systems.
+
+Coordinate systems are predefined as well as the transformation laws between
+them.
+
+Coordinate functions can be accessed as attributes of the manifold (eg `R2.x`),
+as attributes of the coordinate systems (eg `R2_r.x` and `R2_p.theta`), or by
+using the usual `coord_sys.coord_function(index, name)` interface.
+"""
+
+from typing import Any
+import warnings
+
+from sympy.core.symbol import (Dummy, symbols)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (acos, atan2, cos, sin)
+from .diffgeom import Manifold, Patch, CoordSystem
+
+__all__ = [
+    'R2', 'R2_origin', 'relations_2d', 'R2_r', 'R2_p',
+    'R3', 'R3_origin', 'relations_3d', 'R3_r', 'R3_c', 'R3_s'
+]
+
+###############################################################################
+# R2
+###############################################################################
+R2: Any = Manifold('R^2', 2)
+
+R2_origin: Any = Patch('origin', R2)
+
+x, y = symbols('x y', real=True)
+r, theta = symbols('rho theta', nonnegative=True)
+
+relations_2d = {
+    ('rectangular', 'polar'): [(x, y), (sqrt(x**2 + y**2), atan2(y, x))],
+    ('polar', 'rectangular'): [(r, theta), (r*cos(theta), r*sin(theta))],
+}
+
+R2_r: Any = CoordSystem('rectangular', R2_origin, (x, y), relations_2d)
+R2_p: Any = CoordSystem('polar', R2_origin, (r, theta), relations_2d)
+
+# support deprecated feature
+with warnings.catch_warnings():
+    warnings.simplefilter("ignore")
+    x, y, r, theta = symbols('x y r theta', cls=Dummy)
+    R2_r.connect_to(R2_p, [x, y],
+                        [sqrt(x**2 + y**2), atan2(y, x)],
+                    inverse=False, fill_in_gaps=False)
+    R2_p.connect_to(R2_r, [r, theta],
+                        [r*cos(theta), r*sin(theta)],
+                    inverse=False, fill_in_gaps=False)
+
+# Defining the basis coordinate functions and adding shortcuts for them to the
+# manifold and the patch.
+R2.x, R2.y = R2_origin.x, R2_origin.y = R2_r.x, R2_r.y = R2_r.coord_functions()
+R2.r, R2.theta = R2_origin.r, R2_origin.theta = R2_p.r, R2_p.theta = R2_p.coord_functions()
+
+# Defining the basis vector fields and adding shortcuts for them to the
+# manifold and the patch.
+R2.e_x, R2.e_y = R2_origin.e_x, R2_origin.e_y = R2_r.e_x, R2_r.e_y = R2_r.base_vectors()
+R2.e_r, R2.e_theta = R2_origin.e_r, R2_origin.e_theta = R2_p.e_r, R2_p.e_theta = R2_p.base_vectors()
+
+# Defining the basis oneform fields and adding shortcuts for them to the
+# manifold and the patch.
+R2.dx, R2.dy = R2_origin.dx, R2_origin.dy = R2_r.dx, R2_r.dy = R2_r.base_oneforms()
+R2.dr, R2.dtheta = R2_origin.dr, R2_origin.dtheta = R2_p.dr, R2_p.dtheta = R2_p.base_oneforms()
+
+###############################################################################
+# R3
+###############################################################################
+R3: Any = Manifold('R^3', 3)
+
+R3_origin: Any = Patch('origin', R3)
+
+x, y, z = symbols('x y z', real=True)
+rho, psi, r, theta, phi = symbols('rho psi r theta phi', nonnegative=True)
+
+relations_3d = {
+    ('rectangular', 'cylindrical'): [(x, y, z),
+                                     (sqrt(x**2 + y**2), atan2(y, x), z)],
+    ('cylindrical', 'rectangular'): [(rho, psi, z),
+                                     (rho*cos(psi), rho*sin(psi), z)],
+    ('rectangular', 'spherical'): [(x, y, z),
+                                   (sqrt(x**2 + y**2 + z**2),
+                                    acos(z/sqrt(x**2 + y**2 + z**2)),
+                                    atan2(y, x))],
+    ('spherical', 'rectangular'): [(r, theta, phi),
+                                   (r*sin(theta)*cos(phi),
+                                    r*sin(theta)*sin(phi),
+                                    r*cos(theta))],
+    ('cylindrical', 'spherical'): [(rho, psi, z),
+                                   (sqrt(rho**2 + z**2),
+                                    acos(z/sqrt(rho**2 + z**2)),
+                                    psi)],
+    ('spherical', 'cylindrical'): [(r, theta, phi),
+                                   (r*sin(theta), phi, r*cos(theta))],
+}
+
+R3_r: Any = CoordSystem('rectangular', R3_origin, (x, y, z), relations_3d)
+R3_c: Any = CoordSystem('cylindrical', R3_origin, (rho, psi, z), relations_3d)
+R3_s: Any = CoordSystem('spherical', R3_origin, (r, theta, phi), relations_3d)
+
+# support deprecated feature
+with warnings.catch_warnings():
+    warnings.simplefilter("ignore")
+    x, y, z, rho, psi, r, theta, phi = symbols('x y z rho psi r theta phi', cls=Dummy)
+    R3_r.connect_to(R3_c, [x, y, z],
+                        [sqrt(x**2 + y**2), atan2(y, x), z],
+                    inverse=False, fill_in_gaps=False)
+    R3_c.connect_to(R3_r, [rho, psi, z],
+                        [rho*cos(psi), rho*sin(psi), z],
+                    inverse=False, fill_in_gaps=False)
+    ## rectangular <-> spherical
+    R3_r.connect_to(R3_s, [x, y, z],
+                        [sqrt(x**2 + y**2 + z**2), acos(z/
+                                sqrt(x**2 + y**2 + z**2)), atan2(y, x)],
+                    inverse=False, fill_in_gaps=False)
+    R3_s.connect_to(R3_r, [r, theta, phi],
+                        [r*sin(theta)*cos(phi), r*sin(
+                            theta)*sin(phi), r*cos(theta)],
+                    inverse=False, fill_in_gaps=False)
+    ## cylindrical <-> spherical
+    R3_c.connect_to(R3_s, [rho, psi, z],
+                        [sqrt(rho**2 + z**2), acos(z/sqrt(rho**2 + z**2)), psi],
+                    inverse=False, fill_in_gaps=False)
+    R3_s.connect_to(R3_c, [r, theta, phi],
+                        [r*sin(theta), phi, r*cos(theta)],
+                    inverse=False, fill_in_gaps=False)
+
+# Defining the basis coordinate functions.
+R3_r.x, R3_r.y, R3_r.z = R3_r.coord_functions()
+R3_c.rho, R3_c.psi, R3_c.z = R3_c.coord_functions()
+R3_s.r, R3_s.theta, R3_s.phi = R3_s.coord_functions()
+
+# Defining the basis vector fields.
+R3_r.e_x, R3_r.e_y, R3_r.e_z = R3_r.base_vectors()
+R3_c.e_rho, R3_c.e_psi, R3_c.e_z = R3_c.base_vectors()
+R3_s.e_r, R3_s.e_theta, R3_s.e_phi = R3_s.base_vectors()
+
+# Defining the basis oneform fields.
+R3_r.dx, R3_r.dy, R3_r.dz = R3_r.base_oneforms()
+R3_c.drho, R3_c.dpsi, R3_c.dz = R3_c.base_oneforms()
+R3_s.dr, R3_s.dtheta, R3_s.dphi = R3_s.base_oneforms()

env-llmeval/lib/python3.10/site-packages/sympy/diffgeom/tests/test_class_structure.py

@@ -0,0 +1,33 @@
+from sympy.diffgeom import Manifold, Patch, CoordSystem, Point
+from sympy.core.function import Function
+from sympy.core.symbol import symbols
+from sympy.testing.pytest import warns_deprecated_sympy
+
+m = Manifold('m', 2)
+p = Patch('p', m)
+a, b = symbols('a b')
+cs = CoordSystem('cs', p, [a, b])
+x, y = symbols('x y')
+f = Function('f')
+s1, s2 = cs.coord_functions()
+v1, v2 = cs.base_vectors()
+f1, f2 = cs.base_oneforms()
+
+def test_point():
+    point = Point(cs, [x, y])
+    assert point != Point(cs, [2, y])
+    #TODO assert point.subs(x, 2) == Point(cs, [2, y])
+    #TODO assert point.free_symbols == set([x, y])
+
+def test_subs():
+    assert s1.subs(s1, s2) == s2
+    assert v1.subs(v1, v2) == v2
+    assert f1.subs(f1, f2) == f2
+    assert (x*f(s1) + y).subs(s1, s2) == x*f(s2) + y
+    assert (f(s1)*v1).subs(v1, v2) == f(s1)*v2
+    assert (y*f(s1)*f1).subs(f1, f2) == y*f(s1)*f2
+
+def test_deprecated():
+    with warns_deprecated_sympy():
+        cs_wname = CoordSystem('cs', p, ['a', 'b'])
+        assert cs_wname == cs_wname.func(*cs_wname.args)

env-llmeval/lib/python3.10/site-packages/sympy/diffgeom/tests/test_diffgeom.py

@@ -0,0 +1,342 @@
+from sympy.core import Lambda, Symbol, symbols
+from sympy.diffgeom.rn import R2, R2_p, R2_r, R3_r, R3_c, R3_s, R2_origin
+from sympy.diffgeom import (Manifold, Patch, CoordSystem, Commutator, Differential, TensorProduct,
+        WedgeProduct, BaseCovarDerivativeOp, CovarDerivativeOp, LieDerivative,
+        covariant_order, contravariant_order, twoform_to_matrix, metric_to_Christoffel_1st,
+        metric_to_Christoffel_2nd, metric_to_Riemann_components,
+        metric_to_Ricci_components, intcurve_diffequ, intcurve_series)
+from sympy.simplify import trigsimp, simplify
+from sympy.functions import sqrt, atan2, sin
+from sympy.matrices import Matrix
+from sympy.testing.pytest import raises, nocache_fail
+from sympy.testing.pytest import warns_deprecated_sympy
+
+TP = TensorProduct
+
+
+def test_coordsys_transform():
+    # test inverse transforms
+    p, q, r, s = symbols('p q r s')
+    rel = {('first', 'second'): [(p, q), (q, -p)]}
+    R2_pq = CoordSystem('first', R2_origin, [p, q], rel)
+    R2_rs = CoordSystem('second', R2_origin, [r, s], rel)
+    r, s = R2_rs.symbols
+    assert R2_rs.transform(R2_pq) == Matrix([[-s], [r]])
+
+    # inverse transform impossible case
+    a, b = symbols('a b', positive=True)
+    rel = {('first', 'second'): [(a,), (-a,)]}
+    R2_a = CoordSystem('first', R2_origin, [a], rel)
+    R2_b = CoordSystem('second', R2_origin, [b], rel)
+    # This transformation is uninvertible because there is no positive a, b satisfying a = -b
+    with raises(NotImplementedError):
+        R2_b.transform(R2_a)
+
+    # inverse transform ambiguous case
+    c, d = symbols('c d')
+    rel = {('first', 'second'): [(c,), (c**2,)]}
+    R2_c = CoordSystem('first', R2_origin, [c], rel)
+    R2_d = CoordSystem('second', R2_origin, [d], rel)
+    # The transform method should throw if it finds multiple inverses for a coordinate transformation.
+    with raises(ValueError):
+        R2_d.transform(R2_c)
+
+    # test indirect transformation
+    a, b, c, d, e, f = symbols('a, b, c, d, e, f')
+    rel = {('C1', 'C2'): [(a, b), (2*a, 3*b)],
+        ('C2', 'C3'): [(c, d), (3*c, 2*d)]}
+    C1 = CoordSystem('C1', R2_origin, (a, b), rel)
+    C2 = CoordSystem('C2', R2_origin, (c, d), rel)
+    C3 = CoordSystem('C3', R2_origin, (e, f), rel)
+    a, b = C1.symbols
+    c, d = C2.symbols
+    e, f = C3.symbols
+    assert C2.transform(C1) == Matrix([c/2, d/3])
+    assert C1.transform(C3) == Matrix([6*a, 6*b])
+    assert C3.transform(C1) == Matrix([e/6, f/6])
+    assert C3.transform(C2) == Matrix([e/3, f/2])
+
+    a, b, c, d, e, f = symbols('a, b, c, d, e, f')
+    rel = {('C1', 'C2'): [(a, b), (2*a, 3*b + 1)],
+        ('C3', 'C2'): [(e, f), (-e - 2, 2*f)]}
+    C1 = CoordSystem('C1', R2_origin, (a, b), rel)
+    C2 = CoordSystem('C2', R2_origin, (c, d), rel)
+    C3 = CoordSystem('C3', R2_origin, (e, f), rel)
+    a, b = C1.symbols
+    c, d = C2.symbols
+    e, f = C3.symbols
+    assert C2.transform(C1) == Matrix([c/2, (d - 1)/3])
+    assert C1.transform(C3) == Matrix([-2*a - 2, (3*b + 1)/2])
+    assert C3.transform(C1) == Matrix([-e/2 - 1, (2*f - 1)/3])
+    assert C3.transform(C2) == Matrix([-e - 2, 2*f])
+
+    # old signature uses Lambda
+    a, b, c, d, e, f = symbols('a, b, c, d, e, f')
+    rel = {('C1', 'C2'): Lambda((a, b), (2*a, 3*b + 1)),
+        ('C3', 'C2'): Lambda((e, f), (-e - 2, 2*f))}
+    C1 = CoordSystem('C1', R2_origin, (a, b), rel)
+    C2 = CoordSystem('C2', R2_origin, (c, d), rel)
+    C3 = CoordSystem('C3', R2_origin, (e, f), rel)
+    a, b = C1.symbols
+    c, d = C2.symbols
+    e, f = C3.symbols
+    assert C2.transform(C1) == Matrix([c/2, (d - 1)/3])
+    assert C1.transform(C3) == Matrix([-2*a - 2, (3*b + 1)/2])
+    assert C3.transform(C1) == Matrix([-e/2 - 1, (2*f - 1)/3])
+    assert C3.transform(C2) == Matrix([-e - 2, 2*f])
+
+
+def test_R2():
+    x0, y0, r0, theta0 = symbols('x0, y0, r0, theta0', real=True)
+    point_r = R2_r.point([x0, y0])
+    point_p = R2_p.point([r0, theta0])
+
+    # r**2 = x**2 + y**2
+    assert (R2.r**2 - R2.x**2 - R2.y**2).rcall(point_r) == 0
+    assert trigsimp( (R2.r**2 - R2.x**2 - R2.y**2).rcall(point_p) ) == 0
+    assert trigsimp(R2.e_r(R2.x**2 + R2.y**2).rcall(point_p).doit()) == 2*r0
+
+    # polar->rect->polar == Id
+    a, b = symbols('a b', positive=True)
+    m = Matrix([[a], [b]])
+
+    #TODO assert m == R2_r.transform(R2_p, R2_p.transform(R2_r, [a, b])).applyfunc(simplify)
+    assert m == R2_p.transform(R2_r, R2_r.transform(R2_p, m)).applyfunc(simplify)
+
+    # deprecated method
+    with warns_deprecated_sympy():
+        assert m == R2_p.coord_tuple_transform_to(
+            R2_r, R2_r.coord_tuple_transform_to(R2_p, m)).applyfunc(simplify)
+
+
+def test_R3():
+    a, b, c = symbols('a b c', positive=True)
+    m = Matrix([[a], [b], [c]])
+
+    assert m == R3_c.transform(R3_r, R3_r.transform(R3_c, m)).applyfunc(simplify)
+    #TODO assert m == R3_r.transform(R3_c, R3_c.transform(R3_r, m)).applyfunc(simplify)
+    assert m == R3_s.transform(
+        R3_r, R3_r.transform(R3_s, m)).applyfunc(simplify)
+    #TODO assert m == R3_r.transform(R3_s, R3_s.transform(R3_r, m)).applyfunc(simplify)
+    assert m == R3_s.transform(
+        R3_c, R3_c.transform(R3_s, m)).applyfunc(simplify)
+    #TODO assert m == R3_c.transform(R3_s, R3_s.transform(R3_c, m)).applyfunc(simplify)
+
+    with warns_deprecated_sympy():
+        assert m == R3_c.coord_tuple_transform_to(
+            R3_r, R3_r.coord_tuple_transform_to(R3_c, m)).applyfunc(simplify)
+        #TODO assert m == R3_r.coord_tuple_transform_to(R3_c, R3_c.coord_tuple_transform_to(R3_r, m)).applyfunc(simplify)
+        assert m == R3_s.coord_tuple_transform_to(
+            R3_r, R3_r.coord_tuple_transform_to(R3_s, m)).applyfunc(simplify)
+        #TODO assert m == R3_r.coord_tuple_transform_to(R3_s, R3_s.coord_tuple_transform_to(R3_r, m)).applyfunc(simplify)
+        assert m == R3_s.coord_tuple_transform_to(
+            R3_c, R3_c.coord_tuple_transform_to(R3_s, m)).applyfunc(simplify)
+        #TODO assert m == R3_c.coord_tuple_transform_to(R3_s, R3_s.coord_tuple_transform_to(R3_c, m)).applyfunc(simplify)
+
+
+def test_CoordinateSymbol():
+    x, y = R2_r.symbols
+    r, theta = R2_p.symbols
+    assert y.rewrite(R2_p) == r*sin(theta)
+
+
+def test_point():
+    x, y = symbols('x, y')
+    p = R2_r.point([x, y])
+    assert p.free_symbols == {x, y}
+    assert p.coords(R2_r) == p.coords() == Matrix([x, y])
+    assert p.coords(R2_p) == Matrix([sqrt(x**2 + y**2), atan2(y, x)])
+
+
+def test_commutator():
+    assert Commutator(R2.e_x, R2.e_y) == 0
+    assert Commutator(R2.x*R2.e_x, R2.x*R2.e_x) == 0
+    assert Commutator(R2.x*R2.e_x, R2.x*R2.e_y) == R2.x*R2.e_y
+    c = Commutator(R2.e_x, R2.e_r)
+    assert c(R2.x) == R2.y*(R2.x**2 + R2.y**2)**(-1)*sin(R2.theta)
+
+
+def test_differential():
+    xdy = R2.x*R2.dy
+    dxdy = Differential(xdy)
+    assert xdy.rcall(None) == xdy
+    assert dxdy(R2.e_x, R2.e_y) == 1
+    assert dxdy(R2.e_x, R2.x*R2.e_y) == R2.x
+    assert Differential(dxdy) == 0
+
+
+def test_products():
+    assert TensorProduct(
+        R2.dx, R2.dy)(R2.e_x, R2.e_y) == R2.dx(R2.e_x)*R2.dy(R2.e_y) == 1
+    assert TensorProduct(R2.dx, R2.dy)(None, R2.e_y) == R2.dx
+    assert TensorProduct(R2.dx, R2.dy)(R2.e_x, None) == R2.dy
+    assert TensorProduct(R2.dx, R2.dy)(R2.e_x) == R2.dy
+    assert TensorProduct(R2.x, R2.dx) == R2.x*R2.dx
+    assert TensorProduct(
+        R2.e_x, R2.e_y)(R2.x, R2.y) == R2.e_x(R2.x) * R2.e_y(R2.y) == 1
+    assert TensorProduct(R2.e_x, R2.e_y)(None, R2.y) == R2.e_x
+    assert TensorProduct(R2.e_x, R2.e_y)(R2.x, None) == R2.e_y
+    assert TensorProduct(R2.e_x, R2.e_y)(R2.x) == R2.e_y
+    assert TensorProduct(R2.x, R2.e_x) == R2.x * R2.e_x
+    assert TensorProduct(
+        R2.dx, R2.e_y)(R2.e_x, R2.y) == R2.dx(R2.e_x) * R2.e_y(R2.y) == 1
+    assert TensorProduct(R2.dx, R2.e_y)(None, R2.y) == R2.dx
+    assert TensorProduct(R2.dx, R2.e_y)(R2.e_x, None) == R2.e_y
+    assert TensorProduct(R2.dx, R2.e_y)(R2.e_x) == R2.e_y
+    assert TensorProduct(R2.x, R2.e_x) == R2.x * R2.e_x
+    assert TensorProduct(
+        R2.e_x, R2.dy)(R2.x, R2.e_y) == R2.e_x(R2.x) * R2.dy(R2.e_y) == 1
+    assert TensorProduct(R2.e_x, R2.dy)(None, R2.e_y) == R2.e_x
+    assert TensorProduct(R2.e_x, R2.dy)(R2.x, None) == R2.dy
+    assert TensorProduct(R2.e_x, R2.dy)(R2.x) == R2.dy
+    assert TensorProduct(R2.e_y,R2.e_x)(R2.x**2 + R2.y**2,R2.x**2 + R2.y**2) == 4*R2.x*R2.y
+
+    assert WedgeProduct(R2.dx, R2.dy)(R2.e_x, R2.e_y) == 1
+    assert WedgeProduct(R2.e_x, R2.e_y)(R2.x, R2.y) == 1
+
+
+def test_lie_derivative():
+    assert LieDerivative(R2.e_x, R2.y) == R2.e_x(R2.y) == 0
+    assert LieDerivative(R2.e_x, R2.x) == R2.e_x(R2.x) == 1
+    assert LieDerivative(R2.e_x, R2.e_x) == Commutator(R2.e_x, R2.e_x) == 0
+    assert LieDerivative(R2.e_x, R2.e_r) == Commutator(R2.e_x, R2.e_r)
+    assert LieDerivative(R2.e_x + R2.e_y, R2.x) == 1
+    assert LieDerivative(
+        R2.e_x, TensorProduct(R2.dx, R2.dy))(R2.e_x, R2.e_y) == 0
+
+
+@nocache_fail
+def test_covar_deriv():
+    ch = metric_to_Christoffel_2nd(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy))
+    cvd = BaseCovarDerivativeOp(R2_r, 0, ch)
+    assert cvd(R2.x) == 1
+    # This line fails if the cache is disabled:
+    assert cvd(R2.x*R2.e_x) == R2.e_x
+    cvd = CovarDerivativeOp(R2.x*R2.e_x, ch)
+    assert cvd(R2.x) == R2.x
+    assert cvd(R2.x*R2.e_x) == R2.x*R2.e_x
+
+
+def test_intcurve_diffequ():
+    t = symbols('t')
+    start_point = R2_r.point([1, 0])
+    vector_field = -R2.y*R2.e_x + R2.x*R2.e_y
+    equations, init_cond = intcurve_diffequ(vector_field, t, start_point)
+    assert str(equations) == '[f_1(t) + Derivative(f_0(t), t), -f_0(t) + Derivative(f_1(t), t)]'
+    assert str(init_cond) == '[f_0(0) - 1, f_1(0)]'
+    equations, init_cond = intcurve_diffequ(vector_field, t, start_point, R2_p)
+    assert str(
+        equations) == '[Derivative(f_0(t), t), Derivative(f_1(t), t) - 1]'
+    assert str(init_cond) == '[f_0(0) - 1, f_1(0)]'
+
+
+def test_helpers_and_coordinate_dependent():
+    one_form = R2.dr + R2.dx
+    two_form = Differential(R2.x*R2.dr + R2.r*R2.dx)
+    three_form = Differential(
+        R2.y*two_form) + Differential(R2.x*Differential(R2.r*R2.dr))
+    metric = TensorProduct(R2.dx, R2.dx) + TensorProduct(R2.dy, R2.dy)
+    metric_ambig = TensorProduct(R2.dx, R2.dx) + TensorProduct(R2.dr, R2.dr)
+    misform_a = TensorProduct(R2.dr, R2.dr) + R2.dr
+    misform_b = R2.dr**4
+    misform_c = R2.dx*R2.dy
+    twoform_not_sym = TensorProduct(R2.dx, R2.dx) + TensorProduct(R2.dx, R2.dy)
+    twoform_not_TP = WedgeProduct(R2.dx, R2.dy)
+
+    one_vector = R2.e_x + R2.e_y
+    two_vector = TensorProduct(R2.e_x, R2.e_y)
+    three_vector = TensorProduct(R2.e_x, R2.e_y, R2.e_x)
+    two_wp = WedgeProduct(R2.e_x,R2.e_y)
+
+    assert covariant_order(one_form) == 1
+    assert covariant_order(two_form) == 2
+    assert covariant_order(three_form) == 3
+    assert covariant_order(two_form + metric) == 2
+    assert covariant_order(two_form + metric_ambig) == 2
+    assert covariant_order(two_form + twoform_not_sym) == 2
+    assert covariant_order(two_form + twoform_not_TP) == 2
+
+    assert contravariant_order(one_vector) == 1
+    assert contravariant_order(two_vector) == 2
+    assert contravariant_order(three_vector) == 3
+    assert contravariant_order(two_vector + two_wp) == 2
+
+    raises(ValueError, lambda: covariant_order(misform_a))
+    raises(ValueError, lambda: covariant_order(misform_b))
+    raises(ValueError, lambda: covariant_order(misform_c))
+
+    assert twoform_to_matrix(metric) == Matrix([[1, 0], [0, 1]])
+    assert twoform_to_matrix(twoform_not_sym) == Matrix([[1, 0], [1, 0]])
+    assert twoform_to_matrix(twoform_not_TP) == Matrix([[0, -1], [1, 0]])
+
+    raises(ValueError, lambda: twoform_to_matrix(one_form))
+    raises(ValueError, lambda: twoform_to_matrix(three_form))
+    raises(ValueError, lambda: twoform_to_matrix(metric_ambig))
+
+    raises(ValueError, lambda: metric_to_Christoffel_1st(twoform_not_sym))
+    raises(ValueError, lambda: metric_to_Christoffel_2nd(twoform_not_sym))
+    raises(ValueError, lambda: metric_to_Riemann_components(twoform_not_sym))
+    raises(ValueError, lambda: metric_to_Ricci_components(twoform_not_sym))
+
+
+def test_correct_arguments():
+    raises(ValueError, lambda: R2.e_x(R2.e_x))
+    raises(ValueError, lambda: R2.e_x(R2.dx))
+
+    raises(ValueError, lambda: Commutator(R2.e_x, R2.x))
+    raises(ValueError, lambda: Commutator(R2.dx, R2.e_x))
+
+    raises(ValueError, lambda: Differential(Differential(R2.e_x)))
+
+    raises(ValueError, lambda: R2.dx(R2.x))
+
+    raises(ValueError, lambda: LieDerivative(R2.dx, R2.dx))
+    raises(ValueError, lambda: LieDerivative(R2.x, R2.dx))
+
+    raises(ValueError, lambda: CovarDerivativeOp(R2.dx, []))
+    raises(ValueError, lambda: CovarDerivativeOp(R2.x, []))
+
+    a = Symbol('a')
+    raises(ValueError, lambda: intcurve_series(R2.dx, a, R2_r.point([1, 2])))
+    raises(ValueError, lambda: intcurve_series(R2.x, a, R2_r.point([1, 2])))
+
+    raises(ValueError, lambda: intcurve_diffequ(R2.dx, a, R2_r.point([1, 2])))
+    raises(ValueError, lambda: intcurve_diffequ(R2.x, a, R2_r.point([1, 2])))
+
+    raises(ValueError, lambda: contravariant_order(R2.e_x + R2.dx))
+    raises(ValueError, lambda: covariant_order(R2.e_x + R2.dx))
+
+    raises(ValueError, lambda: contravariant_order(R2.e_x*R2.e_y))
+    raises(ValueError, lambda: covariant_order(R2.dx*R2.dy))
+
+def test_simplify():
+    x, y = R2_r.coord_functions()
+    dx, dy = R2_r.base_oneforms()
+    ex, ey = R2_r.base_vectors()
+    assert simplify(x) == x
+    assert simplify(x*y) == x*y
+    assert simplify(dx*dy) == dx*dy
+    assert simplify(ex*ey) == ex*ey
+    assert ((1-x)*dx)/(1-x)**2 == dx/(1-x)
+
+
+def test_issue_17917():
+    X = R2.x*R2.e_x - R2.y*R2.e_y
+    Y = (R2.x**2 + R2.y**2)*R2.e_x - R2.x*R2.y*R2.e_y
+    assert LieDerivative(X, Y).expand() == (
+        R2.x**2*R2.e_x - 3*R2.y**2*R2.e_x - R2.x*R2.y*R2.e_y)
+
+def test_deprecations():
+    m = Manifold('M', 2)
+    p = Patch('P', m)
+    with warns_deprecated_sympy():
+        CoordSystem('Car2d', p, names=['x', 'y'])
+
+    with warns_deprecated_sympy():
+        c = CoordSystem('Car2d', p, ['x', 'y'])
+
+    with warns_deprecated_sympy():
+        list(m.patches)
+
+    with warns_deprecated_sympy():
+        list(c.transforms)

env-llmeval/lib/python3.10/site-packages/sympy/external/gmpy.py

@@ -0,0 +1,104 @@
+import os
+from typing import Tuple as tTuple, Type
+
+import mpmath.libmp as mlib
+
+from sympy.external import import_module
+
+__all__ = [
+    # GROUND_TYPES is either 'gmpy' or 'python' depending on which is used. If
+    # gmpy is installed then it will be used unless the environment variable
+    # SYMPY_GROUND_TYPES is set to something other than 'auto', 'gmpy', or
+    # 'gmpy2'.
+    'GROUND_TYPES',
+
+    # If HAS_GMPY is 0, no supported version of gmpy is available. Otherwise,
+    # HAS_GMPY will be 2 for gmpy2 if GROUND_TYPES is 'gmpy'. It used to be
+    # possible for HAS_GMPY to be 1 for gmpy but gmpy is no longer supported.
+    'HAS_GMPY',
+
+    # SYMPY_INTS is a tuple containing the base types for valid integer types.
+    # This is either (int,) or (int, type(mpz(0))) depending on GROUND_TYPES.
+    'SYMPY_INTS',
+
+    # MPQ is either gmpy.mpq or the Python equivalent from
+    # sympy.external.pythonmpq
+    'MPQ',
+
+    # MPZ is either gmpy.mpz or int.
+    'MPZ',
+
+    # Either the gmpy or the mpmath function
+    'factorial',
+
+    # isqrt from gmpy or mpmath
+    'sqrt',
+]
+
+
+#
+# SYMPY_GROUND_TYPES can be gmpy, gmpy2, python or auto
+#
+GROUND_TYPES = os.environ.get('SYMPY_GROUND_TYPES', 'auto').lower()
+
+
+#
+# Try to import gmpy2 by default. If gmpy or gmpy2 is specified in
+# SYMPY_GROUND_TYPES then warn if gmpy2 is not found. In all cases there is a
+# fallback based on pure Python int and PythonMPQ that should still work fine.
+#
+if GROUND_TYPES in ('auto', 'gmpy', 'gmpy2'):
+
+    # Actually import gmpy2
+    gmpy = import_module('gmpy2', min_module_version='2.0.0',
+                module_version_attr='version', module_version_attr_call_args=())
+
+    # Warn if user explicitly asked for gmpy but it isn't available.
+    if gmpy is None and GROUND_TYPES in ('gmpy', 'gmpy2'):
+        from warnings import warn
+        warn("gmpy library is not installed, switching to 'python' ground types")
+
+elif GROUND_TYPES == 'python':
+
+    # The user asked for Python so ignore gmpy2 module.
+    gmpy = None
+
+else:
+
+    # Invalid value for SYMPY_GROUND_TYPES. Ignore the gmpy2 module.
+    from warnings import warn
+    warn("SYMPY_GROUND_TYPES environment variable unrecognised. "
+         "Should be 'python', 'auto', 'gmpy', or 'gmpy2'")
+    gmpy = None
+
+
+#
+# At this point gmpy will be None if gmpy2 was not successfully imported or if
+# the environment variable SYMPY_GROUND_TYPES was set to 'python' (or some
+# unrecognised value). The two blocks below define the values exported by this
+# module in each case.
+#
+SYMPY_INTS: tTuple[Type, ...]
+
+if gmpy is not None:
+
+    HAS_GMPY = 2
+    GROUND_TYPES = 'gmpy'
+    SYMPY_INTS = (int, type(gmpy.mpz(0)))
+    MPZ = gmpy.mpz
+    MPQ = gmpy.mpq
+
+    factorial = gmpy.fac
+    sqrt = gmpy.isqrt
+
+else:
+    from .pythonmpq import PythonMPQ
+
+    HAS_GMPY = 0
+    GROUND_TYPES = 'python'
+    SYMPY_INTS = (int,)
+    MPZ = int
+    MPQ = PythonMPQ
+
+    factorial = lambda x: int(mlib.ifac(x))
+    sqrt = lambda x: int(mlib.isqrt(x))

env-llmeval/lib/python3.10/site-packages/sympy/external/importtools.py

@@ -0,0 +1,187 @@
+"""Tools to assist importing optional external modules."""
+
+import sys
+import re
+
+# Override these in the module to change the default warning behavior.
+# For example, you might set both to False before running the tests so that
+# warnings are not printed to the console, or set both to True for debugging.
+
+WARN_NOT_INSTALLED = None  # Default is False
+WARN_OLD_VERSION = None  # Default is True
+
+
+def __sympy_debug():
+    # helper function from sympy/__init__.py
+    # We don't just import SYMPY_DEBUG from that file because we don't want to
+    # import all of SymPy just to use this module.
+    import os
+    debug_str = os.getenv('SYMPY_DEBUG', 'False')
+    if debug_str in ('True', 'False'):
+        return eval(debug_str)
+    else:
+        raise RuntimeError("unrecognized value for SYMPY_DEBUG: %s" %
+                           debug_str)
+
+if __sympy_debug():
+    WARN_OLD_VERSION = True
+    WARN_NOT_INSTALLED = True
+
+
+_component_re = re.compile(r'(\d+ | [a-z]+ | \.)', re.VERBOSE)
+
+def version_tuple(vstring):
+    # Parse a version string to a tuple e.g. '1.2' -> (1, 2)
+    # Simplified from distutils.version.LooseVersion which was deprecated in
+    # Python 3.10.
+    components = []
+    for x in _component_re.split(vstring):
+        if x and x != '.':
+            try:
+                x = int(x)
+            except ValueError:
+                pass
+            components.append(x)
+    return tuple(components)
+
+
+def import_module(module, min_module_version=None, min_python_version=None,
+        warn_not_installed=None, warn_old_version=None,
+        module_version_attr='__version__', module_version_attr_call_args=None,
+        import_kwargs={}, catch=()):
+    """
+    Import and return a module if it is installed.
+
+    If the module is not installed, it returns None.
+
+    A minimum version for the module can be given as the keyword argument
+    min_module_version.  This should be comparable against the module version.
+    By default, module.__version__ is used to get the module version.  To
+    override this, set the module_version_attr keyword argument.  If the
+    attribute of the module to get the version should be called (e.g.,
+    module.version()), then set module_version_attr_call_args to the args such
+    that module.module_version_attr(*module_version_attr_call_args) returns the
+    module's version.
+
+    If the module version is less than min_module_version using the Python <
+    comparison, None will be returned, even if the module is installed. You can
+    use this to keep from importing an incompatible older version of a module.
+
+    You can also specify a minimum Python version by using the
+    min_python_version keyword argument.  This should be comparable against
+    sys.version_info.
+
+    If the keyword argument warn_not_installed is set to True, the function will
+    emit a UserWarning when the module is not installed.
+
+    If the keyword argument warn_old_version is set to True, the function will
+    emit a UserWarning when the library is installed, but cannot be imported
+    because of the min_module_version or min_python_version options.
+
+    Note that because of the way warnings are handled, a warning will be
+    emitted for each module only once.  You can change the default warning
+    behavior by overriding the values of WARN_NOT_INSTALLED and WARN_OLD_VERSION
+    in sympy.external.importtools.  By default, WARN_NOT_INSTALLED is False and
+    WARN_OLD_VERSION is True.
+
+    This function uses __import__() to import the module.  To pass additional
+    options to __import__(), use the import_kwargs keyword argument.  For
+    example, to import a submodule A.B, you must pass a nonempty fromlist option
+    to __import__.  See the docstring of __import__().
+
+    This catches ImportError to determine if the module is not installed.  To
+    catch additional errors, pass them as a tuple to the catch keyword
+    argument.
+
+    Examples
+    ========
+
+    >>> from sympy.external import import_module
+
+    >>> numpy = import_module('numpy')
+
+    >>> numpy = import_module('numpy', min_python_version=(2, 7),
+    ... warn_old_version=False)
+
+    >>> numpy = import_module('numpy', min_module_version='1.5',
+    ... warn_old_version=False) # numpy.__version__ is a string
+
+    >>> # gmpy does not have __version__, but it does have gmpy.version()
+
+    >>> gmpy = import_module('gmpy', min_module_version='1.14',
+    ... module_version_attr='version', module_version_attr_call_args=(),
+    ... warn_old_version=False)
+
+    >>> # To import a submodule, you must pass a nonempty fromlist to
+    >>> # __import__().  The values do not matter.
+    >>> p3 = import_module('mpl_toolkits.mplot3d',
+    ... import_kwargs={'fromlist':['something']})
+
+    >>> # matplotlib.pyplot can raise RuntimeError when the display cannot be opened
+    >>> matplotlib = import_module('matplotlib',
+    ... import_kwargs={'fromlist':['pyplot']}, catch=(RuntimeError,))
+
+    """
+    # keyword argument overrides default, and global variable overrides
+    # keyword argument.
+    warn_old_version = (WARN_OLD_VERSION if WARN_OLD_VERSION is not None
+        else warn_old_version or True)
+    warn_not_installed = (WARN_NOT_INSTALLED if WARN_NOT_INSTALLED is not None
+        else warn_not_installed or False)
+
+    import warnings
+
+    # Check Python first so we don't waste time importing a module we can't use
+    if min_python_version:
+        if sys.version_info < min_python_version:
+            if warn_old_version:
+                warnings.warn("Python version is too old to use %s "
+                    "(%s or newer required)" % (
+                        module, '.'.join(map(str, min_python_version))),
+                    UserWarning, stacklevel=2)
+            return
+
+    try:
+        mod = __import__(module, **import_kwargs)
+
+        ## there's something funny about imports with matplotlib and py3k. doing
+        ##    from matplotlib import collections
+        ## gives python's stdlib collections module. explicitly re-importing
+        ## the module fixes this.
+        from_list = import_kwargs.get('fromlist', ())
+        for submod in from_list:
+            if submod == 'collections' and mod.__name__ == 'matplotlib':
+                __import__(module + '.' + submod)
+    except ImportError:
+        if warn_not_installed:
+            warnings.warn("%s module is not installed" % module, UserWarning,
+                    stacklevel=2)
+        return
+    except catch as e:
+        if warn_not_installed:
+            warnings.warn(
+                "%s module could not be used (%s)" % (module, repr(e)),
+                stacklevel=2)
+        return
+
+    if min_module_version:
+        modversion = getattr(mod, module_version_attr)
+        if module_version_attr_call_args is not None:
+            modversion = modversion(*module_version_attr_call_args)
+        if version_tuple(modversion) < version_tuple(min_module_version):
+            if warn_old_version:
+                # Attempt to create a pretty string version of the version
+                if isinstance(min_module_version, str):
+                    verstr = min_module_version
+                elif isinstance(min_module_version, (tuple, list)):
+                    verstr = '.'.join(map(str, min_module_version))
+                else:
+                    # Either don't know what this is.  Hopefully
+                    # it's something that has a nice str version, like an int.
+                    verstr = str(min_module_version)
+                warnings.warn("%s version is too old to use "
+                    "(%s or newer required)" % (module, verstr),
+                    UserWarning, stacklevel=2)
+            return
+
+    return mod

env-llmeval/lib/python3.10/site-packages/sympy/matrices/tests/test_determinant.py

@@ -0,0 +1,414 @@
+import random
+from sympy.core.numbers import I
+from sympy.core.numbers import Rational
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.polys.polytools import Poly
+from sympy.matrices import Matrix, eye, ones
+from sympy.abc import x, y, z
+from sympy.testing.pytest import raises
+from sympy.matrices.common import NonSquareMatrixError
+from sympy.functions.combinatorial.factorials import factorial, subfactorial
+
+
+def test_determinant():
+    M = Matrix()
+
+    assert M.det() == 1
+    # Evaluating these directly because they are never reached via M.det()
+    assert M._eval_det_bareiss() == 1
+    assert M._eval_det_berkowitz() == 1
+    assert M._eval_det_lu() == 1
+
+    M = Matrix([ [0] ])
+
+    assert M.det() == 0
+    assert M._eval_det_bareiss() == 0
+    assert M._eval_det_berkowitz() == 0
+    assert M._eval_det_lu() == 0
+
+    M = Matrix([ [5] ])
+
+    assert M.det() == 5
+    assert M._eval_det_bareiss() == 5
+    assert M._eval_det_berkowitz() == 5
+    assert M._eval_det_lu() == 5
+
+    M = Matrix(( (-3,  2),
+                 ( 8, -5) ))
+
+    assert M.det(method="domain-ge") == -1
+    assert M.det(method="bareiss") == -1
+    assert M.det(method="berkowitz") == -1
+    assert M.det(method="lu") == -1
+
+    M = Matrix(( (x,   1),
+                 (y, 2*y) ))
+
+    assert M.det(method="domain-ge") == 2*x*y - y
+    assert M.det(method="bareiss") == 2*x*y - y
+    assert M.det(method="berkowitz") == 2*x*y - y
+    assert M.det(method="lu") == 2*x*y - y
+
+    M = Matrix(( (1, 1, 1),
+                 (1, 2, 3),
+                 (1, 3, 6) ))
+
+    assert M.det(method="domain-ge") == 1
+    assert M.det(method="bareiss") == 1
+    assert M.det(method="berkowitz") == 1
+    assert M.det(method="lu") == 1
+
+    M = Matrix(( ( 3, -2,  0, 5),
+                 (-2,  1, -2, 2),
+                 ( 0, -2,  5, 0),
+                 ( 5,  0,  3, 4) ))
+
+    assert M.det(method="domain-ge") == -289
+    assert M.det(method="bareiss") == -289
+    assert M.det(method="berkowitz") == -289
+    assert M.det(method="lu") == -289
+
+    M = Matrix(( ( 1,  2,  3,  4),
+                 ( 5,  6,  7,  8),
+                 ( 9, 10, 11, 12),
+                 (13, 14, 15, 16) ))
+
+    assert M.det(method="domain-ge") == 0
+    assert M.det(method="bareiss") == 0
+    assert M.det(method="berkowitz") == 0
+    assert M.det(method="lu") == 0
+
+    M = Matrix(( (3, 2, 0, 0, 0),
+                 (0, 3, 2, 0, 0),
+                 (0, 0, 3, 2, 0),
+                 (0, 0, 0, 3, 2),
+                 (2, 0, 0, 0, 3) ))
+
+    assert M.det(method="domain-ge") == 275
+    assert M.det(method="bareiss") == 275
+    assert M.det(method="berkowitz") == 275
+    assert M.det(method="lu") == 275
+
+    M = Matrix(( ( 3,  0,  0, 0),
+                 (-2,  1,  0, 0),
+                 ( 0, -2,  5, 0),
+                 ( 5,  0,  3, 4) ))
+
+    assert M.det(method="domain-ge") == 60
+    assert M.det(method="bareiss") == 60
+    assert M.det(method="berkowitz") == 60
+    assert M.det(method="lu") == 60
+
+    M = Matrix(( ( 1,  0,  0,  0),
+                 ( 5,  0,  0,  0),
+                 ( 9, 10, 11, 0),
+                 (13, 14, 15, 16) ))
+
+    assert M.det(method="domain-ge") == 0
+    assert M.det(method="bareiss") == 0
+    assert M.det(method="berkowitz") == 0
+    assert M.det(method="lu") == 0
+
+    M = Matrix(( (3, 2, 0, 0, 0),
+                 (0, 3, 2, 0, 0),
+                 (0, 0, 3, 2, 0),
+                 (0, 0, 0, 3, 2),
+                 (0, 0, 0, 0, 3) ))
+
+    assert M.det(method="domain-ge") == 243
+    assert M.det(method="bareiss") == 243
+    assert M.det(method="berkowitz") == 243
+    assert M.det(method="lu") == 243
+
+    M = Matrix(( (1, 0,  1,  2, 12),
+                 (2, 0,  1,  1,  4),
+                 (2, 1,  1, -1,  3),
+                 (3, 2, -1,  1,  8),
+                 (1, 1,  1,  0,  6) ))
+
+    assert M.det(method="domain-ge") == -55
+    assert M.det(method="bareiss") == -55
+    assert M.det(method="berkowitz") == -55
+    assert M.det(method="lu") == -55
+
+    M = Matrix(( (-5,  2,  3,  4,  5),
+                 ( 1, -4,  3,  4,  5),
+                 ( 1,  2, -3,  4,  5),
+                 ( 1,  2,  3, -2,  5),
+                 ( 1,  2,  3,  4, -1) ))
+
+    assert M.det(method="domain-ge") == 11664
+    assert M.det(method="bareiss") == 11664
+    assert M.det(method="berkowitz") == 11664
+    assert M.det(method="lu") == 11664
+
+    M = Matrix(( ( 2,  7, -1, 3, 2),
+                 ( 0,  0,  1, 0, 1),
+                 (-2,  0,  7, 0, 2),
+                 (-3, -2,  4, 5, 3),
+                 ( 1,  0,  0, 0, 1) ))
+
+    assert M.det(method="domain-ge") == 123
+    assert M.det(method="bareiss") == 123
+    assert M.det(method="berkowitz") == 123
+    assert M.det(method="lu") == 123
+
+    M = Matrix(( (x, y, z),
+                 (1, 0, 0),
+                 (y, z, x) ))
+
+    assert M.det(method="domain-ge") == z**2 - x*y
+    assert M.det(method="bareiss") == z**2 - x*y
+    assert M.det(method="berkowitz") == z**2 - x*y
+    assert M.det(method="lu") == z**2 - x*y
+
+    # issue 13835
+    a = symbols('a')
+    M = lambda n: Matrix([[i + a*j for i in range(n)]
+                          for j in range(n)])
+    assert M(5).det() == 0
+    assert M(6).det() == 0
+    assert M(7).det() == 0
+
+def test_issue_14517():
+    M = Matrix([
+        [   0, 10*I,    10*I,       0],
+        [10*I,    0,       0,    10*I],
+        [10*I,    0, 5 + 2*I,    10*I],
+        [   0, 10*I,    10*I, 5 + 2*I]])
+    ev = M.eigenvals()
+    # test one random eigenvalue, the computation is a little slow
+    test_ev = random.choice(list(ev.keys()))
+    assert (M - test_ev*eye(4)).det() == 0
+
+def test_legacy_det():
+    # Minimal support for legacy keys for 'method' in det()
+    # Partially copied from test_determinant()
+
+    M = Matrix(( ( 3, -2,  0, 5),
+                 (-2,  1, -2, 2),
+                 ( 0, -2,  5, 0),
+                 ( 5,  0,  3, 4) ))
+
+    assert M.det(method="bareis") == -289
+    assert M.det(method="det_lu") == -289
+    assert M.det(method="det_LU") == -289
+
+    M = Matrix(( (3, 2, 0, 0, 0),
+                 (0, 3, 2, 0, 0),
+                 (0, 0, 3, 2, 0),
+                 (0, 0, 0, 3, 2),
+                 (2, 0, 0, 0, 3) ))
+
+    assert M.det(method="bareis") == 275
+    assert M.det(method="det_lu") == 275
+    assert M.det(method="Bareis") == 275
+
+    M = Matrix(( (1, 0,  1,  2, 12),
+                 (2, 0,  1,  1,  4),
+                 (2, 1,  1, -1,  3),
+                 (3, 2, -1,  1,  8),
+                 (1, 1,  1,  0,  6) ))
+
+    assert M.det(method="bareis") == -55
+    assert M.det(method="det_lu") == -55
+    assert M.det(method="BAREISS") == -55
+
+    M = Matrix(( ( 3,  0,  0, 0),
+                 (-2,  1,  0, 0),
+                 ( 0, -2,  5, 0),
+                 ( 5,  0,  3, 4) ))
+
+    assert M.det(method="bareiss") == 60
+    assert M.det(method="berkowitz") == 60
+    assert M.det(method="lu") == 60
+
+    M = Matrix(( ( 1,  0,  0,  0),
+                 ( 5,  0,  0,  0),
+                 ( 9, 10, 11, 0),
+                 (13, 14, 15, 16) ))
+
+    assert M.det(method="bareiss") == 0
+    assert M.det(method="berkowitz") == 0
+    assert M.det(method="lu") == 0
+
+    M = Matrix(( (3, 2, 0, 0, 0),
+                 (0, 3, 2, 0, 0),
+                 (0, 0, 3, 2, 0),
+                 (0, 0, 0, 3, 2),
+                 (0, 0, 0, 0, 3) ))
+
+    assert M.det(method="bareiss") == 243
+    assert M.det(method="berkowitz") == 243
+    assert M.det(method="lu") == 243
+
+    M = Matrix(( (-5,  2,  3,  4,  5),
+                 ( 1, -4,  3,  4,  5),
+                 ( 1,  2, -3,  4,  5),
+                 ( 1,  2,  3, -2,  5),
+                 ( 1,  2,  3,  4, -1) ))
+
+    assert M.det(method="bareis") == 11664
+    assert M.det(method="det_lu") == 11664
+    assert M.det(method="BERKOWITZ") == 11664
+
+    M = Matrix(( ( 2,  7, -1, 3, 2),
+                 ( 0,  0,  1, 0, 1),
+                 (-2,  0,  7, 0, 2),
+                 (-3, -2,  4, 5, 3),
+                 ( 1,  0,  0, 0, 1) ))
+
+    assert M.det(method="bareis") == 123
+    assert M.det(method="det_lu") == 123
+    assert M.det(method="LU") == 123
+
+def eye_Determinant(n):
+    return Matrix(n, n, lambda i, j: int(i == j))
+
+def zeros_Determinant(n):
+    return Matrix(n, n, lambda i, j: 0)
+
+def test_det():
+    a = Matrix(2, 3, [1, 2, 3, 4, 5, 6])
+    raises(NonSquareMatrixError, lambda: a.det())
+
+    z = zeros_Determinant(2)
+    ey = eye_Determinant(2)
+    assert z.det() == 0
+    assert ey.det() == 1
+
+    x = Symbol('x')
+    a = Matrix(0, 0, [])
+    b = Matrix(1, 1, [5])
+    c = Matrix(2, 2, [1, 2, 3, 4])
+    d = Matrix(3, 3, [1, 2, 3, 4, 5, 6, 7, 8, 8])
+    e = Matrix(4, 4,
+        [x, 1, 2, 3, 4, 5, 6, 7, 2, 9, 10, 11, 12, 13, 14, 14])
+    from sympy.abc import i, j, k, l, m, n
+    f = Matrix(3, 3, [i, l, m, 0, j, n, 0, 0, k])
+    g = Matrix(3, 3, [i, 0, 0, l, j, 0, m, n, k])
+    h = Matrix(3, 3, [x**3, 0, 0, i, x**-1, 0, j, k, x**-2])
+    # the method keyword for `det` doesn't kick in until 4x4 matrices,
+    # so there is no need to test all methods on smaller ones
+
+    assert a.det() == 1
+    assert b.det() == 5
+    assert c.det() == -2
+    assert d.det() == 3
+    assert e.det() == 4*x - 24
+    assert e.det(method="domain-ge") == 4*x - 24
+    assert e.det(method='bareiss') == 4*x - 24
+    assert e.det(method='berkowitz') == 4*x - 24
+    assert f.det() == i*j*k
+    assert g.det() == i*j*k
+    assert h.det() == 1
+    raises(ValueError, lambda: e.det(iszerofunc="test"))
+
+def test_permanent():
+    M = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    assert M.per() == 450
+    for i in range(1, 12):
+        assert ones(i, i).per() == ones(i, i).T.per() == factorial(i)
+        assert (ones(i, i)-eye(i)).per() == (ones(i, i)-eye(i)).T.per() == subfactorial(i)
+
+    a1, a2, a3, a4, a5 = symbols('a_1 a_2 a_3 a_4 a_5')
+    M = Matrix([a1, a2, a3, a4, a5])
+    assert M.per() == M.T.per() == a1 + a2 + a3 + a4 + a5
+
+def test_adjugate():
+    x = Symbol('x')
+    e = Matrix(4, 4,
+        [x, 1, 2, 3, 4, 5, 6, 7, 2, 9, 10, 11, 12, 13, 14, 14])
+
+    adj = Matrix([
+        [   4,         -8,         4,         0],
+        [  76, -14*x - 68,  14*x - 8, -4*x + 24],
+        [-122, 17*x + 142, -21*x + 4,  8*x - 48],
+        [  48,  -4*x - 72,       8*x, -4*x + 24]])
+    assert e.adjugate() == adj
+    assert e.adjugate(method='bareiss') == adj
+    assert e.adjugate(method='berkowitz') == adj
+
+    a = Matrix(2, 3, [1, 2, 3, 4, 5, 6])
+    raises(NonSquareMatrixError, lambda: a.adjugate())
+
+def test_util():
+    R = Rational
+
+    v1 = Matrix(1, 3, [1, 2, 3])
+    v2 = Matrix(1, 3, [3, 4, 5])
+    assert v1.norm() == sqrt(14)
+    assert v1.project(v2) == Matrix(1, 3, [R(39)/25, R(52)/25, R(13)/5])
+    assert Matrix.zeros(1, 2) == Matrix(1, 2, [0, 0])
+    assert ones(1, 2) == Matrix(1, 2, [1, 1])
+    assert v1.copy() == v1
+    # cofactor
+    assert eye(3) == eye(3).cofactor_matrix()
+    test = Matrix([[1, 3, 2], [2, 6, 3], [2, 3, 6]])
+    assert test.cofactor_matrix() == \
+        Matrix([[27, -6, -6], [-12, 2, 3], [-3, 1, 0]])
+    test = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    assert test.cofactor_matrix() == \
+        Matrix([[-3, 6, -3], [6, -12, 6], [-3, 6, -3]])
+
+def test_cofactor_and_minors():
+    x = Symbol('x')
+    e = Matrix(4, 4,
+        [x, 1, 2, 3, 4, 5, 6, 7, 2, 9, 10, 11, 12, 13, 14, 14])
+
+    m = Matrix([
+        [ x,  1,  3],
+        [ 2,  9, 11],
+        [12, 13, 14]])
+    cm = Matrix([
+        [ 4,         76,       -122,        48],
+        [-8, -14*x - 68, 17*x + 142, -4*x - 72],
+        [ 4,   14*x - 8,  -21*x + 4,       8*x],
+        [ 0,  -4*x + 24,   8*x - 48, -4*x + 24]])
+    sub = Matrix([
+            [x, 1,  2],
+            [4, 5,  6],
+            [2, 9, 10]])
+
+    assert e.minor_submatrix(1, 2) == m
+    assert e.minor_submatrix(-1, -1) == sub
+    assert e.minor(1, 2) == -17*x - 142
+    assert e.cofactor(1, 2) == 17*x + 142
+    assert e.cofactor_matrix() == cm
+    assert e.cofactor_matrix(method="bareiss") == cm
+    assert e.cofactor_matrix(method="berkowitz") == cm
+
+    raises(ValueError, lambda: e.cofactor(4, 5))
+    raises(ValueError, lambda: e.minor(4, 5))
+    raises(ValueError, lambda: e.minor_submatrix(4, 5))
+
+    a = Matrix(2, 3, [1, 2, 3, 4, 5, 6])
+    assert a.minor_submatrix(0, 0) == Matrix([[5, 6]])
+
+    raises(ValueError, lambda:
+        Matrix(0, 0, []).minor_submatrix(0, 0))
+    raises(NonSquareMatrixError, lambda: a.cofactor(0, 0))
+    raises(NonSquareMatrixError, lambda: a.minor(0, 0))
+    raises(NonSquareMatrixError, lambda: a.cofactor_matrix())
+
+def test_charpoly():
+    x, y = Symbol('x'), Symbol('y')
+    z, t = Symbol('z'), Symbol('t')
+
+    from sympy.abc import a,b,c
+
+    m = Matrix(3, 3, [1, 2, 3, 4, 5, 6, 7, 8, 9])
+
+    assert eye_Determinant(3).charpoly(x) == Poly((x - 1)**3, x)
+    assert eye_Determinant(3).charpoly(y) == Poly((y - 1)**3, y)
+    assert m.charpoly() == Poly(x**3 - 15*x**2 - 18*x, x)
+    raises(NonSquareMatrixError, lambda: Matrix([[1], [2]]).charpoly())
+    n = Matrix(4, 4, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+    assert n.charpoly() == Poly(x**4, x)
+
+    n = Matrix(4, 4, [45, 0, 0, 0, 0, 23, 0, 0, 0, 0, 87, 0, 0, 0, 0, 12])
+    assert n.charpoly() == Poly(x**4 - 167*x**3 + 8811*x**2 - 173457*x + 1080540, x)
+
+    n = Matrix(3, 3, [x, 0, 0, a, y, 0, b, c, z])
+    assert n.charpoly() == Poly(t**3 - (x+y+z)*t**2 + t*(x*y+y*z+x*z) - x*y*z, t)

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

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

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

@@ -0,0 +1,356 @@
+"""Tools for manipulation of expressions using paths. """
+
+from sympy.core import Basic
+
+
+class EPath:
+    r"""
+    Manipulate expressions using paths.
+
+    EPath grammar in EBNF notation::
+
+        literal   ::= /[A-Za-z_][A-Za-z_0-9]*/
+        number    ::= /-?\d+/
+        type      ::= literal
+        attribute ::= literal "?"
+        all       ::= "*"
+        slice     ::= "[" number? (":" number? (":" number?)?)? "]"
+        range     ::= all | slice
+        query     ::= (type | attribute) ("|" (type | attribute))*
+        selector  ::= range | query range?
+        path      ::= "/" selector ("/" selector)*
+
+    See the docstring of the epath() function.
+
+    """
+
+    __slots__ = ("_path", "_epath")
+
+    def __new__(cls, path):
+        """Construct new EPath. """
+        if isinstance(path, EPath):
+            return path
+
+        if not path:
+            raise ValueError("empty EPath")
+
+        _path = path
+
+        if path[0] == '/':
+            path = path[1:]
+        else:
+            raise NotImplementedError("non-root EPath")
+
+        epath = []
+
+        for selector in path.split('/'):
+            selector = selector.strip()
+
+            if not selector:
+                raise ValueError("empty selector")
+
+            index = 0
+
+            for c in selector:
+                if c.isalnum() or c in ('_', '|', '?'):
+                    index += 1
+                else:
+                    break
+
+            attrs = []
+            types = []
+
+            if index:
+                elements = selector[:index]
+                selector = selector[index:]
+
+                for element in elements.split('|'):
+                    element = element.strip()
+
+                    if not element:
+                        raise ValueError("empty element")
+
+                    if element.endswith('?'):
+                        attrs.append(element[:-1])
+                    else:
+                        types.append(element)
+
+            span = None
+
+            if selector == '*':
+                pass
+            else:
+                if selector.startswith('['):
+                    try:
+                        i = selector.index(']')
+                    except ValueError:
+                        raise ValueError("expected ']', got EOL")
+
+                    _span, span = selector[1:i], []
+
+                    if ':' not in _span:
+                        span = int(_span)
+                    else:
+                        for elt in _span.split(':', 3):
+                            if not elt:
+                                span.append(None)
+                            else:
+                                span.append(int(elt))
+
+                        span = slice(*span)
+
+                    selector = selector[i + 1:]
+
+                if selector:
+                    raise ValueError("trailing characters in selector")
+
+            epath.append((attrs, types, span))
+
+        obj = object.__new__(cls)
+
+        obj._path = _path
+        obj._epath = epath
+
+        return obj
+
+    def __repr__(self):
+        return "%s(%r)" % (self.__class__.__name__, self._path)
+
+    def _get_ordered_args(self, expr):
+        """Sort ``expr.args`` using printing order. """
+        if expr.is_Add:
+            return expr.as_ordered_terms()
+        elif expr.is_Mul:
+            return expr.as_ordered_factors()
+        else:
+            return expr.args
+
+    def _hasattrs(self, expr, attrs):
+        """Check if ``expr`` has any of ``attrs``. """
+        for attr in attrs:
+            if not hasattr(expr, attr):
+                return False
+
+        return True
+
+    def _hastypes(self, expr, types):
+        """Check if ``expr`` is any of ``types``. """
+        _types = [ cls.__name__ for cls in expr.__class__.mro() ]
+        return bool(set(_types).intersection(types))
+
+    def _has(self, expr, attrs, types):
+        """Apply ``_hasattrs`` and ``_hastypes`` to ``expr``. """
+        if not (attrs or types):
+            return True
+
+        if attrs and self._hasattrs(expr, attrs):
+            return True
+
+        if types and self._hastypes(expr, types):
+            return True
+
+        return False
+
+    def apply(self, expr, func, args=None, kwargs=None):
+        """
+        Modify parts of an expression selected by a path.
+
+        Examples
+        ========
+
+        >>> from sympy.simplify.epathtools import EPath
+        >>> from sympy import sin, cos, E
+        >>> from sympy.abc import x, y, z, t
+
+        >>> path = EPath("/*/[0]/Symbol")
+        >>> expr = [((x, 1), 2), ((3, y), z)]
+
+        >>> path.apply(expr, lambda expr: expr**2)
+        [((x**2, 1), 2), ((3, y**2), z)]
+
+        >>> path = EPath("/*/*/Symbol")
+        >>> expr = t + sin(x + 1) + cos(x + y + E)
+
+        >>> path.apply(expr, lambda expr: 2*expr)
+        t + sin(2*x + 1) + cos(2*x + 2*y + E)
+
+        """
+        def _apply(path, expr, func):
+            if not path:
+                return func(expr)
+            else:
+                selector, path = path[0], path[1:]
+                attrs, types, span = selector
+
+                if isinstance(expr, Basic):
+                    if not expr.is_Atom:
+                        args, basic = self._get_ordered_args(expr), True
+                    else:
+                        return expr
+                elif hasattr(expr, '__iter__'):
+                    args, basic = expr, False
+                else:
+                    return expr
+
+                args = list(args)
+
+                if span is not None:
+                    if isinstance(span, slice):
+                        indices = range(*span.indices(len(args)))
+                    else:
+                        indices = [span]
+                else:
+                    indices = range(len(args))
+
+                for i in indices:
+                    try:
+                        arg = args[i]
+                    except IndexError:
+                        continue
+
+                    if self._has(arg, attrs, types):
+                        args[i] = _apply(path, arg, func)
+
+                if basic:
+                    return expr.func(*args)
+                else:
+                    return expr.__class__(args)
+
+        _args, _kwargs = args or (), kwargs or {}
+        _func = lambda expr: func(expr, *_args, **_kwargs)
+
+        return _apply(self._epath, expr, _func)
+
+    def select(self, expr):
+        """
+        Retrieve parts of an expression selected by a path.
+
+        Examples
+        ========
+
+        >>> from sympy.simplify.epathtools import EPath
+        >>> from sympy import sin, cos, E
+        >>> from sympy.abc import x, y, z, t
+
+        >>> path = EPath("/*/[0]/Symbol")
+        >>> expr = [((x, 1), 2), ((3, y), z)]
+
+        >>> path.select(expr)
+        [x, y]
+
+        >>> path = EPath("/*/*/Symbol")
+        >>> expr = t + sin(x + 1) + cos(x + y + E)
+
+        >>> path.select(expr)
+        [x, x, y]
+
+        """
+        result = []
+
+        def _select(path, expr):
+            if not path:
+                result.append(expr)
+            else:
+                selector, path = path[0], path[1:]
+                attrs, types, span = selector
+
+                if isinstance(expr, Basic):
+                    args = self._get_ordered_args(expr)
+                elif hasattr(expr, '__iter__'):
+                    args = expr
+                else:
+                    return
+
+                if span is not None:
+                    if isinstance(span, slice):
+                        args = args[span]
+                    else:
+                        try:
+                            args = [args[span]]
+                        except IndexError:
+                            return
+
+                for arg in args:
+                    if self._has(arg, attrs, types):
+                        _select(path, arg)
+
+        _select(self._epath, expr)
+        return result
+
+
+def epath(path, expr=None, func=None, args=None, kwargs=None):
+    r"""
+    Manipulate parts of an expression selected by a path.
+
+    Explanation
+    ===========
+
+    This function allows to manipulate large nested expressions in single
+    line of code, utilizing techniques to those applied in XML processing
+    standards (e.g. XPath).
+
+    If ``func`` is ``None``, :func:`epath` retrieves elements selected by
+    the ``path``. Otherwise it applies ``func`` to each matching element.
+
+    Note that it is more efficient to create an EPath object and use the select
+    and apply methods of that object, since this will compile the path string
+    only once.  This function should only be used as a convenient shortcut for
+    interactive use.
+
+    This is the supported syntax:
+
+    * select all: ``/*``
+          Equivalent of ``for arg in args:``.
+    * select slice: ``/[0]`` or ``/[1:5]`` or ``/[1:5:2]``
+          Supports standard Python's slice syntax.
+    * select by type: ``/list`` or ``/list|tuple``
+          Emulates ``isinstance()``.
+    * select by attribute: ``/__iter__?``
+          Emulates ``hasattr()``.
+
+    Parameters
+    ==========
+
+    path : str | EPath
+        A path as a string or a compiled EPath.
+    expr : Basic | iterable
+        An expression or a container of expressions.
+    func : callable (optional)
+        A callable that will be applied to matching parts.
+    args : tuple (optional)
+        Additional positional arguments to ``func``.
+    kwargs : dict (optional)
+        Additional keyword arguments to ``func``.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.epathtools import epath
+    >>> from sympy import sin, cos, E
+    >>> from sympy.abc import x, y, z, t
+
+    >>> path = "/*/[0]/Symbol"
+    >>> expr = [((x, 1), 2), ((3, y), z)]
+
+    >>> epath(path, expr)
+    [x, y]
+    >>> epath(path, expr, lambda expr: expr**2)
+    [((x**2, 1), 2), ((3, y**2), z)]
+
+    >>> path = "/*/*/Symbol"
+    >>> expr = t + sin(x + 1) + cos(x + y + E)
+
+    >>> epath(path, expr)
+    [x, x, y]
+    >>> epath(path, expr, lambda expr: 2*expr)
+    t + sin(2*x + 1) + cos(2*x + 2*y + E)
+
+    """
+    _epath = EPath(path)
+
+    if expr is None:
+        return _epath
+    if func is None:
+        return _epath.select(expr)
+    else:
+        return _epath.apply(expr, func, args, kwargs)

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

@@ -0,0 +1,714 @@
+from collections import defaultdict
+from functools import reduce
+from math import prod
+
+from sympy.core.function import expand_log, count_ops, _coeff_isneg
+from sympy.core import sympify, Basic, Dummy, S, Add, Mul, Pow, expand_mul, factor_terms
+from sympy.core.sorting import ordered, default_sort_key
+from sympy.core.numbers import Integer, Rational
+from sympy.core.mul import _keep_coeff
+from sympy.core.rules import Transform
+from sympy.functions import exp_polar, exp, log, root, polarify, unpolarify
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.polys import lcm, gcd
+from sympy.ntheory.factor_ import multiplicity
+
+
+
+def powsimp(expr, deep=False, combine='all', force=False, measure=count_ops):
+    """
+    Reduce expression by combining powers with similar bases and exponents.
+
+    Explanation
+    ===========
+
+    If ``deep`` is ``True`` then powsimp() will also simplify arguments of
+    functions. By default ``deep`` is set to ``False``.
+
+    If ``force`` is ``True`` then bases will be combined without checking for
+    assumptions, e.g. sqrt(x)*sqrt(y) -> sqrt(x*y) which is not true
+    if x and y are both negative.
+
+    You can make powsimp() only combine bases or only combine exponents by
+    changing combine='base' or combine='exp'.  By default, combine='all',
+    which does both.  combine='base' will only combine::
+
+         a   a          a                          2x      x
+        x * y  =>  (x*y)   as well as things like 2   =>  4
+
+    and combine='exp' will only combine
+    ::
+
+         a   b      (a + b)
+        x * x  =>  x
+
+    combine='exp' will strictly only combine exponents in the way that used
+    to be automatic.  Also use deep=True if you need the old behavior.
+
+    When combine='all', 'exp' is evaluated first.  Consider the first
+    example below for when there could be an ambiguity relating to this.
+    This is done so things like the second example can be completely
+    combined.  If you want 'base' combined first, do something like
+    powsimp(powsimp(expr, combine='base'), combine='exp').
+
+    Examples
+    ========
+
+    >>> from sympy import powsimp, exp, log, symbols
+    >>> from sympy.abc import x, y, z, n
+    >>> powsimp(x**y*x**z*y**z, combine='all')
+    x**(y + z)*y**z
+    >>> powsimp(x**y*x**z*y**z, combine='exp')
+    x**(y + z)*y**z
+    >>> powsimp(x**y*x**z*y**z, combine='base', force=True)
+    x**y*(x*y)**z
+
+    >>> powsimp(x**z*x**y*n**z*n**y, combine='all', force=True)
+    (n*x)**(y + z)
+    >>> powsimp(x**z*x**y*n**z*n**y, combine='exp')
+    n**(y + z)*x**(y + z)
+    >>> powsimp(x**z*x**y*n**z*n**y, combine='base', force=True)
+    (n*x)**y*(n*x)**z
+
+    >>> x, y = symbols('x y', positive=True)
+    >>> powsimp(log(exp(x)*exp(y)))
+    log(exp(x)*exp(y))
+    >>> powsimp(log(exp(x)*exp(y)), deep=True)
+    x + y
+
+    Radicals with Mul bases will be combined if combine='exp'
+
+    >>> from sympy import sqrt
+    >>> x, y = symbols('x y')
+
+    Two radicals are automatically joined through Mul:
+
+    >>> a=sqrt(x*sqrt(y))
+    >>> a*a**3 == a**4
+    True
+
+    But if an integer power of that radical has been
+    autoexpanded then Mul does not join the resulting factors:
+
+    >>> a**4 # auto expands to a Mul, no longer a Pow
+    x**2*y
+    >>> _*a # so Mul doesn't combine them
+    x**2*y*sqrt(x*sqrt(y))
+    >>> powsimp(_) # but powsimp will
+    (x*sqrt(y))**(5/2)
+    >>> powsimp(x*y*a) # but won't when doing so would violate assumptions
+    x*y*sqrt(x*sqrt(y))
+
+    """
+    def recurse(arg, **kwargs):
+        _deep = kwargs.get('deep', deep)
+        _combine = kwargs.get('combine', combine)
+        _force = kwargs.get('force', force)
+        _measure = kwargs.get('measure', measure)
+        return powsimp(arg, _deep, _combine, _force, _measure)
+
+    expr = sympify(expr)
+
+    if (not isinstance(expr, Basic) or isinstance(expr, MatrixSymbol) or (
+            expr.is_Atom or expr in (exp_polar(0), exp_polar(1)))):
+        return expr
+
+    if deep or expr.is_Add or expr.is_Mul and _y not in expr.args:
+        expr = expr.func(*[recurse(w) for w in expr.args])
+
+    if expr.is_Pow:
+        return recurse(expr*_y, deep=False)/_y
+
+    if not expr.is_Mul:
+        return expr
+
+    # handle the Mul
+    if combine in ('exp', 'all'):
+        # Collect base/exp data, while maintaining order in the
+        # non-commutative parts of the product
+        c_powers = defaultdict(list)
+        nc_part = []
+        newexpr = []
+        coeff = S.One
+        for term in expr.args:
+            if term.is_Rational:
+                coeff *= term
+                continue
+            if term.is_Pow:
+                term = _denest_pow(term)
+            if term.is_commutative:
+                b, e = term.as_base_exp()
+                if deep:
+                    b, e = [recurse(i) for i in [b, e]]
+                if b.is_Pow or isinstance(b, exp):
+                    # don't let smthg like sqrt(x**a) split into x**a, 1/2
+                    # or else it will be joined as x**(a/2) later
+                    b, e = b**e, S.One
+                c_powers[b].append(e)
+            else:
+                # This is the logic that combines exponents for equal,
+                # but non-commutative bases: A**x*A**y == A**(x+y).
+                if nc_part:
+                    b1, e1 = nc_part[-1].as_base_exp()
+                    b2, e2 = term.as_base_exp()
+                    if (b1 == b2 and
+                            e1.is_commutative and e2.is_commutative):
+                        nc_part[-1] = Pow(b1, Add(e1, e2))
+                        continue
+                nc_part.append(term)
+
+        # add up exponents of common bases
+        for b, e in ordered(iter(c_powers.items())):
+            # allow 2**x/4 -> 2**(x - 2); don't do this when b and e are
+            # Numbers since autoevaluation will undo it, e.g.
+            # 2**(1/3)/4 -> 2**(1/3 - 2) -> 2**(1/3)/4
+            if (b and b.is_Rational and not all(ei.is_Number for ei in e) and \
+                    coeff is not S.One and
+                    b not in (S.One, S.NegativeOne)):
+                m = multiplicity(abs(b), abs(coeff))
+                if m:
+                    e.append(m)
+                    coeff /= b**m
+            c_powers[b] = Add(*e)
+        if coeff is not S.One:
+            if coeff in c_powers:
+                c_powers[coeff] += S.One
+            else:
+                c_powers[coeff] = S.One
+
+        # convert to plain dictionary
+        c_powers = dict(c_powers)
+
+        # check for base and inverted base pairs
+        be = list(c_powers.items())
+        skip = set()  # skip if we already saw them
+        for b, e in be:
+            if b in skip:
+                continue
+            bpos = b.is_positive or b.is_polar
+            if bpos:
+                binv = 1/b
+                if b != binv and binv in c_powers:
+                    if b.as_numer_denom()[0] is S.One:
+                        c_powers.pop(b)
+                        c_powers[binv] -= e
+                    else:
+                        skip.add(binv)
+                        e = c_powers.pop(binv)
+                        c_powers[b] -= e
+
+        # check for base and negated base pairs
+        be = list(c_powers.items())
+        _n = S.NegativeOne
+        for b, e in be:
+            if (b.is_Symbol or b.is_Add) and -b in c_powers and b in c_powers:
+                if (b.is_positive is not None or e.is_integer):
+                    if e.is_integer or b.is_negative:
+                        c_powers[-b] += c_powers.pop(b)
+                    else:  # (-b).is_positive so use its e
+                        e = c_powers.pop(-b)
+                        c_powers[b] += e
+                    if _n in c_powers:
+                        c_powers[_n] += e
+                    else:
+                        c_powers[_n] = e
+
+        # filter c_powers and convert to a list
+        c_powers = [(b, e) for b, e in c_powers.items() if e]
+
+        # ==============================================================
+        # check for Mul bases of Rational powers that can be combined with
+        # separated bases, e.g. x*sqrt(x*y)*sqrt(x*sqrt(x*y)) ->
+        # (x*sqrt(x*y))**(3/2)
+        # ---------------- helper functions
+
+        def ratq(x):
+            '''Return Rational part of x's exponent as it appears in the bkey.
+            '''
+            return bkey(x)[0][1]
+
+        def bkey(b, e=None):
+            '''Return (b**s, c.q), c.p where e -> c*s. If e is not given then
+            it will be taken by using as_base_exp() on the input b.
+            e.g.
+                x**3/2 -> (x, 2), 3
+                x**y -> (x**y, 1), 1
+                x**(2*y/3) -> (x**y, 3), 2
+                exp(x/2) -> (exp(a), 2), 1
+
+            '''
+            if e is not None:  # coming from c_powers or from below
+                if e.is_Integer:
+                    return (b, S.One), e
+                elif e.is_Rational:
+                    return (b, Integer(e.q)), Integer(e.p)
+                else:
+                    c, m = e.as_coeff_Mul(rational=True)
+                    if c is not S.One:
+                        if m.is_integer:
+                            return (b, Integer(c.q)), m*Integer(c.p)
+                        return (b**m, Integer(c.q)), Integer(c.p)
+                    else:
+                        return (b**e, S.One), S.One
+            else:
+                return bkey(*b.as_base_exp())
+
+        def update(b):
+            '''Decide what to do with base, b. If its exponent is now an
+            integer multiple of the Rational denominator, then remove it
+            and put the factors of its base in the common_b dictionary or
+            update the existing bases if necessary. If it has been zeroed
+            out, simply remove the base.
+            '''
+            newe, r = divmod(common_b[b], b[1])
+            if not r:
+                common_b.pop(b)
+                if newe:
+                    for m in Mul.make_args(b[0]**newe):
+                        b, e = bkey(m)
+                        if b not in common_b:
+                            common_b[b] = 0
+                        common_b[b] += e
+                        if b[1] != 1:
+                            bases.append(b)
+        # ---------------- end of helper functions
+
+        # assemble a dictionary of the factors having a Rational power
+        common_b = {}
+        done = []
+        bases = []
+        for b, e in c_powers:
+            b, e = bkey(b, e)
+            if b in common_b:
+                common_b[b] = common_b[b] + e
+            else:
+                common_b[b] = e
+            if b[1] != 1 and b[0].is_Mul:
+                bases.append(b)
+        bases.sort(key=default_sort_key)  # this makes tie-breaking canonical
+        bases.sort(key=measure, reverse=True)  # handle longest first
+        for base in bases:
+            if base not in common_b:  # it may have been removed already
+                continue
+            b, exponent = base
+            last = False  # True when no factor of base is a radical
+            qlcm = 1  # the lcm of the radical denominators
+            while True:
+                bstart = b
+                qstart = qlcm
+
+                bb = []  # list of factors
+                ee = []  # (factor's expo. and it's current value in common_b)
+                for bi in Mul.make_args(b):
+                    bib, bie = bkey(bi)
+                    if bib not in common_b or common_b[bib] < bie:
+                        ee = bb = []  # failed
+                        break
+                    ee.append([bie, common_b[bib]])
+                    bb.append(bib)
+                if ee:
+                    # find the number of integral extractions possible
+                    # e.g. [(1, 2), (2, 2)] -> min(2/1, 2/2) -> 1
+                    min1 = ee[0][1]//ee[0][0]
+                    for i in range(1, len(ee)):
+                        rat = ee[i][1]//ee[i][0]
+                        if rat < 1:
+                            break
+                        min1 = min(min1, rat)
+                    else:
+                        # update base factor counts
+                        # e.g. if ee = [(2, 5), (3, 6)] then min1 = 2
+                        # and the new base counts will be 5-2*2 and 6-2*3
+                        for i in range(len(bb)):
+                            common_b[bb[i]] -= min1*ee[i][0]
+                            update(bb[i])
+                        # update the count of the base
+                        # e.g. x**2*y*sqrt(x*sqrt(y)) the count of x*sqrt(y)
+                        # will increase by 4 to give bkey (x*sqrt(y), 2, 5)
+                        common_b[base] += min1*qstart*exponent
+                if (last  # no more radicals in base
+                    or len(common_b) == 1  # nothing left to join with
+                    or all(k[1] == 1 for k in common_b)  # no rad's in common_b
+                        ):
+                    break
+                # see what we can exponentiate base by to remove any radicals
+                # so we know what to search for
+                # e.g. if base were x**(1/2)*y**(1/3) then we should
+                # exponentiate by 6 and look for powers of x and y in the ratio
+                # of 2 to 3
+                qlcm = lcm([ratq(bi) for bi in Mul.make_args(bstart)])
+                if qlcm == 1:
+                    break  # we are done
+                b = bstart**qlcm
+                qlcm *= qstart
+                if all(ratq(bi) == 1 for bi in Mul.make_args(b)):
+                    last = True  # we are going to be done after this next pass
+            # this base no longer can find anything to join with and
+            # since it was longer than any other we are done with it
+            b, q = base
+            done.append((b, common_b.pop(base)*Rational(1, q)))
+
+        # update c_powers and get ready to continue with powsimp
+        c_powers = done
+        # there may be terms still in common_b that were bases that were
+        # identified as needing processing, so remove those, too
+        for (b, q), e in common_b.items():
+            if (b.is_Pow or isinstance(b, exp)) and \
+                    q is not S.One and not b.exp.is_Rational:
+                b, be = b.as_base_exp()
+                b = b**(be/q)
+            else:
+                b = root(b, q)
+            c_powers.append((b, e))
+        check = len(c_powers)
+        c_powers = dict(c_powers)
+        assert len(c_powers) == check  # there should have been no duplicates
+        # ==============================================================
+
+        # rebuild the expression
+        newexpr = expr.func(*(newexpr + [Pow(b, e) for b, e in c_powers.items()]))
+        if combine == 'exp':
+            return expr.func(newexpr, expr.func(*nc_part))
+        else:
+            return recurse(expr.func(*nc_part), combine='base') * \
+                recurse(newexpr, combine='base')
+
+    elif combine == 'base':
+
+        # Build c_powers and nc_part.  These must both be lists not
+        # dicts because exp's are not combined.
+        c_powers = []
+        nc_part = []
+        for term in expr.args:
+            if term.is_commutative:
+                c_powers.append(list(term.as_base_exp()))
+            else:
+                nc_part.append(term)
+
+        # Pull out numerical coefficients from exponent if assumptions allow
+        # e.g., 2**(2*x) => 4**x
+        for i in range(len(c_powers)):
+            b, e = c_powers[i]
+            if not (all(x.is_nonnegative for x in b.as_numer_denom()) or e.is_integer or force or b.is_polar):
+                continue
+            exp_c, exp_t = e.as_coeff_Mul(rational=True)
+            if exp_c is not S.One and exp_t is not S.One:
+                c_powers[i] = [Pow(b, exp_c), exp_t]
+
+        # Combine bases whenever they have the same exponent and
+        # assumptions allow
+        # first gather the potential bases under the common exponent
+        c_exp = defaultdict(list)
+        for b, e in c_powers:
+            if deep:
+                e = recurse(e)
+            if e.is_Add and (b.is_positive or e.is_integer):
+                e = factor_terms(e)
+                if _coeff_isneg(e):
+                    e = -e
+                    b = 1/b
+            c_exp[e].append(b)
+        del c_powers
+
+        # Merge back in the results of the above to form a new product
+        c_powers = defaultdict(list)
+        for e in c_exp:
+            bases = c_exp[e]
+
+            # calculate the new base for e
+
+            if len(bases) == 1:
+                new_base = bases[0]
+            elif e.is_integer or force:
+                new_base = expr.func(*bases)
+            else:
+                # see which ones can be joined
+                unk = []
+                nonneg = []
+                neg = []
+                for bi in bases:
+                    if bi.is_negative:
+                        neg.append(bi)
+                    elif bi.is_nonnegative:
+                        nonneg.append(bi)
+                    elif bi.is_polar:
+                        nonneg.append(
+                            bi)  # polar can be treated like non-negative
+                    else:
+                        unk.append(bi)
+                if len(unk) == 1 and not neg or len(neg) == 1 and not unk:
+                    # a single neg or a single unk can join the rest
+                    nonneg.extend(unk + neg)
+                    unk = neg = []
+                elif neg:
+                    # their negative signs cancel in groups of 2*q if we know
+                    # that e = p/q else we have to treat them as unknown
+                    israt = False
+                    if e.is_Rational:
+                        israt = True
+                    else:
+                        p, d = e.as_numer_denom()
+                        if p.is_integer and d.is_integer:
+                            israt = True
+                    if israt:
+                        neg = [-w for w in neg]
+                        unk.extend([S.NegativeOne]*len(neg))
+                    else:
+                        unk.extend(neg)
+                        neg = []
+                    del israt
+
+                # these shouldn't be joined
+                for b in unk:
+                    c_powers[b].append(e)
+                # here is a new joined base
+                new_base = expr.func(*(nonneg + neg))
+                # if there are positive parts they will just get separated
+                # again unless some change is made
+
+                def _terms(e):
+                    # return the number of terms of this expression
+                    # when multiplied out -- assuming no joining of terms
+                    if e.is_Add:
+                        return sum([_terms(ai) for ai in e.args])
+                    if e.is_Mul:
+                        return prod([_terms(mi) for mi in e.args])
+                    return 1
+                xnew_base = expand_mul(new_base, deep=False)
+                if len(Add.make_args(xnew_base)) < _terms(new_base):
+                    new_base = factor_terms(xnew_base)
+
+            c_powers[new_base].append(e)
+
+        # break out the powers from c_powers now
+        c_part = [Pow(b, ei) for b, e in c_powers.items() for ei in e]
+
+        # we're done
+        return expr.func(*(c_part + nc_part))
+
+    else:
+        raise ValueError("combine must be one of ('all', 'exp', 'base').")
+
+
+def powdenest(eq, force=False, polar=False):
+    r"""
+    Collect exponents on powers as assumptions allow.
+
+    Explanation
+    ===========
+
+    Given ``(bb**be)**e``, this can be simplified as follows:
+        * if ``bb`` is positive, or
+        * ``e`` is an integer, or
+        * ``|be| < 1`` then this simplifies to ``bb**(be*e)``
+
+    Given a product of powers raised to a power, ``(bb1**be1 *
+    bb2**be2...)**e``, simplification can be done as follows:
+
+    - if e is positive, the gcd of all bei can be joined with e;
+    - all non-negative bb can be separated from those that are negative
+      and their gcd can be joined with e; autosimplification already
+      handles this separation.
+    - integer factors from powers that have integers in the denominator
+      of the exponent can be removed from any term and the gcd of such
+      integers can be joined with e
+
+    Setting ``force`` to ``True`` will make symbols that are not explicitly
+    negative behave as though they are positive, resulting in more
+    denesting.
+
+    Setting ``polar`` to ``True`` will do simplifications on the Riemann surface of
+    the logarithm, also resulting in more denestings.
+
+    When there are sums of logs in exp() then a product of powers may be
+    obtained e.g. ``exp(3*(log(a) + 2*log(b)))`` - > ``a**3*b**6``.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import a, b, x, y, z
+    >>> from sympy import Symbol, exp, log, sqrt, symbols, powdenest
+
+    >>> powdenest((x**(2*a/3))**(3*x))
+    (x**(2*a/3))**(3*x)
+    >>> powdenest(exp(3*x*log(2)))
+    2**(3*x)
+
+    Assumptions may prevent expansion:
+
+    >>> powdenest(sqrt(x**2))
+    sqrt(x**2)
+
+    >>> p = symbols('p', positive=True)
+    >>> powdenest(sqrt(p**2))
+    p
+
+    No other expansion is done.
+
+    >>> i, j = symbols('i,j', integer=True)
+    >>> powdenest((x**x)**(i + j)) # -X-> (x**x)**i*(x**x)**j
+    x**(x*(i + j))
+
+    But exp() will be denested by moving all non-log terms outside of
+    the function; this may result in the collapsing of the exp to a power
+    with a different base:
+
+    >>> powdenest(exp(3*y*log(x)))
+    x**(3*y)
+    >>> powdenest(exp(y*(log(a) + log(b))))
+    (a*b)**y
+    >>> powdenest(exp(3*(log(a) + log(b))))
+    a**3*b**3
+
+    If assumptions allow, symbols can also be moved to the outermost exponent:
+
+    >>> i = Symbol('i', integer=True)
+    >>> powdenest(((x**(2*i))**(3*y))**x)
+    ((x**(2*i))**(3*y))**x
+    >>> powdenest(((x**(2*i))**(3*y))**x, force=True)
+    x**(6*i*x*y)
+
+    >>> powdenest(((x**(2*a/3))**(3*y/i))**x)
+    ((x**(2*a/3))**(3*y/i))**x
+    >>> powdenest((x**(2*i)*y**(4*i))**z, force=True)
+    (x*y**2)**(2*i*z)
+
+    >>> n = Symbol('n', negative=True)
+
+    >>> powdenest((x**i)**y, force=True)
+    x**(i*y)
+    >>> powdenest((n**i)**x, force=True)
+    (n**i)**x
+
+    """
+    from sympy.simplify.simplify import posify
+
+    if force:
+        def _denest(b, e):
+            if not isinstance(b, (Pow, exp)):
+                return b.is_positive, Pow(b, e, evaluate=False)
+            return _denest(b.base, b.exp*e)
+        reps = []
+        for p in eq.atoms(Pow, exp):
+            if isinstance(p.base, (Pow, exp)):
+                ok, dp = _denest(*p.args)
+                if ok is not False:
+                    reps.append((p, dp))
+        if reps:
+            eq = eq.subs(reps)
+        eq, reps = posify(eq)
+        return powdenest(eq, force=False, polar=polar).xreplace(reps)
+
+    if polar:
+        eq, rep = polarify(eq)
+        return unpolarify(powdenest(unpolarify(eq, exponents_only=True)), rep)
+
+    new = powsimp(eq)
+    return new.xreplace(Transform(
+        _denest_pow, filter=lambda m: m.is_Pow or isinstance(m, exp)))
+
+_y = Dummy('y')
+
+
+def _denest_pow(eq):
+    """
+    Denest powers.
+
+    This is a helper function for powdenest that performs the actual
+    transformation.
+    """
+    from sympy.simplify.simplify import logcombine
+
+    b, e = eq.as_base_exp()
+    if b.is_Pow or isinstance(b, exp) and e != 1:
+        new = b._eval_power(e)
+        if new is not None:
+            eq = new
+            b, e = new.as_base_exp()
+
+    # denest exp with log terms in exponent
+    if b is S.Exp1 and e.is_Mul:
+        logs = []
+        other = []
+        for ei in e.args:
+            if any(isinstance(ai, log) for ai in Add.make_args(ei)):
+                logs.append(ei)
+            else:
+                other.append(ei)
+        logs = logcombine(Mul(*logs))
+        return Pow(exp(logs), Mul(*other))
+
+    _, be = b.as_base_exp()
+    if be is S.One and not (b.is_Mul or
+                            b.is_Rational and b.q != 1 or
+                            b.is_positive):
+        return eq
+
+    # denest eq which is either pos**e or Pow**e or Mul**e or
+    # Mul(b1**e1, b2**e2)
+
+    # handle polar numbers specially
+    polars, nonpolars = [], []
+    for bb in Mul.make_args(b):
+        if bb.is_polar:
+            polars.append(bb.as_base_exp())
+        else:
+            nonpolars.append(bb)
+    if len(polars) == 1 and not polars[0][0].is_Mul:
+        return Pow(polars[0][0], polars[0][1]*e)*powdenest(Mul(*nonpolars)**e)
+    elif polars:
+        return Mul(*[powdenest(bb**(ee*e)) for (bb, ee) in polars]) \
+            *powdenest(Mul(*nonpolars)**e)
+
+    if b.is_Integer:
+        # use log to see if there is a power here
+        logb = expand_log(log(b))
+        if logb.is_Mul:
+            c, logb = logb.args
+            e *= c
+            base = logb.args[0]
+            return Pow(base, e)
+
+    # if b is not a Mul or any factor is an atom then there is nothing to do
+    if not b.is_Mul or any(s.is_Atom for s in Mul.make_args(b)):
+        return eq
+
+    # let log handle the case of the base of the argument being a Mul, e.g.
+    # sqrt(x**(2*i)*y**(6*i)) -> x**i*y**(3**i) if x and y are positive; we
+    # will take the log, expand it, and then factor out the common powers that
+    # now appear as coefficient. We do this manually since terms_gcd pulls out
+    # fractions, terms_gcd(x+x*y/2) -> x*(y + 2)/2 and we don't want the 1/2;
+    # gcd won't pull out numerators from a fraction: gcd(3*x, 9*x/2) -> x but
+    # we want 3*x. Neither work with noncommutatives.
+
+    def nc_gcd(aa, bb):
+        a, b = [i.as_coeff_Mul() for i in [aa, bb]]
+        c = gcd(a[0], b[0]).as_numer_denom()[0]
+        g = Mul(*(a[1].args_cnc(cset=True)[0] & b[1].args_cnc(cset=True)[0]))
+        return _keep_coeff(c, g)
+
+    glogb = expand_log(log(b))
+    if glogb.is_Add:
+        args = glogb.args
+        g = reduce(nc_gcd, args)
+        if g != 1:
+            cg, rg = g.as_coeff_Mul()
+            glogb = _keep_coeff(cg, rg*Add(*[a/g for a in args]))
+
+    # now put the log back together again
+    if isinstance(glogb, log) or not glogb.is_Mul:
+        if glogb.args[0].is_Pow or isinstance(glogb.args[0], exp):
+            glogb = _denest_pow(glogb.args[0])
+            if (abs(glogb.exp) < 1) == True:
+                return Pow(glogb.base, glogb.exp*e)
+        return eq
+
+    # the log(b) was a Mul so join any adds with logcombine
+    add = []
+    other = []
+    for a in glogb.args:
+        if a.is_Add:
+            add.append(a)
+        else:
+            other.append(a)
+    return Pow(exp(logcombine(Mul(*add))), e*Mul(*other))

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

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

@@ -0,0 +1,679 @@
+from sympy.core import Add, Expr, Mul, S, sympify
+from sympy.core.function import _mexpand, count_ops, expand_mul
+from sympy.core.sorting import default_sort_key
+from sympy.core.symbol import Dummy
+from sympy.functions import root, sign, sqrt
+from sympy.polys import Poly, PolynomialError
+
+
+def is_sqrt(expr):
+    """Return True if expr is a sqrt, otherwise False."""
+
+    return expr.is_Pow and expr.exp.is_Rational and abs(expr.exp) is S.Half
+
+
+def sqrt_depth(p):
+    """Return the maximum depth of any square root argument of p.
+
+    >>> from sympy.functions.elementary.miscellaneous import sqrt
+    >>> from sympy.simplify.sqrtdenest import sqrt_depth
+
+    Neither of these square roots contains any other square roots
+    so the depth is 1:
+
+    >>> sqrt_depth(1 + sqrt(2)*(1 + sqrt(3)))
+    1
+
+    The sqrt(3) is contained within a square root so the depth is
+    2:
+
+    >>> sqrt_depth(1 + sqrt(2)*sqrt(1 + sqrt(3)))
+    2
+    """
+    if p is S.ImaginaryUnit:
+        return 1
+    if p.is_Atom:
+        return 0
+    elif p.is_Add or p.is_Mul:
+        return max([sqrt_depth(x) for x in p.args], key=default_sort_key)
+    elif is_sqrt(p):
+        return sqrt_depth(p.base) + 1
+    else:
+        return 0
+
+
+def is_algebraic(p):
+    """Return True if p is comprised of only Rationals or square roots
+    of Rationals and algebraic operations.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.elementary.miscellaneous import sqrt
+    >>> from sympy.simplify.sqrtdenest import is_algebraic
+    >>> from sympy import cos
+    >>> is_algebraic(sqrt(2)*(3/(sqrt(7) + sqrt(5)*sqrt(2))))
+    True
+    >>> is_algebraic(sqrt(2)*(3/(sqrt(7) + sqrt(5)*cos(2))))
+    False
+    """
+
+    if p.is_Rational:
+        return True
+    elif p.is_Atom:
+        return False
+    elif is_sqrt(p) or p.is_Pow and p.exp.is_Integer:
+        return is_algebraic(p.base)
+    elif p.is_Add or p.is_Mul:
+        return all(is_algebraic(x) for x in p.args)
+    else:
+        return False
+
+
+def _subsets(n):
+    """
+    Returns all possible subsets of the set (0, 1, ..., n-1) except the
+    empty set, listed in reversed lexicographical order according to binary
+    representation, so that the case of the fourth root is treated last.
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.sqrtdenest import _subsets
+    >>> _subsets(2)
+    [[1, 0], [0, 1], [1, 1]]
+
+    """
+    if n == 1:
+        a = [[1]]
+    elif n == 2:
+        a = [[1, 0], [0, 1], [1, 1]]
+    elif n == 3:
+        a = [[1, 0, 0], [0, 1, 0], [1, 1, 0],
+             [0, 0, 1], [1, 0, 1], [0, 1, 1], [1, 1, 1]]
+    else:
+        b = _subsets(n - 1)
+        a0 = [x + [0] for x in b]
+        a1 = [x + [1] for x in b]
+        a = a0 + [[0]*(n - 1) + [1]] + a1
+    return a
+
+
+def sqrtdenest(expr, max_iter=3):
+    """Denests sqrts in an expression that contain other square roots
+    if possible, otherwise returns the expr unchanged. This is based on the
+    algorithms of [1].
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.sqrtdenest import sqrtdenest
+    >>> from sympy import sqrt
+    >>> sqrtdenest(sqrt(5 + 2 * sqrt(6)))
+    sqrt(2) + sqrt(3)
+
+    See Also
+    ========
+
+    sympy.solvers.solvers.unrad
+
+    References
+    ==========
+
+    .. [1] https://web.archive.org/web/20210806201615/https://researcher.watson.ibm.com/researcher/files/us-fagin/symb85.pdf
+
+    .. [2] D. J. Jeffrey and A. D. Rich, 'Symplifying Square Roots of Square Roots
+           by Denesting' (available at https://www.cybertester.com/data/denest.pdf)
+
+    """
+    expr = expand_mul(expr)
+    for i in range(max_iter):
+        z = _sqrtdenest0(expr)
+        if expr == z:
+            return expr
+        expr = z
+    return expr
+
+
+def _sqrt_match(p):
+    """Return [a, b, r] for p.match(a + b*sqrt(r)) where, in addition to
+    matching, sqrt(r) also has then maximal sqrt_depth among addends of p.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.elementary.miscellaneous import sqrt
+    >>> from sympy.simplify.sqrtdenest import _sqrt_match
+    >>> _sqrt_match(1 + sqrt(2) + sqrt(2)*sqrt(3) +  2*sqrt(1+sqrt(5)))
+    [1 + sqrt(2) + sqrt(6), 2, 1 + sqrt(5)]
+    """
+    from sympy.simplify.radsimp import split_surds
+
+    p = _mexpand(p)
+    if p.is_Number:
+        res = (p, S.Zero, S.Zero)
+    elif p.is_Add:
+        pargs = sorted(p.args, key=default_sort_key)
+        sqargs = [x**2 for x in pargs]
+        if all(sq.is_Rational and sq.is_positive for sq in sqargs):
+            r, b, a = split_surds(p)
+            res = a, b, r
+            return list(res)
+        # to make the process canonical, the argument is included in the tuple
+        # so when the max is selected, it will be the largest arg having a
+        # given depth
+        v = [(sqrt_depth(x), x, i) for i, x in enumerate(pargs)]
+        nmax = max(v, key=default_sort_key)
+        if nmax[0] == 0:
+            res = []
+        else:
+            # select r
+            depth, _, i = nmax
+            r = pargs.pop(i)
+            v.pop(i)
+            b = S.One
+            if r.is_Mul:
+                bv = []
+                rv = []
+                for x in r.args:
+                    if sqrt_depth(x) < depth:
+                        bv.append(x)
+                    else:
+                        rv.append(x)
+                b = Mul._from_args(bv)
+                r = Mul._from_args(rv)
+            # collect terms comtaining r
+            a1 = []
+            b1 = [b]
+            for x in v:
+                if x[0] < depth:
+                    a1.append(x[1])
+                else:
+                    x1 = x[1]
+                    if x1 == r:
+                        b1.append(1)
+                    else:
+                        if x1.is_Mul:
+                            x1args = list(x1.args)
+                            if r in x1args:
+                                x1args.remove(r)
+                                b1.append(Mul(*x1args))
+                            else:
+                                a1.append(x[1])
+                        else:
+                            a1.append(x[1])
+            a = Add(*a1)
+            b = Add(*b1)
+            res = (a, b, r**2)
+    else:
+        b, r = p.as_coeff_Mul()
+        if is_sqrt(r):
+            res = (S.Zero, b, r**2)
+        else:
+            res = []
+    return list(res)
+
+
+class SqrtdenestStopIteration(StopIteration):
+    pass
+
+
+def _sqrtdenest0(expr):
+    """Returns expr after denesting its arguments."""
+
+    if is_sqrt(expr):
+        n, d = expr.as_numer_denom()
+        if d is S.One:  # n is a square root
+            if n.base.is_Add:
+                args = sorted(n.base.args, key=default_sort_key)
+                if len(args) > 2 and all((x**2).is_Integer for x in args):
+                    try:
+                        return _sqrtdenest_rec(n)
+                    except SqrtdenestStopIteration:
+                        pass
+                expr = sqrt(_mexpand(Add(*[_sqrtdenest0(x) for x in args])))
+            return _sqrtdenest1(expr)
+        else:
+            n, d = [_sqrtdenest0(i) for i in (n, d)]
+            return n/d
+
+    if isinstance(expr, Add):
+        cs = []
+        args = []
+        for arg in expr.args:
+            c, a = arg.as_coeff_Mul()
+            cs.append(c)
+            args.append(a)
+
+        if all(c.is_Rational for c in cs) and all(is_sqrt(arg) for arg in args):
+            return _sqrt_ratcomb(cs, args)
+
+    if isinstance(expr, Expr):
+        args = expr.args
+        if args:
+            return expr.func(*[_sqrtdenest0(a) for a in args])
+    return expr
+
+
+def _sqrtdenest_rec(expr):
+    """Helper that denests the square root of three or more surds.
+
+    Explanation
+    ===========
+
+    It returns the denested expression; if it cannot be denested it
+    throws SqrtdenestStopIteration
+
+    Algorithm: expr.base is in the extension Q_m = Q(sqrt(r_1),..,sqrt(r_k));
+    split expr.base = a + b*sqrt(r_k), where `a` and `b` are on
+    Q_(m-1) = Q(sqrt(r_1),..,sqrt(r_(k-1))); then a**2 - b**2*r_k is
+    on Q_(m-1); denest sqrt(a**2 - b**2*r_k) and so on.
+    See [1], section 6.
+
+    Examples
+    ========
+
+    >>> from sympy import sqrt
+    >>> from sympy.simplify.sqrtdenest import _sqrtdenest_rec
+    >>> _sqrtdenest_rec(sqrt(-72*sqrt(2) + 158*sqrt(5) + 498))
+    -sqrt(10) + sqrt(2) + 9 + 9*sqrt(5)
+    >>> w=-6*sqrt(55)-6*sqrt(35)-2*sqrt(22)-2*sqrt(14)+2*sqrt(77)+6*sqrt(10)+65
+    >>> _sqrtdenest_rec(sqrt(w))
+    -sqrt(11) - sqrt(7) + sqrt(2) + 3*sqrt(5)
+    """
+    from sympy.simplify.radsimp import radsimp, rad_rationalize, split_surds
+    if not expr.is_Pow:
+        return sqrtdenest(expr)
+    if expr.base < 0:
+        return sqrt(-1)*_sqrtdenest_rec(sqrt(-expr.base))
+    g, a, b = split_surds(expr.base)
+    a = a*sqrt(g)
+    if a < b:
+        a, b = b, a
+    c2 = _mexpand(a**2 - b**2)
+    if len(c2.args) > 2:
+        g, a1, b1 = split_surds(c2)
+        a1 = a1*sqrt(g)
+        if a1 < b1:
+            a1, b1 = b1, a1
+        c2_1 = _mexpand(a1**2 - b1**2)
+        c_1 = _sqrtdenest_rec(sqrt(c2_1))
+        d_1 = _sqrtdenest_rec(sqrt(a1 + c_1))
+        num, den = rad_rationalize(b1, d_1)
+        c = _mexpand(d_1/sqrt(2) + num/(den*sqrt(2)))
+    else:
+        c = _sqrtdenest1(sqrt(c2))
+
+    if sqrt_depth(c) > 1:
+        raise SqrtdenestStopIteration
+    ac = a + c
+    if len(ac.args) >= len(expr.args):
+        if count_ops(ac) >= count_ops(expr.base):
+            raise SqrtdenestStopIteration
+    d = sqrtdenest(sqrt(ac))
+    if sqrt_depth(d) > 1:
+        raise SqrtdenestStopIteration
+    num, den = rad_rationalize(b, d)
+    r = d/sqrt(2) + num/(den*sqrt(2))
+    r = radsimp(r)
+    return _mexpand(r)
+
+
+def _sqrtdenest1(expr, denester=True):
+    """Return denested expr after denesting with simpler methods or, that
+    failing, using the denester."""
+
+    from sympy.simplify.simplify import radsimp
+
+    if not is_sqrt(expr):
+        return expr
+
+    a = expr.base
+    if a.is_Atom:
+        return expr
+    val = _sqrt_match(a)
+    if not val:
+        return expr
+
+    a, b, r = val
+    # try a quick numeric denesting
+    d2 = _mexpand(a**2 - b**2*r)
+    if d2.is_Rational:
+        if d2.is_positive:
+            z = _sqrt_numeric_denest(a, b, r, d2)
+            if z is not None:
+                return z
+        else:
+            # fourth root case
+            # sqrtdenest(sqrt(3 + 2*sqrt(3))) =
+            # sqrt(2)*3**(1/4)/2 + sqrt(2)*3**(3/4)/2
+            dr2 = _mexpand(-d2*r)
+            dr = sqrt(dr2)
+            if dr.is_Rational:
+                z = _sqrt_numeric_denest(_mexpand(b*r), a, r, dr2)
+                if z is not None:
+                    return z/root(r, 4)
+
+    else:
+        z = _sqrt_symbolic_denest(a, b, r)
+        if z is not None:
+            return z
+
+    if not denester or not is_algebraic(expr):
+        return expr
+
+    res = sqrt_biquadratic_denest(expr, a, b, r, d2)
+    if res:
+        return res
+
+    # now call to the denester
+    av0 = [a, b, r, d2]
+    z = _denester([radsimp(expr**2)], av0, 0, sqrt_depth(expr))[0]
+    if av0[1] is None:
+        return expr
+    if z is not None:
+        if sqrt_depth(z) == sqrt_depth(expr) and count_ops(z) > count_ops(expr):
+            return expr
+        return z
+    return expr
+
+
+def _sqrt_symbolic_denest(a, b, r):
+    """Given an expression, sqrt(a + b*sqrt(b)), return the denested
+    expression or None.
+
+    Explanation
+    ===========
+
+    If r = ra + rb*sqrt(rr), try replacing sqrt(rr) in ``a`` with
+    (y**2 - ra)/rb, and if the result is a quadratic, ca*y**2 + cb*y + cc, and
+    (cb + b)**2 - 4*ca*cc is 0, then sqrt(a + b*sqrt(r)) can be rewritten as
+    sqrt(ca*(sqrt(r) + (cb + b)/(2*ca))**2).
+
+    Examples
+    ========
+
+    >>> from sympy.simplify.sqrtdenest import _sqrt_symbolic_denest, sqrtdenest
+    >>> from sympy import sqrt, Symbol
+    >>> from sympy.abc import x
+
+    >>> a, b, r = 16 - 2*sqrt(29), 2, -10*sqrt(29) + 55
+    >>> _sqrt_symbolic_denest(a, b, r)
+    sqrt(11 - 2*sqrt(29)) + sqrt(5)
+
+    If the expression is numeric, it will be simplified:
+
+    >>> w = sqrt(sqrt(sqrt(3) + 1) + 1) + 1 + sqrt(2)
+    >>> sqrtdenest(sqrt((w**2).expand()))
+    1 + sqrt(2) + sqrt(1 + sqrt(1 + sqrt(3)))
+
+    Otherwise, it will only be simplified if assumptions allow:
+
+    >>> w = w.subs(sqrt(3), sqrt(x + 3))
+    >>> sqrtdenest(sqrt((w**2).expand()))
+    sqrt((sqrt(sqrt(sqrt(x + 3) + 1) + 1) + 1 + sqrt(2))**2)
+
+    Notice that the argument of the sqrt is a square. If x is made positive
+    then the sqrt of the square is resolved:
+
+    >>> _.subs(x, Symbol('x', positive=True))
+    sqrt(sqrt(sqrt(x + 3) + 1) + 1) + 1 + sqrt(2)
+    """
+
+    a, b, r = map(sympify, (a, b, r))
+    rval = _sqrt_match(r)
+    if not rval:
+        return None
+    ra, rb, rr = rval
+    if rb:
+        y = Dummy('y', positive=True)
+        try:
+            newa = Poly(a.subs(sqrt(rr), (y**2 - ra)/rb), y)
+        except PolynomialError:
+            return None
+        if newa.degree() == 2:
+            ca, cb, cc = newa.all_coeffs()
+            cb += b
+            if _mexpand(cb**2 - 4*ca*cc).equals(0):
+                z = sqrt(ca*(sqrt(r) + cb/(2*ca))**2)
+                if z.is_number:
+                    z = _mexpand(Mul._from_args(z.as_content_primitive()))
+                return z
+
+
+def _sqrt_numeric_denest(a, b, r, d2):
+    r"""Helper that denest
+    $\sqrt{a + b \sqrt{r}}, d^2 = a^2 - b^2 r > 0$
+
+    If it cannot be denested, it returns ``None``.
+    """
+    d = sqrt(d2)
+    s = a + d
+    # sqrt_depth(res) <= sqrt_depth(s) + 1
+    # sqrt_depth(expr) = sqrt_depth(r) + 2
+    # there is denesting if sqrt_depth(s) + 1 < sqrt_depth(r) + 2
+    # if s**2 is Number there is a fourth root
+    if sqrt_depth(s) < sqrt_depth(r) + 1 or (s**2).is_Rational:
+        s1, s2 = sign(s), sign(b)
+        if s1 == s2 == -1:
+            s1 = s2 = 1
+        res = (s1 * sqrt(a + d) + s2 * sqrt(a - d)) * sqrt(2) / 2
+        return res.expand()
+
+
+def sqrt_biquadratic_denest(expr, a, b, r, d2):
+    """denest expr = sqrt(a + b*sqrt(r))
+    where a, b, r are linear combinations of square roots of
+    positive rationals on the rationals (SQRR) and r > 0, b != 0,
+    d2 = a**2 - b**2*r > 0
+
+    If it cannot denest it returns None.
+
+    Explanation
+    ===========
+
+    Search for a solution A of type SQRR of the biquadratic equation
+    4*A**4 - 4*a*A**2 + b**2*r = 0                               (1)
+    sqd = sqrt(a**2 - b**2*r)
+    Choosing the sqrt to be positive, the possible solutions are
+    A = sqrt(a/2 +/- sqd/2)
+    Since a, b, r are SQRR, then a**2 - b**2*r is a SQRR,
+    so if sqd can be denested, it is done by
+    _sqrtdenest_rec, and the result is a SQRR.
+    Similarly for A.
+    Examples of solutions (in both cases a and sqd are positive):
+
+      Example of expr with solution sqrt(a/2 + sqd/2) but not
+      solution sqrt(a/2 - sqd/2):
+      expr = sqrt(-sqrt(15) - sqrt(2)*sqrt(-sqrt(5) + 5) - sqrt(3) + 8)
+      a = -sqrt(15) - sqrt(3) + 8; sqd = -2*sqrt(5) - 2 + 4*sqrt(3)
+
+      Example of expr with solution sqrt(a/2 - sqd/2) but not
+      solution sqrt(a/2 + sqd/2):
+      w = 2 + r2 + r3 + (1 + r3)*sqrt(2 + r2 + 5*r3)
+      expr = sqrt((w**2).expand())
+      a = 4*sqrt(6) + 8*sqrt(2) + 47 + 28*sqrt(3)
+      sqd = 29 + 20*sqrt(3)
+
+    Define B = b/2*A; eq.(1) implies a = A**2 + B**2*r; then
+    expr**2 = a + b*sqrt(r) = (A + B*sqrt(r))**2
+
+    Examples
+    ========
+
+    >>> from sympy import sqrt
+    >>> from sympy.simplify.sqrtdenest import _sqrt_match, sqrt_biquadratic_denest
+    >>> z = sqrt((2*sqrt(2) + 4)*sqrt(2 + sqrt(2)) + 5*sqrt(2) + 8)
+    >>> a, b, r = _sqrt_match(z**2)
+    >>> d2 = a**2 - b**2*r
+    >>> sqrt_biquadratic_denest(z, a, b, r, d2)
+    sqrt(2) + sqrt(sqrt(2) + 2) + 2
+    """
+    from sympy.simplify.radsimp import radsimp, rad_rationalize
+    if r <= 0 or d2 < 0 or not b or sqrt_depth(expr.base) < 2:
+        return None
+    for x in (a, b, r):
+        for y in x.args:
+            y2 = y**2
+            if not y2.is_Integer or not y2.is_positive:
+                return None
+    sqd = _mexpand(sqrtdenest(sqrt(radsimp(d2))))
+    if sqrt_depth(sqd) > 1:
+        return None
+    x1, x2 = [a/2 + sqd/2, a/2 - sqd/2]
+    # look for a solution A with depth 1
+    for x in (x1, x2):
+        A = sqrtdenest(sqrt(x))
+        if sqrt_depth(A) > 1:
+            continue
+        Bn, Bd = rad_rationalize(b, _mexpand(2*A))
+        B = Bn/Bd
+        z = A + B*sqrt(r)
+        if z < 0:
+            z = -z
+        return _mexpand(z)
+    return None
+
+
+def _denester(nested, av0, h, max_depth_level):
+    """Denests a list of expressions that contain nested square roots.
+
+    Explanation
+    ===========
+
+    Algorithm based on <http://www.almaden.ibm.com/cs/people/fagin/symb85.pdf>.
+
+    It is assumed that all of the elements of 'nested' share the same
+    bottom-level radicand. (This is stated in the paper, on page 177, in
+    the paragraph immediately preceding the algorithm.)
+
+    When evaluating all of the arguments in parallel, the bottom-level
+    radicand only needs to be denested once. This means that calling
+    _denester with x arguments results in a recursive invocation with x+1
+    arguments; hence _denester has polynomial complexity.
+
+    However, if the arguments were evaluated separately, each call would
+    result in two recursive invocations, and the algorithm would have
+    exponential complexity.
+
+    This is discussed in the paper in the middle paragraph of page 179.
+    """
+    from sympy.simplify.simplify import radsimp
+    if h > max_depth_level:
+        return None, None
+    if av0[1] is None:
+        return None, None
+    if (av0[0] is None and
+            all(n.is_Number for n in nested)):  # no arguments are nested
+        for f in _subsets(len(nested)):  # test subset 'f' of nested
+            p = _mexpand(Mul(*[nested[i] for i in range(len(f)) if f[i]]))
+            if f.count(1) > 1 and f[-1]:
+                p = -p
+            sqp = sqrt(p)
+            if sqp.is_Rational:
+                return sqp, f  # got a perfect square so return its square root.
+        # Otherwise, return the radicand from the previous invocation.
+        return sqrt(nested[-1]), [0]*len(nested)
+    else:
+        R = None
+        if av0[0] is not None:
+            values = [av0[:2]]
+            R = av0[2]
+            nested2 = [av0[3], R]
+            av0[0] = None
+        else:
+            values = list(filter(None, [_sqrt_match(expr) for expr in nested]))
+            for v in values:
+                if v[2]:  # Since if b=0, r is not defined
+                    if R is not None:
+                        if R != v[2]:
+                            av0[1] = None
+                            return None, None
+                    else:
+                        R = v[2]
+            if R is None:
+                # return the radicand from the previous invocation
+                return sqrt(nested[-1]), [0]*len(nested)
+            nested2 = [_mexpand(v[0]**2) -
+                       _mexpand(R*v[1]**2) for v in values] + [R]
+        d, f = _denester(nested2, av0, h + 1, max_depth_level)
+        if not f:
+            return None, None
+        if not any(f[i] for i in range(len(nested))):
+            v = values[-1]
+            return sqrt(v[0] + _mexpand(v[1]*d)), f
+        else:
+            p = Mul(*[nested[i] for i in range(len(nested)) if f[i]])
+            v = _sqrt_match(p)
+            if 1 in f and f.index(1) < len(nested) - 1 and f[len(nested) - 1]:
+                v[0] = -v[0]
+                v[1] = -v[1]
+            if not f[len(nested)]:  # Solution denests with square roots
+                vad = _mexpand(v[0] + d)
+                if vad <= 0:
+                    # return the radicand from the previous invocation.
+                    return sqrt(nested[-1]), [0]*len(nested)
+                if not(sqrt_depth(vad) <= sqrt_depth(R) + 1 or
+                       (vad**2).is_Number):
+                    av0[1] = None
+                    return None, None
+
+                sqvad = _sqrtdenest1(sqrt(vad), denester=False)
+                if not (sqrt_depth(sqvad) <= sqrt_depth(R) + 1):
+                    av0[1] = None
+                    return None, None
+                sqvad1 = radsimp(1/sqvad)
+                res = _mexpand(sqvad/sqrt(2) + (v[1]*sqrt(R)*sqvad1/sqrt(2)))
+                return res, f
+
+                      #          sign(v[1])*sqrt(_mexpand(v[1]**2*R*vad1/2))), f
+            else:  # Solution requires a fourth root
+                s2 = _mexpand(v[1]*R) + d
+                if s2 <= 0:
+                    return sqrt(nested[-1]), [0]*len(nested)
+                FR, s = root(_mexpand(R), 4), sqrt(s2)
+                return _mexpand(s/(sqrt(2)*FR) + v[0]*FR/(sqrt(2)*s)), f
+
+
+def _sqrt_ratcomb(cs, args):
+    """Denest rational combinations of radicals.
+
+    Based on section 5 of [1].
+
+    Examples
+    ========
+
+    >>> from sympy import sqrt
+    >>> from sympy.simplify.sqrtdenest import sqrtdenest
+    >>> z = sqrt(1+sqrt(3)) + sqrt(3+3*sqrt(3)) - sqrt(10+6*sqrt(3))
+    >>> sqrtdenest(z)
+    0
+    """
+    from sympy.simplify.radsimp import radsimp
+
+    # check if there exists a pair of sqrt that can be denested
+    def find(a):
+        n = len(a)
+        for i in range(n - 1):
+            for j in range(i + 1, n):
+                s1 = a[i].base
+                s2 = a[j].base
+                p = _mexpand(s1 * s2)
+                s = sqrtdenest(sqrt(p))
+                if s != sqrt(p):
+                    return s, i, j
+
+    indices = find(args)
+    if indices is None:
+        return Add(*[c * arg for c, arg in zip(cs, args)])
+
+    s, i1, i2 = indices
+
+    c2 = cs.pop(i2)
+    args.pop(i2)
+    a1 = args[i1]
+
+    # replace a2 by s/a1
+    cs[i1] += radsimp(c2 * s / a1.base)
+
+    return _sqrt_ratcomb(cs, args)