diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/combinatorics/tests/__pycache__/test_graycode.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/combinatorics/tests/__pycache__/test_graycode.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a3be5513d390d38c5dfceb6ae276f25ee20b2ec2
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/combinatorics/tests/__pycache__/test_graycode.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/combinatorics/tests/__pycache__/test_group_constructs.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/combinatorics/tests/__pycache__/test_group_constructs.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4eb74f1ab85109495f5965f700a2fe3c8f93488d
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/combinatorics/tests/__pycache__/test_group_constructs.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/combinatorics/tests/__pycache__/test_homomorphisms.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/combinatorics/tests/__pycache__/test_homomorphisms.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..43105cd0d040c7ba673803e3cf17a6d8f9b909b0
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/combinatorics/tests/__pycache__/test_homomorphisms.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/combinatorics/tests/__pycache__/test_perm_groups.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/combinatorics/tests/__pycache__/test_perm_groups.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..67b022c707364fd4b3f1f4c7238deea5255bbefc
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/combinatorics/tests/__pycache__/test_perm_groups.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/combinatorics/tests/__pycache__/test_prufer.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/combinatorics/tests/__pycache__/test_prufer.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f4cb479be4ca1937052e9b098c966c8498ea054a
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/combinatorics/tests/__pycache__/test_prufer.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/combinatorics/tests/test_free_groups.py b/llmeval-env/lib/python3.10/site-packages/sympy/combinatorics/tests/test_free_groups.py
new file mode 100644
index 0000000000000000000000000000000000000000..0b2b35e96548b88d0628167bcac08432e9ac31b6
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/combinatorics/tests/test_free_groups.py
@@ -0,0 +1,215 @@
+from sympy.combinatorics.free_groups import free_group, FreeGroup
+from sympy.core import Symbol
+from sympy.testing.pytest import raises
+from sympy.core.numbers import oo
+
+F, x, y, z = free_group("x, y, z")
+
+
+def test_FreeGroup__init__():
+    x, y, z = map(Symbol, "xyz")
+
+    assert len(FreeGroup("x, y, z").generators) == 3
+    assert len(FreeGroup(x).generators) == 1
+    assert len(FreeGroup(("x", "y", "z"))) == 3
+    assert len(FreeGroup((x, y, z)).generators) == 3
+
+
+def test_free_group():
+    G, a, b, c = free_group("a, b, c")
+    assert F.generators == (x, y, z)
+    assert x*z**2 in F
+    assert x in F
+    assert y*z**-1 in F
+    assert (y*z)**0 in F
+    assert a not in F
+    assert a**0 not in F
+    assert len(F) == 3
+    assert str(F) == '<free group on the generators (x, y, z)>'
+    assert not F == G
+    assert F.order() is oo
+    assert F.is_abelian == False
+    assert F.center() == {F.identity}
+
+    (e,) = free_group("")
+    assert e.order() == 1
+    assert e.generators == ()
+    assert e.elements == {e.identity}
+    assert e.is_abelian == True
+
+
+def test_FreeGroup__hash__():
+    assert hash(F)
+
+
+def test_FreeGroup__eq__():
+    assert free_group("x, y, z")[0] == free_group("x, y, z")[0]
+    assert free_group("x, y, z")[0] is free_group("x, y, z")[0]
+
+    assert free_group("x, y, z")[0] != free_group("a, x, y")[0]
+    assert free_group("x, y, z")[0] is not free_group("a, x, y")[0]
+
+    assert free_group("x, y")[0] != free_group("x, y, z")[0]
+    assert free_group("x, y")[0] is not free_group("x, y, z")[0]
+
+    assert free_group("x, y, z")[0] != free_group("x, y")[0]
+    assert free_group("x, y, z")[0] is not free_group("x, y")[0]
+
+
+def test_FreeGroup__getitem__():
+    assert F[0:] == FreeGroup("x, y, z")
+    assert F[1:] == FreeGroup("y, z")
+    assert F[2:] == FreeGroup("z")
+
+
+def test_FreeGroupElm__hash__():
+    assert hash(x*y*z)
+
+
+def test_FreeGroupElm_copy():
+    f = x*y*z**3
+    g = f.copy()
+    h = x*y*z**7
+
+    assert f == g
+    assert f != h
+
+
+def test_FreeGroupElm_inverse():
+    assert x.inverse() == x**-1
+    assert (x*y).inverse() == y**-1*x**-1
+    assert (y*x*y**-1).inverse() == y*x**-1*y**-1
+    assert (y**2*x**-1).inverse() == x*y**-2
+
+
+def test_FreeGroupElm_type_error():
+    raises(TypeError, lambda: 2/x)
+    raises(TypeError, lambda: x**2 + y**2)
+    raises(TypeError, lambda: x/2)
+
+
+def test_FreeGroupElm_methods():
+    assert (x**0).order() == 1
+    assert (y**2).order() is oo
+    assert (x**-1*y).commutator(x) == y**-1*x**-1*y*x
+    assert len(x**2*y**-1) == 3
+    assert len(x**-1*y**3*z) == 5
+
+
+def test_FreeGroupElm_eliminate_word():
+    w = x**5*y*x**2*y**-4*x
+    assert w.eliminate_word( x, x**2 ) == x**10*y*x**4*y**-4*x**2
+    w3 = x**2*y**3*x**-1*y
+    assert w3.eliminate_word(x, x**2) == x**4*y**3*x**-2*y
+    assert w3.eliminate_word(x, y) == y**5
+    assert w3.eliminate_word(x, y**4) == y**8
+    assert w3.eliminate_word(y, x**-1) == x**-3
+    assert w3.eliminate_word(x, y*z) == y*z*y*z*y**3*z**-1
+    assert (y**-3).eliminate_word(y, x**-1*z**-1) == z*x*z*x*z*x
+    #assert w3.eliminate_word(x, y*x) == y*x*y*x**2*y*x*y*x*y*x*z**3
+    #assert w3.eliminate_word(x, x*y) == x*y*x**2*y*x*y*x*y*x*y*z**3
+
+
+def test_FreeGroupElm_array_form():
+    assert (x*z).array_form == ((Symbol('x'), 1), (Symbol('z'), 1))
+    assert (x**2*z*y*x**-2).array_form == \
+        ((Symbol('x'), 2), (Symbol('z'), 1), (Symbol('y'), 1), (Symbol('x'), -2))
+    assert (x**-2*y**-1).array_form == ((Symbol('x'), -2), (Symbol('y'), -1))
+
+
+def test_FreeGroupElm_letter_form():
+    assert (x**3).letter_form == (Symbol('x'), Symbol('x'), Symbol('x'))
+    assert (x**2*z**-2*x).letter_form == \
+        (Symbol('x'), Symbol('x'), -Symbol('z'), -Symbol('z'), Symbol('x'))
+
+
+def test_FreeGroupElm_ext_rep():
+    assert (x**2*z**-2*x).ext_rep == \
+        (Symbol('x'), 2, Symbol('z'), -2, Symbol('x'), 1)
+    assert (x**-2*y**-1).ext_rep == (Symbol('x'), -2, Symbol('y'), -1)
+    assert (x*z).ext_rep == (Symbol('x'), 1, Symbol('z'), 1)
+
+
+def test_FreeGroupElm__mul__pow__():
+    x1 = x.group.dtype(((Symbol('x'), 1),))
+    assert x**2 == x1*x
+
+    assert (x**2*y*x**-2)**4 == x**2*y**4*x**-2
+    assert (x**2)**2 == x**4
+    assert (x**-1)**-1 == x
+    assert (x**-1)**0 == F.identity
+    assert (y**2)**-2 == y**-4
+
+    assert x**2*x**-1 == x
+    assert x**2*y**2*y**-1 == x**2*y
+    assert x*x**-1 == F.identity
+
+    assert x/x == F.identity
+    assert x/x**2 == x**-1
+    assert (x**2*y)/(x**2*y**-1) == x**2*y**2*x**-2
+    assert (x**2*y)/(y**-1*x**2) == x**2*y*x**-2*y
+
+    assert x*(x**-1*y*z*y**-1) == y*z*y**-1
+    assert x**2*(x**-2*y**-1*z**2*y) == y**-1*z**2*y
+
+
+def test_FreeGroupElm__len__():
+    assert len(x**5*y*x**2*y**-4*x) == 13
+    assert len(x**17) == 17
+    assert len(y**0) == 0
+
+
+def test_FreeGroupElm_comparison():
+    assert not (x*y == y*x)
+    assert x**0 == y**0
+
+    assert x**2 < y**3
+    assert not x**3 < y**2
+    assert x*y < x**2*y
+    assert x**2*y**2 < y**4
+    assert not y**4 < y**-4
+    assert not y**4 < x**-4
+    assert y**-2 < y**2
+
+    assert x**2 <= y**2
+    assert x**2 <= x**2
+
+    assert not y*z > z*y
+    assert x > x**-1
+
+    assert not x**2 >= y**2
+
+
+def test_FreeGroupElm_syllables():
+    w = x**5*y*x**2*y**-4*x
+    assert w.number_syllables() == 5
+    assert w.exponent_syllable(2) == 2
+    assert w.generator_syllable(3) == Symbol('y')
+    assert w.sub_syllables(1, 2) == y
+    assert w.sub_syllables(3, 3) == F.identity
+
+
+def test_FreeGroup_exponents():
+    w1 = x**2*y**3
+    assert w1.exponent_sum(x) == 2
+    assert w1.exponent_sum(x**-1) == -2
+    assert w1.generator_count(x) == 2
+
+    w2 = x**2*y**4*x**-3
+    assert w2.exponent_sum(x) == -1
+    assert w2.generator_count(x) == 5
+
+
+def test_FreeGroup_generators():
+    assert (x**2*y**4*z**-1).contains_generators() == {x, y, z}
+    assert (x**-1*y**3).contains_generators() == {x, y}
+
+
+def test_FreeGroupElm_words():
+    w = x**5*y*x**2*y**-4*x
+    assert w.subword(2, 6) == x**3*y
+    assert w.subword(3, 2) == F.identity
+    assert w.subword(6, 10) == x**2*y**-2
+
+    assert w.substituted_word(0, 7, y**-1) == y**-1*x*y**-4*x
+    assert w.substituted_word(0, 7, y**2*x) == y**2*x**2*y**-4*x
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/combinatorics/tests/test_generators.py b/llmeval-env/lib/python3.10/site-packages/sympy/combinatorics/tests/test_generators.py
new file mode 100644
index 0000000000000000000000000000000000000000..795ef8f08f6ec212879f528c6a0c2f0bd73037f0
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/combinatorics/tests/test_generators.py
@@ -0,0 +1,105 @@
+from sympy.combinatorics.generators import symmetric, cyclic, alternating, \
+    dihedral, rubik
+from sympy.combinatorics.permutations import Permutation
+from sympy.testing.pytest import raises
+
+def test_generators():
+
+    assert list(cyclic(6)) == [
+        Permutation([0, 1, 2, 3, 4, 5]),
+        Permutation([1, 2, 3, 4, 5, 0]),
+        Permutation([2, 3, 4, 5, 0, 1]),
+        Permutation([3, 4, 5, 0, 1, 2]),
+        Permutation([4, 5, 0, 1, 2, 3]),
+        Permutation([5, 0, 1, 2, 3, 4])]
+
+    assert list(cyclic(10)) == [
+        Permutation([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
+        Permutation([1, 2, 3, 4, 5, 6, 7, 8, 9, 0]),
+        Permutation([2, 3, 4, 5, 6, 7, 8, 9, 0, 1]),
+        Permutation([3, 4, 5, 6, 7, 8, 9, 0, 1, 2]),
+        Permutation([4, 5, 6, 7, 8, 9, 0, 1, 2, 3]),
+        Permutation([5, 6, 7, 8, 9, 0, 1, 2, 3, 4]),
+        Permutation([6, 7, 8, 9, 0, 1, 2, 3, 4, 5]),
+        Permutation([7, 8, 9, 0, 1, 2, 3, 4, 5, 6]),
+        Permutation([8, 9, 0, 1, 2, 3, 4, 5, 6, 7]),
+        Permutation([9, 0, 1, 2, 3, 4, 5, 6, 7, 8])]
+
+    assert list(alternating(4)) == [
+        Permutation([0, 1, 2, 3]),
+        Permutation([0, 2, 3, 1]),
+        Permutation([0, 3, 1, 2]),
+        Permutation([1, 0, 3, 2]),
+        Permutation([1, 2, 0, 3]),
+        Permutation([1, 3, 2, 0]),
+        Permutation([2, 0, 1, 3]),
+        Permutation([2, 1, 3, 0]),
+        Permutation([2, 3, 0, 1]),
+        Permutation([3, 0, 2, 1]),
+        Permutation([3, 1, 0, 2]),
+        Permutation([3, 2, 1, 0])]
+
+    assert list(symmetric(3)) == [
+        Permutation([0, 1, 2]),
+        Permutation([0, 2, 1]),
+        Permutation([1, 0, 2]),
+        Permutation([1, 2, 0]),
+        Permutation([2, 0, 1]),
+        Permutation([2, 1, 0])]
+
+    assert list(symmetric(4)) == [
+        Permutation([0, 1, 2, 3]),
+        Permutation([0, 1, 3, 2]),
+        Permutation([0, 2, 1, 3]),
+        Permutation([0, 2, 3, 1]),
+        Permutation([0, 3, 1, 2]),
+        Permutation([0, 3, 2, 1]),
+        Permutation([1, 0, 2, 3]),
+        Permutation([1, 0, 3, 2]),
+        Permutation([1, 2, 0, 3]),
+        Permutation([1, 2, 3, 0]),
+        Permutation([1, 3, 0, 2]),
+        Permutation([1, 3, 2, 0]),
+        Permutation([2, 0, 1, 3]),
+        Permutation([2, 0, 3, 1]),
+        Permutation([2, 1, 0, 3]),
+        Permutation([2, 1, 3, 0]),
+        Permutation([2, 3, 0, 1]),
+        Permutation([2, 3, 1, 0]),
+        Permutation([3, 0, 1, 2]),
+        Permutation([3, 0, 2, 1]),
+        Permutation([3, 1, 0, 2]),
+        Permutation([3, 1, 2, 0]),
+        Permutation([3, 2, 0, 1]),
+        Permutation([3, 2, 1, 0])]
+
+    assert list(dihedral(1)) == [
+        Permutation([0, 1]), Permutation([1, 0])]
+
+    assert list(dihedral(2)) == [
+        Permutation([0, 1, 2, 3]),
+        Permutation([1, 0, 3, 2]),
+        Permutation([2, 3, 0, 1]),
+        Permutation([3, 2, 1, 0])]
+
+    assert list(dihedral(3)) == [
+        Permutation([0, 1, 2]),
+        Permutation([2, 1, 0]),
+        Permutation([1, 2, 0]),
+        Permutation([0, 2, 1]),
+        Permutation([2, 0, 1]),
+        Permutation([1, 0, 2])]
+
+    assert list(dihedral(5)) == [
+        Permutation([0, 1, 2, 3, 4]),
+        Permutation([4, 3, 2, 1, 0]),
+        Permutation([1, 2, 3, 4, 0]),
+        Permutation([0, 4, 3, 2, 1]),
+        Permutation([2, 3, 4, 0, 1]),
+        Permutation([1, 0, 4, 3, 2]),
+        Permutation([3, 4, 0, 1, 2]),
+        Permutation([2, 1, 0, 4, 3]),
+        Permutation([4, 0, 1, 2, 3]),
+        Permutation([3, 2, 1, 0, 4])]
+
+    raises(ValueError, lambda: rubik(1))
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/combinatorics/tests/test_group_constructs.py b/llmeval-env/lib/python3.10/site-packages/sympy/combinatorics/tests/test_group_constructs.py
new file mode 100644
index 0000000000000000000000000000000000000000..d0f7d6394bbc2e285650ea95d36be8e2ed5ea69e
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/combinatorics/tests/test_group_constructs.py
@@ -0,0 +1,15 @@
+from sympy.combinatorics.group_constructs import DirectProduct
+from sympy.combinatorics.named_groups import CyclicGroup, DihedralGroup
+
+
+def test_direct_product_n():
+    C = CyclicGroup(4)
+    D = DihedralGroup(4)
+    G = DirectProduct(C, C, C)
+    assert G.order() == 64
+    assert G.degree == 12
+    assert len(G.orbits()) == 3
+    assert G.is_abelian is True
+    H = DirectProduct(D, C)
+    assert H.order() == 32
+    assert H.is_abelian is False
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/combinatorics/tests/test_pc_groups.py b/llmeval-env/lib/python3.10/site-packages/sympy/combinatorics/tests/test_pc_groups.py
new file mode 100644
index 0000000000000000000000000000000000000000..b0c146279921e1e6499534fe9e33b993348d1503
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/combinatorics/tests/test_pc_groups.py
@@ -0,0 +1,87 @@
+from sympy.combinatorics.permutations import Permutation
+from sympy.combinatorics.named_groups import SymmetricGroup, AlternatingGroup, DihedralGroup
+from sympy.matrices import Matrix
+
+def test_pc_presentation():
+    Groups = [SymmetricGroup(3), SymmetricGroup(4), SymmetricGroup(9).sylow_subgroup(3),
+         SymmetricGroup(9).sylow_subgroup(2), SymmetricGroup(8).sylow_subgroup(2), DihedralGroup(10)]
+
+    S = SymmetricGroup(125).sylow_subgroup(5)
+    G = S.derived_series()[2]
+    Groups.append(G)
+
+    G = SymmetricGroup(25).sylow_subgroup(5)
+    Groups.append(G)
+
+    S = SymmetricGroup(11**2).sylow_subgroup(11)
+    G = S.derived_series()[2]
+    Groups.append(G)
+
+    for G in Groups:
+        PcGroup = G.polycyclic_group()
+        collector = PcGroup.collector
+        pc_presentation = collector.pc_presentation
+
+        pcgs = PcGroup.pcgs
+        free_group = collector.free_group
+        free_to_perm = {}
+        for s, g in zip(free_group.symbols, pcgs):
+            free_to_perm[s] = g
+
+        for k, v in pc_presentation.items():
+            k_array = k.array_form
+            if v != ():
+                v_array = v.array_form
+
+            lhs = Permutation()
+            for gen in k_array:
+                s = gen[0]
+                e = gen[1]
+                lhs = lhs*free_to_perm[s]**e
+
+            if v == ():
+                assert lhs.is_identity
+                continue
+
+            rhs = Permutation()
+            for gen in v_array:
+                s = gen[0]
+                e = gen[1]
+                rhs = rhs*free_to_perm[s]**e
+
+            assert lhs == rhs
+
+
+def test_exponent_vector():
+
+    Groups = [SymmetricGroup(3), SymmetricGroup(4), SymmetricGroup(9).sylow_subgroup(3),
+         SymmetricGroup(9).sylow_subgroup(2), SymmetricGroup(8).sylow_subgroup(2)]
+
+    for G in Groups:
+        PcGroup = G.polycyclic_group()
+        collector = PcGroup.collector
+
+        pcgs = PcGroup.pcgs
+        # free_group = collector.free_group
+
+        for gen in G.generators:
+            exp = collector.exponent_vector(gen)
+            g = Permutation()
+            for i in range(len(exp)):
+                g = g*pcgs[i]**exp[i] if exp[i] else g
+            assert g == gen
+
+
+def test_induced_pcgs():
+    G = [SymmetricGroup(9).sylow_subgroup(3), SymmetricGroup(20).sylow_subgroup(2), AlternatingGroup(4),
+    DihedralGroup(4), DihedralGroup(10), DihedralGroup(9), SymmetricGroup(3), SymmetricGroup(4)]
+
+    for g in G:
+        PcGroup = g.polycyclic_group()
+        collector = PcGroup.collector
+        gens = list(g.generators)
+        ipcgs = collector.induced_pcgs(gens)
+        m = []
+        for i in ipcgs:
+            m.append(collector.exponent_vector(i))
+        assert Matrix(m).is_upper
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/combinatorics/tests/test_util.py b/llmeval-env/lib/python3.10/site-packages/sympy/combinatorics/tests/test_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..bca183e81f354e398aee9ae809fe79b20c7f2468
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/combinatorics/tests/test_util.py
@@ -0,0 +1,120 @@
+from sympy.combinatorics.named_groups import SymmetricGroup, DihedralGroup,\
+    AlternatingGroup
+from sympy.combinatorics.permutations import Permutation
+from sympy.combinatorics.util import _check_cycles_alt_sym, _strip,\
+    _distribute_gens_by_base, _strong_gens_from_distr,\
+    _orbits_transversals_from_bsgs, _handle_precomputed_bsgs, _base_ordering,\
+    _remove_gens
+from sympy.combinatorics.testutil import _verify_bsgs
+
+
+def test_check_cycles_alt_sym():
+    perm1 = Permutation([[0, 1, 2, 3, 4, 5, 6], [7], [8], [9]])
+    perm2 = Permutation([[0, 1, 2, 3, 4, 5], [6, 7, 8, 9]])
+    perm3 = Permutation([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]])
+    assert _check_cycles_alt_sym(perm1) is True
+    assert _check_cycles_alt_sym(perm2) is False
+    assert _check_cycles_alt_sym(perm3) is False
+
+
+def test_strip():
+    D = DihedralGroup(5)
+    D.schreier_sims()
+    member = Permutation([4, 0, 1, 2, 3])
+    not_member1 = Permutation([0, 1, 4, 3, 2])
+    not_member2 = Permutation([3, 1, 4, 2, 0])
+    identity = Permutation([0, 1, 2, 3, 4])
+    res1 = _strip(member, D.base, D.basic_orbits, D.basic_transversals)
+    res2 = _strip(not_member1, D.base, D.basic_orbits, D.basic_transversals)
+    res3 = _strip(not_member2, D.base, D.basic_orbits, D.basic_transversals)
+    assert res1[0] == identity
+    assert res1[1] == len(D.base) + 1
+    assert res2[0] == not_member1
+    assert res2[1] == len(D.base) + 1
+    assert res3[0] != identity
+    assert res3[1] == 2
+
+
+def test_distribute_gens_by_base():
+    base = [0, 1, 2]
+    gens = [Permutation([0, 1, 2, 3]), Permutation([0, 1, 3, 2]),
+           Permutation([0, 2, 3, 1]), Permutation([3, 2, 1, 0])]
+    assert _distribute_gens_by_base(base, gens) == [gens,
+                                                   [Permutation([0, 1, 2, 3]),
+                                                   Permutation([0, 1, 3, 2]),
+                                                   Permutation([0, 2, 3, 1])],
+                                                   [Permutation([0, 1, 2, 3]),
+                                                   Permutation([0, 1, 3, 2])]]
+
+
+def test_strong_gens_from_distr():
+    strong_gens_distr = [[Permutation([0, 2, 1]), Permutation([1, 2, 0]),
+                  Permutation([1, 0, 2])], [Permutation([0, 2, 1])]]
+    assert _strong_gens_from_distr(strong_gens_distr) == \
+        [Permutation([0, 2, 1]),
+         Permutation([1, 2, 0]),
+         Permutation([1, 0, 2])]
+
+
+def test_orbits_transversals_from_bsgs():
+    S = SymmetricGroup(4)
+    S.schreier_sims()
+    base = S.base
+    strong_gens = S.strong_gens
+    strong_gens_distr = _distribute_gens_by_base(base, strong_gens)
+    result = _orbits_transversals_from_bsgs(base, strong_gens_distr)
+    orbits = result[0]
+    transversals = result[1]
+    base_len = len(base)
+    for i in range(base_len):
+        for el in orbits[i]:
+            assert transversals[i][el](base[i]) == el
+            for j in range(i):
+                assert transversals[i][el](base[j]) == base[j]
+    order = 1
+    for i in range(base_len):
+        order *= len(orbits[i])
+    assert S.order() == order
+
+
+def test_handle_precomputed_bsgs():
+    A = AlternatingGroup(5)
+    A.schreier_sims()
+    base = A.base
+    strong_gens = A.strong_gens
+    result = _handle_precomputed_bsgs(base, strong_gens)
+    strong_gens_distr = _distribute_gens_by_base(base, strong_gens)
+    assert strong_gens_distr == result[2]
+    transversals = result[0]
+    orbits = result[1]
+    base_len = len(base)
+    for i in range(base_len):
+        for el in orbits[i]:
+            assert transversals[i][el](base[i]) == el
+            for j in range(i):
+                assert transversals[i][el](base[j]) == base[j]
+    order = 1
+    for i in range(base_len):
+        order *= len(orbits[i])
+    assert A.order() == order
+
+
+def test_base_ordering():
+    base = [2, 4, 5]
+    degree = 7
+    assert _base_ordering(base, degree) == [3, 4, 0, 5, 1, 2, 6]
+
+
+def test_remove_gens():
+    S = SymmetricGroup(10)
+    base, strong_gens = S.schreier_sims_incremental()
+    new_gens = _remove_gens(base, strong_gens)
+    assert _verify_bsgs(S, base, new_gens) is True
+    A = AlternatingGroup(7)
+    base, strong_gens = A.schreier_sims_incremental()
+    new_gens = _remove_gens(base, strong_gens)
+    assert _verify_bsgs(A, base, new_gens) is True
+    D = DihedralGroup(2)
+    base, strong_gens = D.schreier_sims_incremental()
+    new_gens = _remove_gens(base, strong_gens)
+    assert _verify_bsgs(D, base, new_gens) is True
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/logic/algorithms/__pycache__/__init__.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/logic/algorithms/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b50bbfcf9d927d7b1d571165b983d390b60f3ee4
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/logic/algorithms/__pycache__/__init__.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/logic/algorithms/__pycache__/dpll.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/logic/algorithms/__pycache__/dpll.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3d1a5431ad46339792a065179316ac62252364e0
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/logic/algorithms/__pycache__/dpll.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/logic/algorithms/__pycache__/dpll2.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/logic/algorithms/__pycache__/dpll2.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8d5cbcd20d64102a9d6c7a8a7b5ec8cb559cbcb3
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/logic/algorithms/__pycache__/dpll2.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/logic/algorithms/__pycache__/minisat22_wrapper.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/logic/algorithms/__pycache__/minisat22_wrapper.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8f9603e0a755b7debc55af173c9e06dee2cc7dbd
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/logic/algorithms/__pycache__/minisat22_wrapper.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/logic/algorithms/__pycache__/pycosat_wrapper.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/logic/algorithms/__pycache__/pycosat_wrapper.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cb2cd8ad18fc1a222ea7e10d75561e6746384aaf
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/logic/algorithms/__pycache__/pycosat_wrapper.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/logic/algorithms/pycosat_wrapper.py b/llmeval-env/lib/python3.10/site-packages/sympy/logic/algorithms/pycosat_wrapper.py
new file mode 100644
index 0000000000000000000000000000000000000000..5ff498b7e3f6b73d95e9b949598ef32df4ecf226
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/logic/algorithms/pycosat_wrapper.py
@@ -0,0 +1,41 @@
+from sympy.assumptions.cnf import EncodedCNF
+
+
+def pycosat_satisfiable(expr, all_models=False):
+    import pycosat
+    if not isinstance(expr, EncodedCNF):
+        exprs = EncodedCNF()
+        exprs.add_prop(expr)
+        expr = exprs
+
+    # Return UNSAT when False (encoded as 0) is present in the CNF
+    if {0} in expr.data:
+        if all_models:
+            return (f for f in [False])
+        return False
+
+    if not all_models:
+        r = pycosat.solve(expr.data)
+        result = (r != "UNSAT")
+        if not result:
+            return result
+        return {expr.symbols[abs(lit) - 1]: lit > 0 for lit in r}
+    else:
+        r = pycosat.itersolve(expr.data)
+        result = (r != "UNSAT")
+        if not result:
+            return result
+
+        # Make solutions SymPy compatible by creating a generator
+        def _gen(results):
+            satisfiable = False
+            try:
+                while True:
+                    sol = next(results)
+                    yield {expr.symbols[abs(lit) - 1]: lit > 0 for lit in sol}
+                    satisfiable = True
+            except StopIteration:
+                if not satisfiable:
+                    yield False
+
+        return _gen(r)
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/__init__.py b/llmeval-env/lib/python3.10/site-packages/sympy/series/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..953653e21856b82bc0b708ccd922efb728a084ed
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/series/__init__.py
@@ -0,0 +1,23 @@
+"""A module that handles series: find a limit, order the series etc.
+"""
+from .order import Order
+from .limits import limit, Limit
+from .gruntz import gruntz
+from .series import series
+from .approximants import approximants
+from .residues import residue
+from .sequences import SeqPer, SeqFormula, sequence, SeqAdd, SeqMul
+from .fourier import fourier_series
+from .formal import fps
+from .limitseq import difference_delta, limit_seq
+
+from sympy.core.singleton import S
+EmptySequence = S.EmptySequence
+
+O = Order
+
+__all__ = ['Order', 'O', 'limit', 'Limit', 'gruntz', 'series', 'approximants',
+        'residue', 'EmptySequence', 'SeqPer', 'SeqFormula', 'sequence',
+        'SeqAdd', 'SeqMul', 'fourier_series', 'fps', 'difference_delta',
+        'limit_seq'
+        ]
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/__init__.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..760ee478ad931a7d2ce845f14616c353bc1b077e
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/__init__.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/acceleration.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/acceleration.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..28f4b2657b88db69bd23906acbc3722b08f74067
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/acceleration.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/approximants.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/approximants.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0ae8d6a6784df9e5c2eff01f9f06c9dabfa3a31d
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/approximants.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/aseries.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/aseries.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d6627bed10fd66b58e7a6e1c6d2d73a557c488c4
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/aseries.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/formal.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/formal.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7712ce56ce08a3d3518bc35dc2064dc8db627704
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/formal.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/fourier.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/fourier.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b72d186c7be364c12a8d38eaae40e01823c01f6f
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/fourier.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/gruntz.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/gruntz.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e7a0e93fd359ea0078da77bdaac30e845aad9149
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/gruntz.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/kauers.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/kauers.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9a8539d6e1112ec99d4ac5f6a8bae2a801637323
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/kauers.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/limits.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/limits.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6de1e744e91f9134c730e12db46e2570afca5c4a
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/limits.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/limitseq.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/limitseq.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d201c4582e0cabad4ef0db713a3bbe06274f0adf
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/limitseq.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/order.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/order.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bd3cad6524fa14403779a418f9bd59a2126e77e9
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/order.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/residues.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/residues.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..56e6b9917bfbe09231d2484891f6f06a4f83c72c
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/residues.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/sequences.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/sequences.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..15d58c281dcc272795c7850e043cffd278608f6a
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/sequences.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/series.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/series.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3136802dc125d0bc9fc70b964f21935ab9070279
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/series.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/series_class.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/series_class.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cd4a66c79a2e8fcca8d94d55d7c5db5155ee4a53
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/__pycache__/series_class.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/approximants.py b/llmeval-env/lib/python3.10/site-packages/sympy/series/approximants.py
new file mode 100644
index 0000000000000000000000000000000000000000..3d54ce41bc7367606ae6260f8e9ac00149cedc0f
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/series/approximants.py
@@ -0,0 +1,103 @@
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.polys.polytools import lcm
+from sympy.utilities import public
+
+@public
+def approximants(l, X=Symbol('x'), simplify=False):
+    """
+    Return a generator for consecutive Pade approximants for a series.
+    It can also be used for computing the rational generating function of a
+    series when possible, since the last approximant returned by the generator
+    will be the generating function (if any).
+
+    Explanation
+    ===========
+
+    The input list can contain more complex expressions than integer or rational
+    numbers; symbols may also be involved in the computation. An example below
+    show how to compute the generating function of the whole Pascal triangle.
+
+    The generator can be asked to apply the sympy.simplify function on each
+    generated term, which will make the computation slower; however it may be
+    useful when symbols are involved in the expressions.
+
+    Examples
+    ========
+
+    >>> from sympy.series import approximants
+    >>> from sympy import lucas, fibonacci, symbols, binomial
+    >>> g = [lucas(k) for k in range(16)]
+    >>> [e for e in approximants(g)]
+    [2, -4/(x - 2), (5*x - 2)/(3*x - 1), (x - 2)/(x**2 + x - 1)]
+
+    >>> h = [fibonacci(k) for k in range(16)]
+    >>> [e for e in approximants(h)]
+    [x, -x/(x - 1), (x**2 - x)/(2*x - 1), -x/(x**2 + x - 1)]
+
+    >>> x, t = symbols("x,t")
+    >>> p=[sum(binomial(k,i)*x**i for i in range(k+1)) for k in range(16)]
+    >>> y = approximants(p, t)
+    >>> for k in range(3): print(next(y))
+    1
+    (x + 1)/((-x - 1)*(t*(x + 1) + (x + 1)/(-x - 1)))
+    nan
+
+    >>> y = approximants(p, t, simplify=True)
+    >>> for k in range(3): print(next(y))
+    1
+    -1/(t*(x + 1) - 1)
+    nan
+
+    See Also
+    ========
+
+    sympy.concrete.guess.guess_generating_function_rational
+    mpmath.pade
+    """
+    from sympy.simplify import simplify as simp
+    from sympy.simplify.radsimp import denom
+    p1, q1 = [S.One], [S.Zero]
+    p2, q2 = [S.Zero], [S.One]
+    while len(l):
+        b = 0
+        while l[b]==0:
+            b += 1
+            if b == len(l):
+                return
+        m = [S.One/l[b]]
+        for k in range(b+1, len(l)):
+            s = 0
+            for j in range(b, k):
+                s -= l[j+1] * m[b-j-1]
+            m.append(s/l[b])
+        l = m
+        a, l[0] = l[0], 0
+        p = [0] * max(len(p2), b+len(p1))
+        q = [0] * max(len(q2), b+len(q1))
+        for k in range(len(p2)):
+            p[k] = a*p2[k]
+        for k in range(b, b+len(p1)):
+            p[k] += p1[k-b]
+        for k in range(len(q2)):
+            q[k] = a*q2[k]
+        for k in range(b, b+len(q1)):
+            q[k] += q1[k-b]
+        while p[-1]==0: p.pop()
+        while q[-1]==0: q.pop()
+        p1, p2 = p2, p
+        q1, q2 = q2, q
+
+        # yield result
+        c = 1
+        for x in p:
+            c = lcm(c, denom(x))
+        for x in q:
+            c = lcm(c, denom(x))
+        out = ( sum(c*e*X**k for k, e in enumerate(p))
+              / sum(c*e*X**k for k, e in enumerate(q)) )
+        if simplify:
+            yield(simp(out))
+        else:
+            yield out
+    return
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/aseries.py b/llmeval-env/lib/python3.10/site-packages/sympy/series/aseries.py
new file mode 100644
index 0000000000000000000000000000000000000000..dbbe0664e6d43a9329f37789c16c48143eda5413
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/series/aseries.py
@@ -0,0 +1,10 @@
+from sympy.core.sympify import sympify
+
+
+def aseries(expr, x=None, n=6, bound=0, hir=False):
+    """
+    See the docstring of Expr.aseries() for complete details of this wrapper.
+
+    """
+    expr = sympify(expr)
+    return expr.aseries(x, n, bound, hir)
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/benchmarks/__init__.py b/llmeval-env/lib/python3.10/site-packages/sympy/series/benchmarks/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/benchmarks/__pycache__/__init__.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/benchmarks/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4f49fa6745f00d2fdc574018c89e4daa344a2d19
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/benchmarks/__pycache__/__init__.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/benchmarks/__pycache__/bench_limit.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/benchmarks/__pycache__/bench_limit.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..21e8a8cd7e14168f5f766751ab5585e1cf45bce4
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/benchmarks/__pycache__/bench_limit.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/benchmarks/__pycache__/bench_order.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/benchmarks/__pycache__/bench_order.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..24dfd1dfdf7fb76d8b8f7cdd9db61e774acd71e7
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/benchmarks/__pycache__/bench_order.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/benchmarks/bench_limit.py b/llmeval-env/lib/python3.10/site-packages/sympy/series/benchmarks/bench_limit.py
new file mode 100644
index 0000000000000000000000000000000000000000..eafc28328848dad4b3ea433537971f5785253afe
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/series/benchmarks/bench_limit.py
@@ -0,0 +1,9 @@
+from sympy.core.numbers import oo
+from sympy.core.symbol import Symbol
+from sympy.series.limits import limit
+
+x = Symbol('x')
+
+
+def timeit_limit_1x():
+    limit(1/x, x, oo)
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/benchmarks/bench_order.py b/llmeval-env/lib/python3.10/site-packages/sympy/series/benchmarks/bench_order.py
new file mode 100644
index 0000000000000000000000000000000000000000..1c85fa173dfc2a478792de8ab816c23ba9d408ef
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/series/benchmarks/bench_order.py
@@ -0,0 +1,10 @@
+from sympy.core.add import Add
+from sympy.core.symbol import Symbol
+from sympy.series.order import O
+
+x = Symbol('x')
+l = [x**i for i in range(1000)]
+l.append(O(x**1001))
+
+def timeit_order_1x():
+    Add(*l)
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/kauers.py b/llmeval-env/lib/python3.10/site-packages/sympy/series/kauers.py
new file mode 100644
index 0000000000000000000000000000000000000000..9e9645ff15ee5ae3c1d1c8709f76aed1b366f50a
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/series/kauers.py
@@ -0,0 +1,51 @@
+def finite_diff(expression, variable, increment=1):
+    """
+    Takes as input a polynomial expression and the variable used to construct
+    it and returns the difference between function's value when the input is
+    incremented to 1 and the original function value. If you want an increment
+    other than one supply it as a third argument.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y, z
+    >>> from sympy.series.kauers import finite_diff
+    >>> finite_diff(x**2, x)
+    2*x + 1
+    >>> finite_diff(y**3 + 2*y**2 + 3*y + 4, y)
+    3*y**2 + 7*y + 6
+    >>> finite_diff(x**2 + 3*x + 8, x, 2)
+    4*x + 10
+    >>> finite_diff(z**3 + 8*z, z, 3)
+    9*z**2 + 27*z + 51
+    """
+    expression = expression.expand()
+    expression2 = expression.subs(variable, variable + increment)
+    expression2 = expression2.expand()
+    return expression2 - expression
+
+def finite_diff_kauers(sum):
+    """
+    Takes as input a Sum instance and returns the difference between the sum
+    with the upper index incremented by 1 and the original sum. For example,
+    if S(n) is a sum, then finite_diff_kauers will return S(n + 1) - S(n).
+
+    Examples
+    ========
+
+    >>> from sympy.series.kauers import finite_diff_kauers
+    >>> from sympy import Sum
+    >>> from sympy.abc import x, y, m, n, k
+    >>> finite_diff_kauers(Sum(k, (k, 1, n)))
+    n + 1
+    >>> finite_diff_kauers(Sum(1/k, (k, 1, n)))
+    1/(n + 1)
+    >>> finite_diff_kauers(Sum((x*y**2), (x, 1, n), (y, 1, m)))
+    (m + 1)**2*(n + 1)
+    >>> finite_diff_kauers(Sum((x*y), (x, 1, m), (y, 1, n)))
+    (m + 1)*(n + 1)
+    """
+    function = sum.function
+    for l in sum.limits:
+        function = function.subs(l[0], l[- 1] + 1)
+    return function
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/order.py b/llmeval-env/lib/python3.10/site-packages/sympy/series/order.py
new file mode 100644
index 0000000000000000000000000000000000000000..9bf6c83a1119648c93cffa76cf62b33b6f3176bf
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/series/order.py
@@ -0,0 +1,517 @@
+from sympy.core import S, sympify, Expr, Dummy, Add, Mul
+from sympy.core.cache import cacheit
+from sympy.core.containers import Tuple
+from sympy.core.function import Function, PoleError, expand_power_base, expand_log
+from sympy.core.sorting import default_sort_key
+from sympy.functions.elementary.exponential import exp, log
+from sympy.sets.sets import Complement
+from sympy.utilities.iterables import uniq, is_sequence
+
+
+class Order(Expr):
+    r""" Represents the limiting behavior of some function.
+
+    Explanation
+    ===========
+
+    The order of a function characterizes the function based on the limiting
+    behavior of the function as it goes to some limit. Only taking the limit
+    point to be a number is currently supported. This is expressed in
+    big O notation [1]_.
+
+    The formal definition for the order of a function `g(x)` about a point `a`
+    is such that `g(x) = O(f(x))` as `x \rightarrow a` if and only if there
+    exists a `\delta > 0` and an `M > 0` such that `|g(x)| \leq M|f(x)|` for
+    `|x-a| < \delta`.  This is equivalent to `\limsup_{x \rightarrow a}
+    |g(x)/f(x)| < \infty`.
+
+    Let's illustrate it on the following example by taking the expansion of
+    `\sin(x)` about 0:
+
+    .. math ::
+        \sin(x) = x - x^3/3! + O(x^5)
+
+    where in this case `O(x^5) = x^5/5! - x^7/7! + \cdots`. By the definition
+    of `O`, there is a `\delta > 0` and an `M` such that:
+
+    .. math ::
+        |x^5/5! - x^7/7! + ....| <= M|x^5| \text{ for } |x| < \delta
+
+    or by the alternate definition:
+
+    .. math ::
+        \lim_{x \rightarrow 0} | (x^5/5! - x^7/7! + ....) / x^5| < \infty
+
+    which surely is true, because
+
+    .. math ::
+        \lim_{x \rightarrow 0} | (x^5/5! - x^7/7! + ....) / x^5| = 1/5!
+
+
+    As it is usually used, the order of a function can be intuitively thought
+    of representing all terms of powers greater than the one specified. For
+    example, `O(x^3)` corresponds to any terms proportional to `x^3,
+    x^4,\ldots` and any higher power. For a polynomial, this leaves terms
+    proportional to `x^2`, `x` and constants.
+
+    Examples
+    ========
+
+    >>> from sympy import O, oo, cos, pi
+    >>> from sympy.abc import x, y
+
+    >>> O(x + x**2)
+    O(x)
+    >>> O(x + x**2, (x, 0))
+    O(x)
+    >>> O(x + x**2, (x, oo))
+    O(x**2, (x, oo))
+
+    >>> O(1 + x*y)
+    O(1, x, y)
+    >>> O(1 + x*y, (x, 0), (y, 0))
+    O(1, x, y)
+    >>> O(1 + x*y, (x, oo), (y, oo))
+    O(x*y, (x, oo), (y, oo))
+
+    >>> O(1) in O(1, x)
+    True
+    >>> O(1, x) in O(1)
+    False
+    >>> O(x) in O(1, x)
+    True
+    >>> O(x**2) in O(x)
+    True
+
+    >>> O(x)*x
+    O(x**2)
+    >>> O(x) - O(x)
+    O(x)
+    >>> O(cos(x))
+    O(1)
+    >>> O(cos(x), (x, pi/2))
+    O(x - pi/2, (x, pi/2))
+
+    References
+    ==========
+
+    .. [1] `Big O notation <https://en.wikipedia.org/wiki/Big_O_notation>`_
+
+    Notes
+    =====
+
+    In ``O(f(x), x)`` the expression ``f(x)`` is assumed to have a leading
+    term.  ``O(f(x), x)`` is automatically transformed to
+    ``O(f(x).as_leading_term(x),x)``.
+
+        ``O(expr*f(x), x)`` is ``O(f(x), x)``
+
+        ``O(expr, x)`` is ``O(1)``
+
+        ``O(0, x)`` is 0.
+
+    Multivariate O is also supported:
+
+        ``O(f(x, y), x, y)`` is transformed to
+        ``O(f(x, y).as_leading_term(x,y).as_leading_term(y), x, y)``
+
+    In the multivariate case, it is assumed the limits w.r.t. the various
+    symbols commute.
+
+    If no symbols are passed then all symbols in the expression are used
+    and the limit point is assumed to be zero.
+
+    """
+
+    is_Order = True
+
+    __slots__ = ()
+
+    @cacheit
+    def __new__(cls, expr, *args, **kwargs):
+        expr = sympify(expr)
+
+        if not args:
+            if expr.is_Order:
+                variables = expr.variables
+                point = expr.point
+            else:
+                variables = list(expr.free_symbols)
+                point = [S.Zero]*len(variables)
+        else:
+            args = list(args if is_sequence(args) else [args])
+            variables, point = [], []
+            if is_sequence(args[0]):
+                for a in args:
+                    v, p = list(map(sympify, a))
+                    variables.append(v)
+                    point.append(p)
+            else:
+                variables = list(map(sympify, args))
+                point = [S.Zero]*len(variables)
+
+        if not all(v.is_symbol for v in variables):
+            raise TypeError('Variables are not symbols, got %s' % variables)
+
+        if len(list(uniq(variables))) != len(variables):
+            raise ValueError('Variables are supposed to be unique symbols, got %s' % variables)
+
+        if expr.is_Order:
+            expr_vp = dict(expr.args[1:])
+            new_vp = dict(expr_vp)
+            vp = dict(zip(variables, point))
+            for v, p in vp.items():
+                if v in new_vp.keys():
+                    if p != new_vp[v]:
+                        raise NotImplementedError(
+                            "Mixing Order at different points is not supported.")
+                else:
+                    new_vp[v] = p
+            if set(expr_vp.keys()) == set(new_vp.keys()):
+                return expr
+            else:
+                variables = list(new_vp.keys())
+                point = [new_vp[v] for v in variables]
+
+        if expr is S.NaN:
+            return S.NaN
+
+        if any(x in p.free_symbols for x in variables for p in point):
+            raise ValueError('Got %s as a point.' % point)
+
+        if variables:
+            if any(p != point[0] for p in point):
+                raise NotImplementedError(
+                    "Multivariable orders at different points are not supported.")
+            if point[0] in (S.Infinity, S.Infinity*S.ImaginaryUnit):
+                s = {k: 1/Dummy() for k in variables}
+                rs = {1/v: 1/k for k, v in s.items()}
+                ps = [S.Zero for p in point]
+            elif point[0] in (S.NegativeInfinity, S.NegativeInfinity*S.ImaginaryUnit):
+                s = {k: -1/Dummy() for k in variables}
+                rs = {-1/v: -1/k for k, v in s.items()}
+                ps = [S.Zero for p in point]
+            elif point[0] is not S.Zero:
+                s = {k: Dummy() + point[0] for k in variables}
+                rs = {(v - point[0]).together(): k - point[0] for k, v in s.items()}
+                ps = [S.Zero for p in point]
+            else:
+                s = ()
+                rs = ()
+                ps = list(point)
+
+            expr = expr.subs(s)
+
+            if expr.is_Add:
+                expr = expr.factor()
+
+            if s:
+                args = tuple([r[0] for r in rs.items()])
+            else:
+                args = tuple(variables)
+
+            if len(variables) > 1:
+                # XXX: better way?  We need this expand() to
+                # workaround e.g: expr = x*(x + y).
+                # (x*(x + y)).as_leading_term(x, y) currently returns
+                # x*y (wrong order term!).  That's why we want to deal with
+                # expand()'ed expr (handled in "if expr.is_Add" branch below).
+                expr = expr.expand()
+
+            old_expr = None
+            while old_expr != expr:
+                old_expr = expr
+                if expr.is_Add:
+                    lst = expr.extract_leading_order(args)
+                    expr = Add(*[f.expr for (e, f) in lst])
+
+                elif expr:
+                    try:
+                        expr = expr.as_leading_term(*args)
+                    except PoleError:
+                        if isinstance(expr, Function) or\
+                                all(isinstance(arg, Function) for arg in expr.args):
+                            # It is not possible to simplify an expression
+                            # containing only functions (which raise error on
+                            # call to leading term) further
+                            pass
+                        else:
+                            orders = []
+                            pts = tuple(zip(args, ps))
+                            for arg in expr.args:
+                                try:
+                                    lt = arg.as_leading_term(*args)
+                                except PoleError:
+                                    lt = arg
+                                if lt not in args:
+                                    order = Order(lt)
+                                else:
+                                    order = Order(lt, *pts)
+                                orders.append(order)
+                            if expr.is_Add:
+                                new_expr = Order(Add(*orders), *pts)
+                                if new_expr.is_Add:
+                                    new_expr = Order(Add(*[a.expr for a in new_expr.args]), *pts)
+                                expr = new_expr.expr
+                            elif expr.is_Mul:
+                                expr = Mul(*[a.expr for a in orders])
+                            elif expr.is_Pow:
+                                e = expr.exp
+                                b = expr.base
+                                expr = exp(e * log(b))
+
+                    # It would probably be better to handle this somewhere
+                    # else. This is needed for a testcase in which there is a
+                    # symbol with the assumptions zero=True.
+                    if expr.is_zero:
+                        expr = S.Zero
+                    else:
+                        expr = expr.as_independent(*args, as_Add=False)[1]
+
+                    expr = expand_power_base(expr)
+                    expr = expand_log(expr)
+
+                    if len(args) == 1:
+                        # The definition of O(f(x)) symbol explicitly stated that
+                        # the argument of f(x) is irrelevant.  That's why we can
+                        # combine some power exponents (only "on top" of the
+                        # expression tree for f(x)), e.g.:
+                        # x**p * (-x)**q -> x**(p+q) for real p, q.
+                        x = args[0]
+                        margs = list(Mul.make_args(
+                            expr.as_independent(x, as_Add=False)[1]))
+
+                        for i, t in enumerate(margs):
+                            if t.is_Pow:
+                                b, q = t.args
+                                if b in (x, -x) and q.is_real and not q.has(x):
+                                    margs[i] = x**q
+                                elif b.is_Pow and not b.exp.has(x):
+                                    b, r = b.args
+                                    if b in (x, -x) and r.is_real:
+                                        margs[i] = x**(r*q)
+                                elif b.is_Mul and b.args[0] is S.NegativeOne:
+                                    b = -b
+                                    if b.is_Pow and not b.exp.has(x):
+                                        b, r = b.args
+                                        if b in (x, -x) and r.is_real:
+                                            margs[i] = x**(r*q)
+
+                        expr = Mul(*margs)
+
+            expr = expr.subs(rs)
+
+        if expr.is_Order:
+            expr = expr.expr
+
+        if not expr.has(*variables) and not expr.is_zero:
+            expr = S.One
+
+        # create Order instance:
+        vp = dict(zip(variables, point))
+        variables.sort(key=default_sort_key)
+        point = [vp[v] for v in variables]
+        args = (expr,) + Tuple(*zip(variables, point))
+        obj = Expr.__new__(cls, *args)
+        return obj
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        return self
+
+    @property
+    def expr(self):
+        return self.args[0]
+
+    @property
+    def variables(self):
+        if self.args[1:]:
+            return tuple(x[0] for x in self.args[1:])
+        else:
+            return ()
+
+    @property
+    def point(self):
+        if self.args[1:]:
+            return tuple(x[1] for x in self.args[1:])
+        else:
+            return ()
+
+    @property
+    def free_symbols(self):
+        return self.expr.free_symbols | set(self.variables)
+
+    def _eval_power(b, e):
+        if e.is_Number and e.is_nonnegative:
+            return b.func(b.expr ** e, *b.args[1:])
+        if e == O(1):
+            return b
+        return
+
+    def as_expr_variables(self, order_symbols):
+        if order_symbols is None:
+            order_symbols = self.args[1:]
+        else:
+            if (not all(o[1] == order_symbols[0][1] for o in order_symbols) and
+                    not all(p == self.point[0] for p in self.point)):  # pragma: no cover
+                raise NotImplementedError('Order at points other than 0 '
+                    'or oo not supported, got %s as a point.' % self.point)
+            if order_symbols and order_symbols[0][1] != self.point[0]:
+                raise NotImplementedError(
+                        "Multiplying Order at different points is not supported.")
+            order_symbols = dict(order_symbols)
+            for s, p in dict(self.args[1:]).items():
+                if s not in order_symbols.keys():
+                    order_symbols[s] = p
+            order_symbols = sorted(order_symbols.items(), key=lambda x: default_sort_key(x[0]))
+        return self.expr, tuple(order_symbols)
+
+    def removeO(self):
+        return S.Zero
+
+    def getO(self):
+        return self
+
+    @cacheit
+    def contains(self, expr):
+        r"""
+        Return True if expr belongs to Order(self.expr, \*self.variables).
+        Return False if self belongs to expr.
+        Return None if the inclusion relation cannot be determined
+        (e.g. when self and expr have different symbols).
+        """
+        expr = sympify(expr)
+        if expr.is_zero:
+            return True
+        if expr is S.NaN:
+            return False
+        point = self.point[0] if self.point else S.Zero
+        if expr.is_Order:
+            if (any(p != point for p in expr.point) or
+                   any(p != point for p in self.point)):
+                return None
+            if expr.expr == self.expr:
+                # O(1) + O(1), O(1) + O(1, x), etc.
+                return all(x in self.args[1:] for x in expr.args[1:])
+            if expr.expr.is_Add:
+                return all(self.contains(x) for x in expr.expr.args)
+            if self.expr.is_Add and point.is_zero:
+                return any(self.func(x, *self.args[1:]).contains(expr)
+                            for x in self.expr.args)
+            if self.variables and expr.variables:
+                common_symbols = tuple(
+                    [s for s in self.variables if s in expr.variables])
+            elif self.variables:
+                common_symbols = self.variables
+            else:
+                common_symbols = expr.variables
+            if not common_symbols:
+                return None
+            if (self.expr.is_Pow and len(self.variables) == 1
+                and self.variables == expr.variables):
+                    symbol = self.variables[0]
+                    other = expr.expr.as_independent(symbol, as_Add=False)[1]
+                    if (other.is_Pow and other.base == symbol and
+                        self.expr.base == symbol):
+                            if point.is_zero:
+                                rv = (self.expr.exp - other.exp).is_nonpositive
+                            if point.is_infinite:
+                                rv = (self.expr.exp - other.exp).is_nonnegative
+                            if rv is not None:
+                                return rv
+
+            from sympy.simplify.powsimp import powsimp
+            r = None
+            ratio = self.expr/expr.expr
+            ratio = powsimp(ratio, deep=True, combine='exp')
+            for s in common_symbols:
+                from sympy.series.limits import Limit
+                l = Limit(ratio, s, point).doit(heuristics=False)
+                if not isinstance(l, Limit):
+                    l = l != 0
+                else:
+                    l = None
+                if r is None:
+                    r = l
+                else:
+                    if r != l:
+                        return
+            return r
+
+        if self.expr.is_Pow and len(self.variables) == 1:
+            symbol = self.variables[0]
+            other = expr.as_independent(symbol, as_Add=False)[1]
+            if (other.is_Pow and other.base == symbol and
+                self.expr.base == symbol):
+                    if point.is_zero:
+                        rv = (self.expr.exp - other.exp).is_nonpositive
+                    if point.is_infinite:
+                        rv = (self.expr.exp - other.exp).is_nonnegative
+                    if rv is not None:
+                        return rv
+
+        obj = self.func(expr, *self.args[1:])
+        return self.contains(obj)
+
+    def __contains__(self, other):
+        result = self.contains(other)
+        if result is None:
+            raise TypeError('contains did not evaluate to a bool')
+        return result
+
+    def _eval_subs(self, old, new):
+        if old in self.variables:
+            newexpr = self.expr.subs(old, new)
+            i = self.variables.index(old)
+            newvars = list(self.variables)
+            newpt = list(self.point)
+            if new.is_symbol:
+                newvars[i] = new
+            else:
+                syms = new.free_symbols
+                if len(syms) == 1 or old in syms:
+                    if old in syms:
+                        var = self.variables[i]
+                    else:
+                        var = syms.pop()
+                    # First, try to substitute self.point in the "new"
+                    # expr to see if this is a fixed point.
+                    # E.g.  O(y).subs(y, sin(x))
+                    point = new.subs(var, self.point[i])
+                    if point != self.point[i]:
+                        from sympy.solvers.solveset import solveset
+                        d = Dummy()
+                        sol = solveset(old - new.subs(var, d), d)
+                        if isinstance(sol, Complement):
+                            e1 = sol.args[0]
+                            e2 = sol.args[1]
+                            sol = set(e1) - set(e2)
+                        res = [dict(zip((d, ), sol))]
+                        point = d.subs(res[0]).limit(old, self.point[i])
+                    newvars[i] = var
+                    newpt[i] = point
+                elif old not in syms:
+                    del newvars[i], newpt[i]
+                    if not syms and new == self.point[i]:
+                        newvars.extend(syms)
+                        newpt.extend([S.Zero]*len(syms))
+                else:
+                    return
+            return Order(newexpr, *zip(newvars, newpt))
+
+    def _eval_conjugate(self):
+        expr = self.expr._eval_conjugate()
+        if expr is not None:
+            return self.func(expr, *self.args[1:])
+
+    def _eval_derivative(self, x):
+        return self.func(self.expr.diff(x), *self.args[1:]) or self
+
+    def _eval_transpose(self):
+        expr = self.expr._eval_transpose()
+        if expr is not None:
+            return self.func(expr, *self.args[1:])
+
+    def __neg__(self):
+        return self
+
+O = Order
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/residues.py b/llmeval-env/lib/python3.10/site-packages/sympy/series/residues.py
new file mode 100644
index 0000000000000000000000000000000000000000..a426f9e799bd040eea5124f718c2fa43e5de026b
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/series/residues.py
@@ -0,0 +1,73 @@
+"""
+This module implements the Residue function and related tools for working
+with residues.
+"""
+
+from sympy.core.mul import Mul
+from sympy.core.singleton import S
+from sympy.core.sympify import sympify
+from sympy.utilities.timeutils import timethis
+
+
+@timethis('residue')
+def residue(expr, x, x0):
+    """
+    Finds the residue of ``expr`` at the point x=x0.
+
+    The residue is defined as the coefficient of ``1/(x-x0)`` in the power series
+    expansion about ``x=x0``.
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, residue, sin
+    >>> x = Symbol("x")
+    >>> residue(1/x, x, 0)
+    1
+    >>> residue(1/x**2, x, 0)
+    0
+    >>> residue(2/sin(x), x, 0)
+    2
+
+    This function is essential for the Residue Theorem [1].
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Residue_theorem
+    """
+    # The current implementation uses series expansion to
+    # calculate it. A more general implementation is explained in
+    # the section 5.6 of the Bronstein's book {M. Bronstein:
+    # Symbolic Integration I, Springer Verlag (2005)}. For purely
+    # rational functions, the algorithm is much easier. See
+    # sections 2.4, 2.5, and 2.7 (this section actually gives an
+    # algorithm for computing any Laurent series coefficient for
+    # a rational function). The theory in section 2.4 will help to
+    # understand why the resultant works in the general algorithm.
+    # For the definition of a resultant, see section 1.4 (and any
+    # previous sections for more review).
+
+    from sympy.series.order import Order
+    from sympy.simplify.radsimp import collect
+    expr = sympify(expr)
+    if x0 != 0:
+        expr = expr.subs(x, x + x0)
+    for n in (0, 1, 2, 4, 8, 16, 32):
+        s = expr.nseries(x, n=n)
+        if not s.has(Order) or s.getn() >= 0:
+            break
+    s = collect(s.removeO(), x)
+    if s.is_Add:
+        args = s.args
+    else:
+        args = [s]
+    res = S.Zero
+    for arg in args:
+        c, m = arg.as_coeff_mul(x)
+        m = Mul(*m)
+        if not (m in (S.One, x) or (m.is_Pow and m.exp.is_Integer)):
+            raise NotImplementedError('term of unexpected form: %s' % m)
+        if m == 1/x:
+            res += c
+    return res
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__init__.py b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/__init__.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6235ef3f29446e1e29d236298ae0d11e8b98b151
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/__init__.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_approximants.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_approximants.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e7686130337ca3171ba77b6e907b3e2e0886c2cb
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_approximants.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_aseries.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_aseries.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..61cb9837f5566505a1f1a6f0e1a908bef7897540
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_aseries.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_demidovich.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_demidovich.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1ab7a63a88366c9bb683386f51d47c4a491c44cc
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_demidovich.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_formal.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_formal.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dfdcf3d4389821b210c01156ef3e01cd8cbbf3fe
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_formal.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_fourier.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_fourier.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bcff076ac61e6cc16f39fa18467ad01b05159c60
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_fourier.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_gruntz.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_gruntz.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..215e4d88e93f454566468b9b68ef868b5836b68a
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_gruntz.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_kauers.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_kauers.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..86573af66687b9efef1c202732fc41d787666e8f
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_kauers.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_limits.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_limits.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0b73fcb7731fb5d1e77443d475de8504e79d0881
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_limits.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_limitseq.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_limitseq.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f95cb01e232dbfdd061c170c7617b0896ee7d944
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_limitseq.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_lseries.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_lseries.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7dc93eec36aa9cf002229b9ccdf430beee6ce323
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_lseries.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_nseries.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_nseries.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fe650f2d995c3d0d2c76cdef97b8e225df768698
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_nseries.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_order.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_order.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3f79a106cc71bea51c60ae2ad81a59d3f5c0e067
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_order.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_residues.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_residues.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4106cb1cca89c34183f612487c5a6eca88e5d53e
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_residues.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_sequences.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_sequences.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..93c70237bf2b62416cdf7309291c661fc735e437
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_sequences.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_series.cpython-310.pyc b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_series.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..56f56a3ce6cd0af3de4476420b3ef78a6c7ec77f
Binary files /dev/null and b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/__pycache__/test_series.cpython-310.pyc differ
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_approximants.py b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_approximants.py
new file mode 100644
index 0000000000000000000000000000000000000000..9c03d2ce38add99b0dce8725b6c8d8844b31f76b
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_approximants.py
@@ -0,0 +1,23 @@
+from sympy.series import approximants
+from sympy.core.symbol import symbols
+from sympy.functions.combinatorial.factorials import binomial
+from sympy.functions.combinatorial.numbers import (fibonacci, lucas)
+
+
+def test_approximants():
+    x, t = symbols("x,t")
+    g = [lucas(k) for k in range(16)]
+    assert list(approximants(g)) == (
+        [2, -4/(x - 2), (5*x - 2)/(3*x - 1), (x - 2)/(x**2 + x - 1)] )
+    g = [lucas(k)+fibonacci(k+2) for k in range(16)]
+    assert list(approximants(g)) == (
+        [3, -3/(x - 1), (3*x - 3)/(2*x - 1), -3/(x**2 + x - 1)] )
+    g = [lucas(k)**2 for k in range(16)]
+    assert list(approximants(g)) == (
+        [4, -16/(x - 4), (35*x - 4)/(9*x - 1), (37*x - 28)/(13*x**2 + 11*x - 7),
+        (50*x**2 + 63*x - 52)/(37*x**2 + 19*x - 13),
+        (-x**2 - 7*x + 4)/(x**3 - 2*x**2 - 2*x + 1)] )
+    p = [sum(binomial(k,i)*x**i for i in range(k+1)) for k in range(16)]
+    y = approximants(p, t, simplify=True)
+    assert next(y) == 1
+    assert next(y) == -1/(t*(x + 1) - 1)
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_aseries.py b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_aseries.py
new file mode 100644
index 0000000000000000000000000000000000000000..055d6b8aef23212a8c8f19475f537a5a2b9e2b1b
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_aseries.py
@@ -0,0 +1,56 @@
+from sympy.core.function import PoleError
+from sympy.core.numbers import oo
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.series.order import O
+from sympy.abc import x
+
+from sympy.testing.pytest import raises
+
+def test_simple():
+    # Gruntz' theses pp. 91 to 96
+    # 6.6
+    e = sin(1/x + exp(-x)) - sin(1/x)
+    assert e.aseries(x) == (1/(24*x**4) - 1/(2*x**2) + 1 + O(x**(-6), (x, oo)))*exp(-x)
+
+    e = exp(x) * (exp(1/x + exp(-x)) - exp(1/x))
+    assert e.aseries(x, n=4) == 1/(6*x**3) + 1/(2*x**2) + 1/x + 1 + O(x**(-4), (x, oo))
+
+    e = exp(exp(x) / (1 - 1/x))
+    assert e.aseries(x) == exp(exp(x) / (1 - 1/x))
+
+    # The implementation of bound in aseries is incorrect currently. This test
+    # should be commented out when that is fixed.
+    # assert e.aseries(x, bound=3) == exp(exp(x) / x**2)*exp(exp(x) / x)*exp(-exp(x) + exp(x)/(1 - 1/x) - \
+    #         exp(x) / x - exp(x) / x**2) * exp(exp(x))
+
+    e = exp(sin(1/x + exp(-exp(x)))) - exp(sin(1/x))
+    assert e.aseries(x, n=4) == (-1/(2*x**3) + 1/x + 1 + O(x**(-4), (x, oo)))*exp(-exp(x))
+
+    e3 = lambda x:exp(exp(exp(x)))
+    e = e3(x)/e3(x - 1/e3(x))
+    assert e.aseries(x, n=3) == 1 + exp(x + exp(x))*exp(-exp(exp(x)))\
+            + ((-exp(x)/2 - S.Half)*exp(x + exp(x))\
+            + exp(2*x + 2*exp(x))/2)*exp(-2*exp(exp(x))) + O(exp(-3*exp(exp(x))), (x, oo))
+
+    e = exp(exp(x)) * (exp(sin(1/x + 1/exp(exp(x)))) - exp(sin(1/x)))
+    assert e.aseries(x, n=4) == -1/(2*x**3) + 1/x + 1 + O(x**(-4), (x, oo))
+
+    n = Symbol('n', integer=True)
+    e = (sqrt(n)*log(n)**2*exp(sqrt(log(n))*log(log(n))**2*exp(sqrt(log(log(n)))*log(log(log(n)))**3)))/n
+    assert e.aseries(n) == \
+            exp(exp(sqrt(log(log(n)))*log(log(log(n)))**3)*sqrt(log(n))*log(log(n))**2)*log(n)**2/sqrt(n)
+
+
+def test_hierarchical():
+    e = sin(1/x + exp(-x))
+    assert e.aseries(x, n=3, hir=True) == -exp(-2*x)*sin(1/x)/2 + \
+            exp(-x)*cos(1/x) + sin(1/x) + O(exp(-3*x), (x, oo))
+
+    e = sin(x) * cos(exp(-x))
+    assert e.aseries(x, hir=True) == exp(-4*x)*sin(x)/24 - \
+            exp(-2*x)*sin(x)/2 + sin(x) + O(exp(-6*x), (x, oo))
+    raises(PoleError, lambda: e.aseries(x))
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_demidovich.py b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_demidovich.py
new file mode 100644
index 0000000000000000000000000000000000000000..98cafbae6f019dd3d97d306099d5780ed2f37f04
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_demidovich.py
@@ -0,0 +1,143 @@
+from sympy.core.numbers import (Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import (root, sqrt)
+from sympy.functions.elementary.trigonometric import (asin, cos, sin, tan)
+from sympy.polys.rationaltools import together
+from sympy.series.limits import limit
+
+# Numbers listed with the tests refer to problem numbers in the book
+# "Anti-demidovich, problemas resueltos, Ed. URSS"
+
+x = Symbol("x")
+
+
+def test_leadterm():
+    assert (3 + 2*x**(log(3)/log(2) - 1)).leadterm(x) == (3, 0)
+
+
+def root3(x):
+    return root(x, 3)
+
+
+def root4(x):
+    return root(x, 4)
+
+
+def test_Limits_simple_0():
+    assert limit((2**(x + 1) + 3**(x + 1))/(2**x + 3**x), x, oo) == 3  # 175
+
+
+def test_Limits_simple_1():
+    assert limit((x + 1)*(x + 2)*(x + 3)/x**3, x, oo) == 1  # 172
+    assert limit(sqrt(x + 1) - sqrt(x), x, oo) == 0  # 179
+    assert limit((2*x - 3)*(3*x + 5)*(4*x - 6)/(3*x**3 + x - 1), x, oo) == 8  # Primjer 1
+    assert limit(x/root3(x**3 + 10), x, oo) == 1  # Primjer 2
+    assert limit((x + 1)**2/(x**2 + 1), x, oo) == 1  # 181
+
+
+def test_Limits_simple_2():
+    assert limit(1000*x/(x**2 - 1), x, oo) == 0  # 182
+    assert limit((x**2 - 5*x + 1)/(3*x + 7), x, oo) is oo  # 183
+    assert limit((2*x**2 - x + 3)/(x**3 - 8*x + 5), x, oo) == 0  # 184
+    assert limit((2*x**2 - 3*x - 4)/sqrt(x**4 + 1), x, oo) == 2  # 186
+    assert limit((2*x + 3)/(x + root3(x)), x, oo) == 2  # 187
+    assert limit(x**2/(10 + x*sqrt(x)), x, oo) is oo  # 188
+    assert limit(root3(x**2 + 1)/(x + 1), x, oo) == 0  # 189
+    assert limit(sqrt(x)/sqrt(x + sqrt(x + sqrt(x))), x, oo) == 1  # 190
+
+
+def test_Limits_simple_3a():
+    a = Symbol('a')
+    #issue 3513
+    assert together(limit((x**2 - (a + 1)*x + a)/(x**3 - a**3), x, a)) == \
+        (a - 1)/(3*a**2)  # 196
+
+
+def test_Limits_simple_3b():
+    h = Symbol("h")
+    assert limit(((x + h)**3 - x**3)/h, h, 0) == 3*x**2  # 197
+    assert limit((1/(1 - x) - 3/(1 - x**3)), x, 1) == -1  # 198
+    assert limit((sqrt(1 + x) - 1)/(root3(1 + x) - 1), x, 0) == Rational(3)/2  # Primer 4
+    assert limit((sqrt(x) - 1)/(x - 1), x, 1) == Rational(1)/2  # 199
+    assert limit((sqrt(x) - 8)/(root3(x) - 4), x, 64) == 3  # 200
+    assert limit((root3(x) - 1)/(root4(x) - 1), x, 1) == Rational(4)/3  # 201
+    assert limit(
+        (root3(x**2) - 2*root3(x) + 1)/(x - 1)**2, x, 1) == Rational(1)/9  # 202
+
+
+def test_Limits_simple_4a():
+    a = Symbol('a')
+    assert limit((sqrt(x) - sqrt(a))/(x - a), x, a) == 1/(2*sqrt(a))  # Primer 5
+    assert limit((sqrt(x) - 1)/(root3(x) - 1), x, 1) == Rational(3, 2)  # 205
+    assert limit((sqrt(1 + x) - sqrt(1 - x))/x, x, 0) == 1  # 207
+    assert limit(sqrt(x**2 - 5*x + 6) - x, x, oo) == Rational(-5, 2)  # 213
+
+
+def test_limits_simple_4aa():
+    assert limit(x*(sqrt(x**2 + 1) - x), x, oo) == Rational(1)/2  # 214
+
+
+def test_Limits_simple_4b():
+    #issue 3511
+    assert limit(x - root3(x**3 - 1), x, oo) == 0  # 215
+
+
+def test_Limits_simple_4c():
+    assert limit(log(1 + exp(x))/x, x, -oo) == 0  # 267a
+    assert limit(log(1 + exp(x))/x, x, oo) == 1  # 267b
+
+
+def test_bounded():
+    assert limit(sin(x)/x, x, oo) == 0  # 216b
+    assert limit(x*sin(1/x), x, 0) == 0  # 227a
+
+
+def test_f1a():
+    #issue 3508:
+    assert limit((sin(2*x)/x)**(1 + x), x, 0) == 2  # Primer 7
+
+
+def test_f1a2():
+    #issue 3509:
+    assert limit(((x - 1)/(x + 1))**x, x, oo) == exp(-2)  # Primer 9
+
+
+def test_f1b():
+    m = Symbol("m")
+    n = Symbol("n")
+    h = Symbol("h")
+    a = Symbol("a")
+    assert limit(sin(x)/x, x, 2) == sin(2)/2  # 216a
+    assert limit(sin(3*x)/x, x, 0) == 3  # 217
+    assert limit(sin(5*x)/sin(2*x), x, 0) == Rational(5, 2)  # 218
+    assert limit(sin(pi*x)/sin(3*pi*x), x, 0) == Rational(1, 3)  # 219
+    assert limit(x*sin(pi/x), x, oo) == pi  # 220
+    assert limit((1 - cos(x))/x**2, x, 0) == S.Half  # 221
+    assert limit(x*sin(1/x), x, oo) == 1  # 227b
+    assert limit((cos(m*x) - cos(n*x))/x**2, x, 0) == -m**2/2 + n**2/2  # 232
+    assert limit((tan(x) - sin(x))/x**3, x, 0) == S.Half  # 233
+    assert limit((x - sin(2*x))/(x + sin(3*x)), x, 0) == -Rational(1, 4)  # 237
+    assert limit((1 - sqrt(cos(x)))/x**2, x, 0) == Rational(1, 4)  # 239
+    assert limit((sqrt(1 + sin(x)) - sqrt(1 - sin(x)))/x, x, 0) == 1  # 240
+
+    assert limit((1 + h/x)**x, x, oo) == exp(h)  # Primer 9
+    assert limit((sin(x) - sin(a))/(x - a), x, a) == cos(a)  # 222, *176
+    assert limit((cos(x) - cos(a))/(x - a), x, a) == -sin(a)  # 223
+    assert limit((sin(x + h) - sin(x))/h, h, 0) == cos(x)  # 225
+
+
+def test_f2a():
+    assert limit(((x + 1)/(2*x + 1))**(x**2), x, oo) == 0  # Primer 8
+
+
+def test_f2():
+    assert limit((sqrt(
+        cos(x)) - root3(cos(x)))/(sin(x)**2), x, 0) == -Rational(1, 12)  # *184
+
+
+def test_f3():
+    a = Symbol('a')
+    #issue 3504
+    assert limit(asin(a*x)/x, x, 0) == a
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_formal.py b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_formal.py
new file mode 100644
index 0000000000000000000000000000000000000000..0a28418fbb326ce3aa973eecaf8c3b1231f6c767
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_formal.py
@@ -0,0 +1,618 @@
+from sympy.concrete.summations import Sum
+from sympy.core.add import Add
+from sympy.core.function import (Derivative, Function)
+from sympy.core.mul import Mul
+from sympy.core.numbers import (I, Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.hyperbolic import (acosh, asech)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (acos, asin, atan, cos, sin)
+from sympy.functions.special.bessel import airyai
+from sympy.functions.special.error_functions import erf
+from sympy.functions.special.gamma_functions import gamma
+from sympy.integrals.integrals import integrate
+from sympy.series.formal import fps
+from sympy.series.order import O
+from sympy.series.formal import (rational_algorithm, FormalPowerSeries,
+                                 FormalPowerSeriesProduct, FormalPowerSeriesCompose,
+                                 FormalPowerSeriesInverse, simpleDE,
+                                 rational_independent, exp_re, hyper_re)
+from sympy.testing.pytest import raises, XFAIL, slow
+
+x, y, z = symbols('x y z')
+n, m, k = symbols('n m k', integer=True)
+f, r = Function('f'), Function('r')
+
+
+def test_rational_algorithm():
+    f = 1 / ((x - 1)**2 * (x - 2))
+    assert rational_algorithm(f, x, k) == \
+        (-2**(-k - 1) + 1 - (factorial(k + 1) / factorial(k)), 0, 0)
+
+    f = (1 + x + x**2 + x**3) / ((x - 1) * (x - 2))
+    assert rational_algorithm(f, x, k) == \
+        (-15*2**(-k - 1) + 4, x + 4, 0)
+
+    f = z / (y*m - m*x - y*x + x**2)
+    assert rational_algorithm(f, x, k) == \
+        (((-y**(-k - 1)*z) / (y - m)) + ((m**(-k - 1)*z) / (y - m)), 0, 0)
+
+    f = x / (1 - x - x**2)
+    assert rational_algorithm(f, x, k) is None
+    assert rational_algorithm(f, x, k, full=True) == \
+        (((Rational(-1, 2) + sqrt(5)/2)**(-k - 1) *
+         (-sqrt(5)/10 + S.Half)) +
+         ((-sqrt(5)/2 - S.Half)**(-k - 1) *
+         (sqrt(5)/10 + S.Half)), 0, 0)
+
+    f = 1 / (x**2 + 2*x + 2)
+    assert rational_algorithm(f, x, k) is None
+    assert rational_algorithm(f, x, k, full=True) == \
+        ((I*(-1 + I)**(-k - 1)) / 2 - (I*(-1 - I)**(-k - 1)) / 2, 0, 0)
+
+    f = log(1 + x)
+    assert rational_algorithm(f, x, k) == \
+        (-(-1)**(-k) / k, 0, 1)
+
+    f = atan(x)
+    assert rational_algorithm(f, x, k) is None
+    assert rational_algorithm(f, x, k, full=True) == \
+        (((I*I**(-k)) / 2 - (I*(-I)**(-k)) / 2) / k, 0, 1)
+
+    f = x*atan(x) - log(1 + x**2) / 2
+    assert rational_algorithm(f, x, k) is None
+    assert rational_algorithm(f, x, k, full=True) == \
+        (((I*I**(-k + 1)) / 2 - (I*(-I)**(-k + 1)) / 2) /
+         (k*(k - 1)), 0, 2)
+
+    f = log((1 + x) / (1 - x)) / 2 - atan(x)
+    assert rational_algorithm(f, x, k) is None
+    assert rational_algorithm(f, x, k, full=True) == \
+        ((-(-1)**(-k) / 2 - (I*I**(-k)) / 2 + (I*(-I)**(-k)) / 2 +
+          S.Half) / k, 0, 1)
+
+    assert rational_algorithm(cos(x), x, k) is None
+
+
+def test_rational_independent():
+    ri = rational_independent
+    assert ri([], x) == []
+    assert ri([cos(x), sin(x)], x) == [cos(x), sin(x)]
+    assert ri([x**2, sin(x), x*sin(x), x**3], x) == \
+        [x**3 + x**2, x*sin(x) + sin(x)]
+    assert ri([S.One, x*log(x), log(x), sin(x)/x, cos(x), sin(x), x], x) == \
+        [x + 1, x*log(x) + log(x), sin(x)/x + sin(x), cos(x)]
+
+
+def test_simpleDE():
+    # Tests just the first valid DE
+    for DE in simpleDE(exp(x), x, f):
+        assert DE == (-f(x) + Derivative(f(x), x), 1)
+        break
+    for DE in simpleDE(sin(x), x, f):
+        assert DE == (f(x) + Derivative(f(x), x, x), 2)
+        break
+    for DE in simpleDE(log(1 + x), x, f):
+        assert DE == ((x + 1)*Derivative(f(x), x, 2) + Derivative(f(x), x), 2)
+        break
+    for DE in simpleDE(asin(x), x, f):
+        assert DE == (x*Derivative(f(x), x) + (x**2 - 1)*Derivative(f(x), x, x),
+                      2)
+        break
+    for DE in simpleDE(exp(x)*sin(x), x, f):
+        assert DE == (2*f(x) - 2*Derivative(f(x)) + Derivative(f(x), x, x), 2)
+        break
+    for DE in simpleDE(((1 + x)/(1 - x))**n, x, f):
+        assert DE == (2*n*f(x) + (x**2 - 1)*Derivative(f(x), x), 1)
+        break
+    for DE in simpleDE(airyai(x), x, f):
+        assert DE == (-x*f(x) + Derivative(f(x), x, x), 2)
+        break
+
+
+def test_exp_re():
+    d = -f(x) + Derivative(f(x), x)
+    assert exp_re(d, r, k) == -r(k) + r(k + 1)
+
+    d = f(x) + Derivative(f(x), x, x)
+    assert exp_re(d, r, k) == r(k) + r(k + 2)
+
+    d = f(x) + Derivative(f(x), x) + Derivative(f(x), x, x)
+    assert exp_re(d, r, k) == r(k) + r(k + 1) + r(k + 2)
+
+    d = Derivative(f(x), x) + Derivative(f(x), x, x)
+    assert exp_re(d, r, k) == r(k) + r(k + 1)
+
+    d = Derivative(f(x), x, 3) + Derivative(f(x), x, 4) + Derivative(f(x))
+    assert exp_re(d, r, k) == r(k) + r(k + 2) + r(k + 3)
+
+
+def test_hyper_re():
+    d = f(x) + Derivative(f(x), x, x)
+    assert hyper_re(d, r, k) == r(k) + (k+1)*(k+2)*r(k + 2)
+
+    d = -x*f(x) + Derivative(f(x), x, x)
+    assert hyper_re(d, r, k) == (k + 2)*(k + 3)*r(k + 3) - r(k)
+
+    d = 2*f(x) - 2*Derivative(f(x), x) + Derivative(f(x), x, x)
+    assert hyper_re(d, r, k) == \
+        (-2*k - 2)*r(k + 1) + (k + 1)*(k + 2)*r(k + 2) + 2*r(k)
+
+    d = 2*n*f(x) + (x**2 - 1)*Derivative(f(x), x)
+    assert hyper_re(d, r, k) == \
+        k*r(k) + 2*n*r(k + 1) + (-k - 2)*r(k + 2)
+
+    d = (x**10 + 4)*Derivative(f(x), x) + x*(x**10 - 1)*Derivative(f(x), x, x)
+    assert hyper_re(d, r, k) == \
+        (k*(k - 1) + k)*r(k) + (4*k - (k + 9)*(k + 10) + 40)*r(k + 10)
+
+    d = ((x**2 - 1)*Derivative(f(x), x, 3) + 3*x*Derivative(f(x), x, x) +
+         Derivative(f(x), x))
+    assert hyper_re(d, r, k) == \
+        ((k*(k - 2)*(k - 1) + 3*k*(k - 1) + k)*r(k) +
+         (-k*(k + 1)*(k + 2))*r(k + 2))
+
+
+def test_fps():
+    assert fps(1) == 1
+    assert fps(2, x) == 2
+    assert fps(2, x, dir='+') == 2
+    assert fps(2, x, dir='-') == 2
+    assert fps(1/x + 1/x**2) == 1/x + 1/x**2
+    assert fps(log(1 + x), hyper=False, rational=False) == log(1 + x)
+
+    f = fps(x**2 + x + 1)
+    assert isinstance(f, FormalPowerSeries)
+    assert f.function == x**2 + x + 1
+    assert f[0] == 1
+    assert f[2] == x**2
+    assert f.truncate(4) == x**2 + x + 1 + O(x**4)
+    assert f.polynomial() == x**2 + x + 1
+
+    f = fps(log(1 + x))
+    assert isinstance(f, FormalPowerSeries)
+    assert f.function == log(1 + x)
+    assert f.subs(x, y) == f
+    assert f[:5] == [0, x, -x**2/2, x**3/3, -x**4/4]
+    assert f.as_leading_term(x) == x
+    assert f.polynomial(6) == x - x**2/2 + x**3/3 - x**4/4 + x**5/5
+
+    k = f.ak.variables[0]
+    assert f.infinite == Sum((-(-1)**(-k)*x**k)/k, (k, 1, oo))
+
+    ft, s = f.truncate(n=None), f[:5]
+    for i, t in enumerate(ft):
+        if i == 5:
+            break
+        assert s[i] == t
+
+    f = sin(x).fps(x)
+    assert isinstance(f, FormalPowerSeries)
+    assert f.truncate() == x - x**3/6 + x**5/120 + O(x**6)
+
+    raises(NotImplementedError, lambda: fps(y*x))
+    raises(ValueError, lambda: fps(x, dir=0))
+
+
+@slow
+def test_fps__rational():
+    assert fps(1/x) == (1/x)
+    assert fps((x**2 + x + 1) / x**3, dir=-1) == (x**2 + x + 1) / x**3
+
+    f = 1 / ((x - 1)**2 * (x - 2))
+    assert fps(f, x).truncate() == \
+        (Rational(-1, 2) - x*Rational(5, 4) - 17*x**2/8 - 49*x**3/16 - 129*x**4/32 -
+         321*x**5/64 + O(x**6))
+
+    f = (1 + x + x**2 + x**3) / ((x - 1) * (x - 2))
+    assert fps(f, x).truncate() == \
+        (S.Half + x*Rational(5, 4) + 17*x**2/8 + 49*x**3/16 + 113*x**4/32 +
+         241*x**5/64 + O(x**6))
+
+    f = x / (1 - x - x**2)
+    assert fps(f, x, full=True).truncate() == \
+        x + x**2 + 2*x**3 + 3*x**4 + 5*x**5 + O(x**6)
+
+    f = 1 / (x**2 + 2*x + 2)
+    assert fps(f, x, full=True).truncate() == \
+        S.Half - x/2 + x**2/4 - x**4/8 + x**5/8 + O(x**6)
+
+    f = log(1 + x)
+    assert fps(f, x).truncate() == \
+        x - x**2/2 + x**3/3 - x**4/4 + x**5/5 + O(x**6)
+    assert fps(f, x, dir=1).truncate() == fps(f, x, dir=-1).truncate()
+    assert fps(f, x, 2).truncate() == \
+        (log(3) - Rational(2, 3) - (x - 2)**2/18 + (x - 2)**3/81 -
+         (x - 2)**4/324 + (x - 2)**5/1215 + x/3 + O((x - 2)**6, (x, 2)))
+    assert fps(f, x, 2, dir=-1).truncate() == \
+        (log(3) - Rational(2, 3) - (-x + 2)**2/18 - (-x + 2)**3/81 -
+         (-x + 2)**4/324 - (-x + 2)**5/1215 + x/3 + O((x - 2)**6, (x, 2)))
+
+    f = atan(x)
+    assert fps(f, x, full=True).truncate() == x - x**3/3 + x**5/5 + O(x**6)
+    assert fps(f, x, full=True, dir=1).truncate() == \
+        fps(f, x, full=True, dir=-1).truncate()
+    assert fps(f, x, 2, full=True).truncate() == \
+        (atan(2) - Rational(2, 5) - 2*(x - 2)**2/25 + 11*(x - 2)**3/375 -
+         6*(x - 2)**4/625 + 41*(x - 2)**5/15625 + x/5 + O((x - 2)**6, (x, 2)))
+    assert fps(f, x, 2, full=True, dir=-1).truncate() == \
+        (atan(2) - Rational(2, 5) - 2*(-x + 2)**2/25 - 11*(-x + 2)**3/375 -
+         6*(-x + 2)**4/625 - 41*(-x + 2)**5/15625 + x/5 + O((x - 2)**6, (x, 2)))
+
+    f = x*atan(x) - log(1 + x**2) / 2
+    assert fps(f, x, full=True).truncate() == x**2/2 - x**4/12 + O(x**6)
+
+    f = log((1 + x) / (1 - x)) / 2 - atan(x)
+    assert fps(f, x, full=True).truncate(n=10) == 2*x**3/3 + 2*x**7/7 + O(x**10)
+
+
+@slow
+def test_fps__hyper():
+    f = sin(x)
+    assert fps(f, x).truncate() == x - x**3/6 + x**5/120 + O(x**6)
+
+    f = cos(x)
+    assert fps(f, x).truncate() == 1 - x**2/2 + x**4/24 + O(x**6)
+
+    f = exp(x)
+    assert fps(f, x).truncate() == \
+        1 + x + x**2/2 + x**3/6 + x**4/24 + x**5/120 + O(x**6)
+
+    f = atan(x)
+    assert fps(f, x).truncate() == x - x**3/3 + x**5/5 + O(x**6)
+
+    f = exp(acos(x))
+    assert fps(f, x).truncate() == \
+        (exp(pi/2) - x*exp(pi/2) + x**2*exp(pi/2)/2 - x**3*exp(pi/2)/3 +
+         5*x**4*exp(pi/2)/24 - x**5*exp(pi/2)/6 + O(x**6))
+
+    f = exp(acosh(x))
+    assert fps(f, x).truncate() == I + x - I*x**2/2 - I*x**4/8 + O(x**6)
+
+    f = atan(1/x)
+    assert fps(f, x).truncate() == pi/2 - x + x**3/3 - x**5/5 + O(x**6)
+
+    f = x*atan(x) - log(1 + x**2) / 2
+    assert fps(f, x, rational=False).truncate() == x**2/2 - x**4/12 + O(x**6)
+
+    f = log(1 + x)
+    assert fps(f, x, rational=False).truncate() == \
+        x - x**2/2 + x**3/3 - x**4/4 + x**5/5 + O(x**6)
+
+    f = airyai(x**2)
+    assert fps(f, x).truncate() == \
+        (3**Rational(5, 6)*gamma(Rational(1, 3))/(6*pi) -
+         3**Rational(2, 3)*x**2/(3*gamma(Rational(1, 3))) + O(x**6))
+
+    f = exp(x)*sin(x)
+    assert fps(f, x).truncate() == x + x**2 + x**3/3 - x**5/30 + O(x**6)
+
+    f = exp(x)*sin(x)/x
+    assert fps(f, x).truncate() == 1 + x + x**2/3 - x**4/30 - x**5/90 + O(x**6)
+
+    f = sin(x) * cos(x)
+    assert fps(f, x).truncate() == x - 2*x**3/3 + 2*x**5/15 + O(x**6)
+
+
+def test_fps_shift():
+    f = x**-5*sin(x)
+    assert fps(f, x).truncate() == \
+        1/x**4 - 1/(6*x**2) + Rational(1, 120) - x**2/5040 + x**4/362880 + O(x**6)
+
+    f = x**2*atan(x)
+    assert fps(f, x, rational=False).truncate() == \
+        x**3 - x**5/3 + O(x**6)
+
+    f = cos(sqrt(x))*x
+    assert fps(f, x).truncate() == \
+        x - x**2/2 + x**3/24 - x**4/720 + x**5/40320 + O(x**6)
+
+    f = x**2*cos(sqrt(x))
+    assert fps(f, x).truncate() == \
+        x**2 - x**3/2 + x**4/24 - x**5/720 + O(x**6)
+
+
+def test_fps__Add_expr():
+    f = x*atan(x) - log(1 + x**2) / 2
+    assert fps(f, x).truncate() == x**2/2 - x**4/12 + O(x**6)
+
+    f = sin(x) + cos(x) - exp(x) + log(1 + x)
+    assert fps(f, x).truncate() == x - 3*x**2/2 - x**4/4 + x**5/5 + O(x**6)
+
+    f = 1/x + sin(x)
+    assert fps(f, x).truncate() == 1/x + x - x**3/6 + x**5/120 + O(x**6)
+
+    f = sin(x) - cos(x) + 1/(x - 1)
+    assert fps(f, x).truncate() == \
+        -2 - x**2/2 - 7*x**3/6 - 25*x**4/24 - 119*x**5/120 + O(x**6)
+
+
+def test_fps__asymptotic():
+    f = exp(x)
+    assert fps(f, x, oo) == f
+    assert fps(f, x, -oo).truncate() == O(1/x**6, (x, oo))
+
+    f = erf(x)
+    assert fps(f, x, oo).truncate() == 1 + O(1/x**6, (x, oo))
+    assert fps(f, x, -oo).truncate() == -1 + O(1/x**6, (x, oo))
+
+    f = atan(x)
+    assert fps(f, x, oo, full=True).truncate() == \
+        -1/(5*x**5) + 1/(3*x**3) - 1/x + pi/2 + O(1/x**6, (x, oo))
+    assert fps(f, x, -oo, full=True).truncate() == \
+        -1/(5*x**5) + 1/(3*x**3) - 1/x - pi/2 + O(1/x**6, (x, oo))
+
+    f = log(1 + x)
+    assert fps(f, x, oo) != \
+        (-1/(5*x**5) - 1/(4*x**4) + 1/(3*x**3) - 1/(2*x**2) + 1/x - log(1/x) +
+         O(1/x**6, (x, oo)))
+    assert fps(f, x, -oo) != \
+        (-1/(5*x**5) - 1/(4*x**4) + 1/(3*x**3) - 1/(2*x**2) + 1/x + I*pi -
+         log(-1/x) + O(1/x**6, (x, oo)))
+
+
+def test_fps__fractional():
+    f = sin(sqrt(x)) / x
+    assert fps(f, x).truncate() == \
+        (1/sqrt(x) - sqrt(x)/6 + x**Rational(3, 2)/120 -
+         x**Rational(5, 2)/5040 + x**Rational(7, 2)/362880 -
+         x**Rational(9, 2)/39916800 + x**Rational(11, 2)/6227020800 + O(x**6))
+
+    f = sin(sqrt(x)) * x
+    assert fps(f, x).truncate() == \
+        (x**Rational(3, 2) - x**Rational(5, 2)/6 + x**Rational(7, 2)/120 -
+         x**Rational(9, 2)/5040 + x**Rational(11, 2)/362880 + O(x**6))
+
+    f = atan(sqrt(x)) / x**2
+    assert fps(f, x).truncate() == \
+        (x**Rational(-3, 2) - x**Rational(-1, 2)/3 + x**S.Half/5 -
+         x**Rational(3, 2)/7 + x**Rational(5, 2)/9 - x**Rational(7, 2)/11 +
+         x**Rational(9, 2)/13 - x**Rational(11, 2)/15 + O(x**6))
+
+    f = exp(sqrt(x))
+    assert fps(f, x).truncate().expand() == \
+        (1 + x/2 + x**2/24 + x**3/720 + x**4/40320 + x**5/3628800 + sqrt(x) +
+         x**Rational(3, 2)/6 + x**Rational(5, 2)/120 + x**Rational(7, 2)/5040 +
+         x**Rational(9, 2)/362880 + x**Rational(11, 2)/39916800 + O(x**6))
+
+    f = exp(sqrt(x))*x
+    assert fps(f, x).truncate().expand() == \
+        (x + x**2/2 + x**3/24 + x**4/720 + x**5/40320 + x**Rational(3, 2) +
+         x**Rational(5, 2)/6 + x**Rational(7, 2)/120 + x**Rational(9, 2)/5040 +
+         x**Rational(11, 2)/362880 + O(x**6))
+
+
+def test_fps__logarithmic_singularity():
+    f = log(1 + 1/x)
+    assert fps(f, x) != \
+        -log(x) + x - x**2/2 + x**3/3 - x**4/4 + x**5/5 + O(x**6)
+    assert fps(f, x, rational=False) != \
+        -log(x) + x - x**2/2 + x**3/3 - x**4/4 + x**5/5 + O(x**6)
+
+
+@XFAIL
+def test_fps__logarithmic_singularity_fail():
+    f = asech(x)  # Algorithms for computing limits probably needs improvemnts
+    assert fps(f, x) == log(2) - log(x) - x**2/4 - 3*x**4/64 + O(x**6)
+
+
+def test_fps_symbolic():
+    f = x**n*sin(x**2)
+    assert fps(f, x).truncate(8) == x**(n + 2) - x**(n + 6)/6 + O(x**(n + 8), x)
+
+    f = x**n*log(1 + x)
+    fp = fps(f, x)
+    k = fp.ak.variables[0]
+    assert fp.infinite == \
+        Sum((-(-1)**(-k)*x**(k + n))/k, (k, 1, oo))
+
+    f = (x - 2)**n*log(1 + x)
+    assert fps(f, x, 2).truncate() == \
+        ((x - 2)**n*log(3) + (x - 2)**(n + 1)/3 - (x - 2)**(n + 2)/18 + (x - 2)**(n + 3)/81 -
+         (x - 2)**(n + 4)/324 + (x - 2)**(n + 5)/1215 + O((x - 2)**(n + 6), (x, 2)))
+
+    f = x**(n - 2)*cos(x)
+    assert fps(f, x).truncate() == \
+        (x**(n - 2) - x**n/2 + x**(n + 2)/24 + O(x**(n + 4), x))
+
+    f = x**(n - 2)*sin(x) + x**n*exp(x)
+    assert fps(f, x).truncate() == \
+        (x**(n - 1) + x**(n + 1) + x**(n + 2)/2 + x**n +
+         x**(n + 4)/24 + x**(n + 5)/60 + O(x**(n + 6), x))
+
+    f = x**n*atan(x)
+    assert fps(f, x, oo).truncate() == \
+        (-x**(n - 5)/5 + x**(n - 3)/3 + x**n*(pi/2 - 1/x) +
+         O((1/x)**(-n)/x**6, (x, oo)))
+
+    f = x**(n/2)*cos(x)
+    assert fps(f, x).truncate() == \
+        x**(n/2) - x**(n/2 + 2)/2 + x**(n/2 + 4)/24 + O(x**(n/2 + 6), x)
+
+    f = x**(n + m)*sin(x)
+    assert fps(f, x).truncate() == \
+        x**(m + n + 1) - x**(m + n + 3)/6 + x**(m + n + 5)/120 + O(x**(m + n + 6), x)
+
+
+def test_fps__slow():
+    f = x*exp(x)*sin(2*x)  # TODO: rsolve needs improvement
+    assert fps(f, x).truncate() == 2*x**2 + 2*x**3 - x**4/3 - x**5 + O(x**6)
+
+
+def test_fps__operations():
+    f1, f2 = fps(sin(x)), fps(cos(x))
+
+    fsum = f1 + f2
+    assert fsum.function == sin(x) + cos(x)
+    assert fsum.truncate() == \
+        1 + x - x**2/2 - x**3/6 + x**4/24 + x**5/120 + O(x**6)
+
+    fsum = f1 + 1
+    assert fsum.function == sin(x) + 1
+    assert fsum.truncate() == 1 + x - x**3/6 + x**5/120 + O(x**6)
+
+    fsum = 1 + f2
+    assert fsum.function == cos(x) + 1
+    assert fsum.truncate() == 2 - x**2/2 + x**4/24 + O(x**6)
+
+    assert (f1 + x) == Add(f1, x)
+
+    assert -f2.truncate() == -1 + x**2/2 - x**4/24 + O(x**6)
+    assert (f1 - f1) is S.Zero
+
+    fsub = f1 - f2
+    assert fsub.function == sin(x) - cos(x)
+    assert fsub.truncate() == \
+        -1 + x + x**2/2 - x**3/6 - x**4/24 + x**5/120 + O(x**6)
+
+    fsub = f1 - 1
+    assert fsub.function == sin(x) - 1
+    assert fsub.truncate() == -1 + x - x**3/6 + x**5/120 + O(x**6)
+
+    fsub = 1 - f2
+    assert fsub.function == -cos(x) + 1
+    assert fsub.truncate() == x**2/2 - x**4/24 + O(x**6)
+
+    raises(ValueError, lambda: f1 + fps(exp(x), dir=-1))
+    raises(ValueError, lambda: f1 + fps(exp(x), x0=1))
+
+    fm = f1 * 3
+
+    assert fm.function == 3*sin(x)
+    assert fm.truncate() == 3*x - x**3/2 + x**5/40 + O(x**6)
+
+    fm = 3 * f2
+
+    assert fm.function == 3*cos(x)
+    assert fm.truncate() == 3 - 3*x**2/2 + x**4/8 + O(x**6)
+
+    assert (f1 * f2) == Mul(f1, f2)
+    assert (f1 * x) == Mul(f1, x)
+
+    fd = f1.diff()
+    assert fd.function == cos(x)
+    assert fd.truncate() == 1 - x**2/2 + x**4/24 + O(x**6)
+
+    fd = f2.diff()
+    assert fd.function == -sin(x)
+    assert fd.truncate() == -x + x**3/6 - x**5/120 + O(x**6)
+
+    fd = f2.diff().diff()
+    assert fd.function == -cos(x)
+    assert fd.truncate() == -1 + x**2/2 - x**4/24 + O(x**6)
+
+    f3 = fps(exp(sqrt(x)))
+    fd = f3.diff()
+    assert fd.truncate().expand() == \
+        (1/(2*sqrt(x)) + S.Half + x/12 + x**2/240 + x**3/10080 + x**4/725760 +
+         x**5/79833600 + sqrt(x)/4 + x**Rational(3, 2)/48 + x**Rational(5, 2)/1440 +
+         x**Rational(7, 2)/80640 + x**Rational(9, 2)/7257600 + x**Rational(11, 2)/958003200 +
+         O(x**6))
+
+    assert f1.integrate((x, 0, 1)) == -cos(1) + 1
+    assert integrate(f1, (x, 0, 1)) == -cos(1) + 1
+
+    fi = integrate(f1, x)
+    assert fi.function == -cos(x)
+    assert fi.truncate() == -1 + x**2/2 - x**4/24 + O(x**6)
+
+    fi = f2.integrate(x)
+    assert fi.function == sin(x)
+    assert fi.truncate() == x - x**3/6 + x**5/120 + O(x**6)
+
+def test_fps__product():
+    f1, f2, f3 = fps(sin(x)), fps(exp(x)), fps(cos(x))
+
+    raises(ValueError, lambda: f1.product(exp(x), x))
+    raises(ValueError, lambda: f1.product(fps(exp(x), dir=-1), x, 4))
+    raises(ValueError, lambda: f1.product(fps(exp(x), x0=1), x, 4))
+    raises(ValueError, lambda: f1.product(fps(exp(y)), x, 4))
+
+    fprod = f1.product(f2, x)
+    assert isinstance(fprod, FormalPowerSeriesProduct)
+    assert isinstance(fprod.ffps, FormalPowerSeries)
+    assert isinstance(fprod.gfps, FormalPowerSeries)
+    assert fprod.f == sin(x)
+    assert fprod.g == exp(x)
+    assert fprod.function == sin(x) * exp(x)
+    assert fprod._eval_terms(4) == x + x**2 + x**3/3
+    assert fprod.truncate(4) == x + x**2 + x**3/3 + O(x**4)
+    assert fprod.polynomial(4) == x + x**2 + x**3/3
+
+    raises(NotImplementedError, lambda: fprod._eval_term(5))
+    raises(NotImplementedError, lambda: fprod.infinite)
+    raises(NotImplementedError, lambda: fprod._eval_derivative(x))
+    raises(NotImplementedError, lambda: fprod.integrate(x))
+
+    assert f1.product(f3, x)._eval_terms(4) == x - 2*x**3/3
+    assert f1.product(f3, x).truncate(4) == x - 2*x**3/3 + O(x**4)
+
+
+def test_fps__compose():
+    f1, f2, f3 = fps(exp(x)), fps(sin(x)), fps(cos(x))
+
+    raises(ValueError, lambda: f1.compose(sin(x), x))
+    raises(ValueError, lambda: f1.compose(fps(sin(x), dir=-1), x, 4))
+    raises(ValueError, lambda: f1.compose(fps(sin(x), x0=1), x, 4))
+    raises(ValueError, lambda: f1.compose(fps(sin(y)), x, 4))
+
+    raises(ValueError, lambda: f1.compose(f3, x))
+    raises(ValueError, lambda: f2.compose(f3, x))
+
+    fcomp = f1.compose(f2, x)
+    assert isinstance(fcomp, FormalPowerSeriesCompose)
+    assert isinstance(fcomp.ffps, FormalPowerSeries)
+    assert isinstance(fcomp.gfps, FormalPowerSeries)
+    assert fcomp.f == exp(x)
+    assert fcomp.g == sin(x)
+    assert fcomp.function == exp(sin(x))
+    assert fcomp._eval_terms(6) == 1 + x + x**2/2 - x**4/8 - x**5/15
+    assert fcomp.truncate() == 1 + x + x**2/2 - x**4/8 - x**5/15 + O(x**6)
+    assert fcomp.truncate(5) == 1 + x + x**2/2 - x**4/8 + O(x**5)
+
+    raises(NotImplementedError, lambda: fcomp._eval_term(5))
+    raises(NotImplementedError, lambda: fcomp.infinite)
+    raises(NotImplementedError, lambda: fcomp._eval_derivative(x))
+    raises(NotImplementedError, lambda: fcomp.integrate(x))
+
+    assert f1.compose(f2, x).truncate(4) == 1 + x + x**2/2 + O(x**4)
+    assert f1.compose(f2, x).truncate(8) == \
+        1 + x + x**2/2 - x**4/8 - x**5/15 - x**6/240 + x**7/90 + O(x**8)
+    assert f1.compose(f2, x).truncate(6) == \
+        1 + x + x**2/2 - x**4/8 - x**5/15 + O(x**6)
+
+    assert f2.compose(f2, x).truncate(4) == x - x**3/3 + O(x**4)
+    assert f2.compose(f2, x).truncate(8) == x - x**3/3 + x**5/10 - 8*x**7/315 + O(x**8)
+    assert f2.compose(f2, x).truncate(6) == x - x**3/3 + x**5/10 + O(x**6)
+
+
+def test_fps__inverse():
+    f1, f2, f3 = fps(sin(x)), fps(exp(x)), fps(cos(x))
+
+    raises(ValueError, lambda: f1.inverse(x))
+
+    finv = f2.inverse(x)
+    assert isinstance(finv, FormalPowerSeriesInverse)
+    assert isinstance(finv.ffps, FormalPowerSeries)
+    raises(ValueError, lambda: finv.gfps)
+
+    assert finv.f == exp(x)
+    assert finv.function == exp(-x)
+    assert finv._eval_terms(5) == 1 - x + x**2/2 - x**3/6 + x**4/24
+    assert finv.truncate() == 1 - x + x**2/2 - x**3/6 + x**4/24 - x**5/120 + O(x**6)
+    assert finv.truncate(5) == 1 - x + x**2/2 - x**3/6 + x**4/24 + O(x**5)
+
+    raises(NotImplementedError, lambda: finv._eval_term(5))
+    raises(ValueError, lambda: finv.g)
+    raises(NotImplementedError, lambda: finv.infinite)
+    raises(NotImplementedError, lambda: finv._eval_derivative(x))
+    raises(NotImplementedError, lambda: finv.integrate(x))
+
+    assert f2.inverse(x).truncate(8) == \
+        1 - x + x**2/2 - x**3/6 + x**4/24 - x**5/120 + x**6/720 - x**7/5040 + O(x**8)
+
+    assert f3.inverse(x).truncate() == 1 + x**2/2 + 5*x**4/24 + O(x**6)
+    assert f3.inverse(x).truncate(8) == 1 + x**2/2 + 5*x**4/24 + 61*x**6/720 + O(x**8)
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_fourier.py b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_fourier.py
new file mode 100644
index 0000000000000000000000000000000000000000..e3f206af3cc0c43e78065d8a1b788bf5138131bd
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_fourier.py
@@ -0,0 +1,165 @@
+from sympy.core.add import Add
+from sympy.core.numbers import (Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (cos, sin, sinc, tan)
+from sympy.series.fourier import fourier_series
+from sympy.series.fourier import FourierSeries
+from sympy.testing.pytest import raises
+from functools import lru_cache
+
+x, y, z = symbols('x y z')
+
+# Don't declare these during import because they are slow
+@lru_cache()
+def _get_examples():
+    fo = fourier_series(x, (x, -pi, pi))
+    fe = fourier_series(x**2, (-pi, pi))
+    fp = fourier_series(Piecewise((0, x < 0), (pi, True)), (x, -pi, pi))
+    return fo, fe, fp
+
+
+def test_FourierSeries():
+    fo, fe, fp = _get_examples()
+
+    assert fourier_series(1, (-pi, pi)) == 1
+    assert (Piecewise((0, x < 0), (pi, True)).
+            fourier_series((x, -pi, pi)).truncate()) == fp.truncate()
+    assert isinstance(fo, FourierSeries)
+    assert fo.function == x
+    assert fo.x == x
+    assert fo.period == (-pi, pi)
+
+    assert fo.term(3) == 2*sin(3*x) / 3
+    assert fe.term(3) == -4*cos(3*x) / 9
+    assert fp.term(3) == 2*sin(3*x) / 3
+
+    assert fo.as_leading_term(x) == 2*sin(x)
+    assert fe.as_leading_term(x) == pi**2 / 3
+    assert fp.as_leading_term(x) == pi / 2
+
+    assert fo.truncate() == 2*sin(x) - sin(2*x) + (2*sin(3*x) / 3)
+    assert fe.truncate() == -4*cos(x) + cos(2*x) + pi**2 / 3
+    assert fp.truncate() == 2*sin(x) + (2*sin(3*x) / 3) + pi / 2
+
+    fot = fo.truncate(n=None)
+    s = [0, 2*sin(x), -sin(2*x)]
+    for i, t in enumerate(fot):
+        if i == 3:
+            break
+        assert s[i] == t
+
+    def _check_iter(f, i):
+        for ind, t in enumerate(f):
+            assert t == f[ind]
+            if ind == i:
+                break
+
+    _check_iter(fo, 3)
+    _check_iter(fe, 3)
+    _check_iter(fp, 3)
+
+    assert fo.subs(x, x**2) == fo
+
+    raises(ValueError, lambda: fourier_series(x, (0, 1, 2)))
+    raises(ValueError, lambda: fourier_series(x, (x, 0, oo)))
+    raises(ValueError, lambda: fourier_series(x*y, (0, oo)))
+
+
+def test_FourierSeries_2():
+    p = Piecewise((0, x < 0), (x, True))
+    f = fourier_series(p, (x, -2, 2))
+
+    assert f.term(3) == (2*sin(3*pi*x / 2) / (3*pi) -
+                         4*cos(3*pi*x / 2) / (9*pi**2))
+    assert f.truncate() == (2*sin(pi*x / 2) / pi - sin(pi*x) / pi -
+                            4*cos(pi*x / 2) / pi**2 + S.Half)
+
+
+def test_square_wave():
+    """Test if fourier_series approximates discontinuous function correctly."""
+    square_wave = Piecewise((1, x < pi), (-1, True))
+    s = fourier_series(square_wave, (x, 0, 2*pi))
+
+    assert s.truncate(3) == 4 / pi * sin(x) + 4 / (3 * pi) * sin(3 * x) + \
+        4 / (5 * pi) * sin(5 * x)
+    assert s.sigma_approximation(4) == 4 / pi * sin(x) * sinc(pi / 4) + \
+        4 / (3 * pi) * sin(3 * x) * sinc(3 * pi / 4)
+
+
+def test_sawtooth_wave():
+    s = fourier_series(x, (x, 0, pi))
+    assert s.truncate(4) == \
+        pi/2 - sin(2*x) - sin(4*x)/2 - sin(6*x)/3
+    s = fourier_series(x, (x, 0, 1))
+    assert s.truncate(4) == \
+        S.Half - sin(2*pi*x)/pi - sin(4*pi*x)/(2*pi) - sin(6*pi*x)/(3*pi)
+
+
+def test_FourierSeries__operations():
+    fo, fe, fp = _get_examples()
+
+    fes = fe.scale(-1).shift(pi**2)
+    assert fes.truncate() == 4*cos(x) - cos(2*x) + 2*pi**2 / 3
+
+    assert fp.shift(-pi/2).truncate() == (2*sin(x) + (2*sin(3*x) / 3) +
+                                          (2*sin(5*x) / 5))
+
+    fos = fo.scale(3)
+    assert fos.truncate() == 6*sin(x) - 3*sin(2*x) + 2*sin(3*x)
+
+    fx = fe.scalex(2).shiftx(1)
+    assert fx.truncate() == -4*cos(2*x + 2) + cos(4*x + 4) + pi**2 / 3
+
+    fl = fe.scalex(3).shift(-pi).scalex(2).shiftx(1).scale(4)
+    assert fl.truncate() == (-16*cos(6*x + 6) + 4*cos(12*x + 12) -
+                             4*pi + 4*pi**2 / 3)
+
+    raises(ValueError, lambda: fo.shift(x))
+    raises(ValueError, lambda: fo.shiftx(sin(x)))
+    raises(ValueError, lambda: fo.scale(x*y))
+    raises(ValueError, lambda: fo.scalex(x**2))
+
+
+def test_FourierSeries__neg():
+    fo, fe, fp = _get_examples()
+
+    assert (-fo).truncate() == -2*sin(x) + sin(2*x) - (2*sin(3*x) / 3)
+    assert (-fe).truncate() == +4*cos(x) - cos(2*x) - pi**2 / 3
+
+
+def test_FourierSeries__add__sub():
+    fo, fe, fp = _get_examples()
+
+    assert fo + fo == fo.scale(2)
+    assert fo - fo == 0
+    assert -fe - fe == fe.scale(-2)
+
+    assert (fo + fe).truncate() == 2*sin(x) - sin(2*x) - 4*cos(x) + cos(2*x) \
+        + pi**2 / 3
+    assert (fo - fe).truncate() == 2*sin(x) - sin(2*x) + 4*cos(x) - cos(2*x) \
+        - pi**2 / 3
+
+    assert isinstance(fo + 1, Add)
+
+    raises(ValueError, lambda: fo + fourier_series(x, (x, 0, 2)))
+
+
+def test_FourierSeries_finite():
+
+    assert fourier_series(sin(x)).truncate(1) == sin(x)
+    # assert type(fourier_series(sin(x)*log(x))).truncate() == FourierSeries
+    # assert type(fourier_series(sin(x**2+6))).truncate() == FourierSeries
+    assert fourier_series(sin(x)*log(y)*exp(z),(x,pi,-pi)).truncate() == sin(x)*log(y)*exp(z)
+    assert fourier_series(sin(x)**6).truncate(oo) == -15*cos(2*x)/32 + 3*cos(4*x)/16 - cos(6*x)/32 \
+           + Rational(5, 16)
+    assert fourier_series(sin(x) ** 6).truncate() == -15 * cos(2 * x) / 32 + 3 * cos(4 * x) / 16 \
+           + Rational(5, 16)
+    assert fourier_series(sin(4*x+3) + cos(3*x+4)).truncate(oo) ==  -sin(4)*sin(3*x) + sin(4*x)*cos(3) \
+           + cos(4)*cos(3*x) + sin(3)*cos(4*x)
+    assert fourier_series(sin(x)+cos(x)*tan(x)).truncate(oo) == 2*sin(x)
+    assert fourier_series(cos(pi*x), (x, -1, 1)).truncate(oo) == cos(pi*x)
+    assert fourier_series(cos(3*pi*x + 4) - sin(4*pi*x)*log(pi*y), (x, -1, 1)).truncate(oo) == -log(pi*y)*sin(4*pi*x)\
+           - sin(4)*sin(3*pi*x) + cos(4)*cos(3*pi*x)
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_gruntz.py b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_gruntz.py
new file mode 100644
index 0000000000000000000000000000000000000000..afb63b5977908d719ae6358dfd8dc62fc4118bc6
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_gruntz.py
@@ -0,0 +1,476 @@
+from sympy.core import EulerGamma
+from sympy.core.numbers import (E, I, Integer, Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (acot, atan, cos, sin)
+from sympy.functions.elementary.complexes import sign as _sign
+from sympy.functions.special.error_functions import (Ei, erf)
+from sympy.functions.special.gamma_functions import (digamma, gamma, loggamma)
+from sympy.functions.special.zeta_functions import zeta
+from sympy.polys.polytools import cancel
+from sympy.functions.elementary.hyperbolic import cosh, coth, sinh, tanh
+from sympy.series.gruntz import compare, mrv, rewrite, mrv_leadterm, gruntz, \
+    sign
+from sympy.testing.pytest import XFAIL, skip, slow
+
+"""
+This test suite is testing the limit algorithm using the bottom up approach.
+See the documentation in limits2.py. The algorithm itself is highly recursive
+by nature, so "compare" is logically the lowest part of the algorithm, yet in
+some sense it's the most complex part, because it needs to calculate a limit
+to return the result.
+
+Nevertheless, the rest of the algorithm depends on compare working correctly.
+"""
+
+x = Symbol('x', real=True)
+m = Symbol('m', real=True)
+
+
+runslow = False
+
+
+def _sskip():
+    if not runslow:
+        skip("slow")
+
+
+@slow
+def test_gruntz_evaluation():
+    # Gruntz' thesis pp. 122 to 123
+    # 8.1
+    assert gruntz(exp(x)*(exp(1/x - exp(-x)) - exp(1/x)), x, oo) == -1
+    # 8.2
+    assert gruntz(exp(x)*(exp(1/x + exp(-x) + exp(-x**2))
+                  - exp(1/x - exp(-exp(x)))), x, oo) == 1
+    # 8.3
+    assert gruntz(exp(exp(x - exp(-x))/(1 - 1/x)) - exp(exp(x)), x, oo) is oo
+    # 8.5
+    assert gruntz(exp(exp(exp(x + exp(-x)))) / exp(exp(exp(x))), x, oo) is oo
+    # 8.6
+    assert gruntz(exp(exp(exp(x))) / exp(exp(exp(x - exp(-exp(x))))),
+                  x, oo) is oo
+    # 8.7
+    assert gruntz(exp(exp(exp(x))) / exp(exp(exp(x - exp(-exp(exp(x)))))),
+                  x, oo) == 1
+    # 8.8
+    assert gruntz(exp(exp(x)) / exp(exp(x - exp(-exp(exp(x))))), x, oo) == 1
+    # 8.9
+    assert gruntz(log(x)**2 * exp(sqrt(log(x))*(log(log(x)))**2
+                  * exp(sqrt(log(log(x))) * (log(log(log(x))))**3)) / sqrt(x),
+                  x, oo) == 0
+    # 8.10
+    assert gruntz((x*log(x)*(log(x*exp(x) - x**2))**2)
+                  / (log(log(x**2 + 2*exp(exp(3*x**3*log(x)))))), x, oo) == Rational(1, 3)
+    # 8.11
+    assert gruntz((exp(x*exp(-x)/(exp(-x) + exp(-2*x**2/(x + 1)))) - exp(x))/x,
+                  x, oo) == -exp(2)
+    # 8.12
+    assert gruntz((3**x + 5**x)**(1/x), x, oo) == 5
+    # 8.13
+    assert gruntz(x/log(x**(log(x**(log(2)/log(x))))), x, oo) is oo
+    # 8.14
+    assert gruntz(exp(exp(2*log(x**5 + x)*log(log(x))))
+                  / exp(exp(10*log(x)*log(log(x)))), x, oo) is oo
+    # 8.15
+    assert gruntz(exp(exp(Rational(5, 2)*x**Rational(-5, 7) + Rational(21, 8)*x**Rational(6, 11)
+                          + 2*x**(-8) + Rational(54, 17)*x**Rational(49, 45)))**8
+                  / log(log(-log(Rational(4, 3)*x**Rational(-5, 14))))**Rational(7, 6), x, oo) is oo
+    # 8.16
+    assert gruntz((exp(4*x*exp(-x)/(1/exp(x) + 1/exp(2*x**2/(x + 1)))) - exp(x))
+                  / exp(x)**4, x, oo) == 1
+    # 8.17
+    assert gruntz(exp(x*exp(-x)/(exp(-x) + exp(-2*x**2/(x + 1))))/exp(x), x, oo) \
+        == 1
+    # 8.19
+    assert gruntz(log(x)*(log(log(x) + log(log(x))) - log(log(x)))
+                  / (log(log(x) + log(log(log(x))))), x, oo) == 1
+    # 8.20
+    assert gruntz(exp((log(log(x + exp(log(x)*log(log(x))))))
+                  / (log(log(log(exp(x) + x + log(x)))))), x, oo) == E
+    # Another
+    assert gruntz(exp(exp(exp(x + exp(-x)))) / exp(exp(x)), x, oo) is oo
+
+
+def test_gruntz_evaluation_slow():
+    _sskip()
+    # 8.4
+    assert gruntz(exp(exp(exp(x)/(1 - 1/x)))
+                  - exp(exp(exp(x)/(1 - 1/x - log(x)**(-log(x))))), x, oo) is -oo
+    # 8.18
+    assert gruntz((exp(exp(-x/(1 + exp(-x))))*exp(-x/(1 + exp(-x/(1 + exp(-x)))))
+                   *exp(exp(-x + exp(-x/(1 + exp(-x))))))
+                  / (exp(-x/(1 + exp(-x))))**2 - exp(x) + x, x, oo) == 2
+
+
+@slow
+def test_gruntz_eval_special():
+    # Gruntz, p. 126
+    assert gruntz(exp(x)*(sin(1/x + exp(-x)) - sin(1/x + exp(-x**2))), x, oo) == 1
+    assert gruntz((erf(x - exp(-exp(x))) - erf(x)) * exp(exp(x)) * exp(x**2),
+                  x, oo) == -2/sqrt(pi)
+    assert gruntz(exp(exp(x)) * (exp(sin(1/x + exp(-exp(x)))) - exp(sin(1/x))),
+                  x, oo) == 1
+    assert gruntz(exp(x)*(gamma(x + exp(-x)) - gamma(x)), x, oo) is oo
+    assert gruntz(exp(exp(digamma(digamma(x))))/x, x, oo) == exp(Rational(-1, 2))
+    assert gruntz(exp(exp(digamma(log(x))))/x, x, oo) == exp(Rational(-1, 2))
+    assert gruntz(digamma(digamma(digamma(x))), x, oo) is oo
+    assert gruntz(loggamma(loggamma(x)), x, oo) is oo
+    assert gruntz(((gamma(x + 1/gamma(x)) - gamma(x))/log(x) - cos(1/x))
+                  * x*log(x), x, oo) == Rational(-1, 2)
+    assert gruntz(x * (gamma(x - 1/gamma(x)) - gamma(x) + log(x)), x, oo) \
+        == S.Half
+    assert gruntz((gamma(x + 1/gamma(x)) - gamma(x)) / log(x), x, oo) == 1
+
+
+def test_gruntz_eval_special_slow():
+    _sskip()
+    assert gruntz(gamma(x + 1)/sqrt(2*pi)
+                  - exp(-x)*(x**(x + S.Half) + x**(x - S.Half)/12), x, oo) is oo
+    assert gruntz(exp(exp(exp(digamma(digamma(digamma(x))))))/x, x, oo) == 0
+
+
+@XFAIL
+def test_grunts_eval_special_slow_sometimes_fail():
+    _sskip()
+    # XXX This sometimes fails!!!
+    assert gruntz(exp(gamma(x - exp(-x))*exp(1/x)) - exp(gamma(x)), x, oo) is oo
+
+
+def test_gruntz_Ei():
+    assert gruntz((Ei(x - exp(-exp(x))) - Ei(x)) *exp(-x)*exp(exp(x))*x, x, oo) == -1
+
+
+@XFAIL
+def test_gruntz_eval_special_fail():
+    # TODO zeta function series
+    assert gruntz(
+        exp((log(2) + 1)*x) * (zeta(x + exp(-x)) - zeta(x)), x, oo) == -log(2)
+
+    # TODO 8.35 - 8.37 (bessel, max-min)
+
+
+def test_gruntz_hyperbolic():
+    assert gruntz(cosh(x), x, oo) is oo
+    assert gruntz(cosh(x), x, -oo) is oo
+    assert gruntz(sinh(x), x, oo) is oo
+    assert gruntz(sinh(x), x, -oo) is -oo
+    assert gruntz(2*cosh(x)*exp(x), x, oo) is oo
+    assert gruntz(2*cosh(x)*exp(x), x, -oo) == 1
+    assert gruntz(2*sinh(x)*exp(x), x, oo) is oo
+    assert gruntz(2*sinh(x)*exp(x), x, -oo) == -1
+    assert gruntz(tanh(x), x, oo) == 1
+    assert gruntz(tanh(x), x, -oo) == -1
+    assert gruntz(coth(x), x, oo) == 1
+    assert gruntz(coth(x), x, -oo) == -1
+
+
+def test_compare1():
+    assert compare(2, x, x) == "<"
+    assert compare(x, exp(x), x) == "<"
+    assert compare(exp(x), exp(x**2), x) == "<"
+    assert compare(exp(x**2), exp(exp(x)), x) == "<"
+    assert compare(1, exp(exp(x)), x) == "<"
+
+    assert compare(x, 2, x) == ">"
+    assert compare(exp(x), x, x) == ">"
+    assert compare(exp(x**2), exp(x), x) == ">"
+    assert compare(exp(exp(x)), exp(x**2), x) == ">"
+    assert compare(exp(exp(x)), 1, x) == ">"
+
+    assert compare(2, 3, x) == "="
+    assert compare(3, -5, x) == "="
+    assert compare(2, -5, x) == "="
+
+    assert compare(x, x**2, x) == "="
+    assert compare(x**2, x**3, x) == "="
+    assert compare(x**3, 1/x, x) == "="
+    assert compare(1/x, x**m, x) == "="
+    assert compare(x**m, -x, x) == "="
+
+    assert compare(exp(x), exp(-x), x) == "="
+    assert compare(exp(-x), exp(2*x), x) == "="
+    assert compare(exp(2*x), exp(x)**2, x) == "="
+    assert compare(exp(x)**2, exp(x + exp(-x)), x) == "="
+    assert compare(exp(x), exp(x + exp(-x)), x) == "="
+
+    assert compare(exp(x**2), 1/exp(x**2), x) == "="
+
+
+def test_compare2():
+    assert compare(exp(x), x**5, x) == ">"
+    assert compare(exp(x**2), exp(x)**2, x) == ">"
+    assert compare(exp(x), exp(x + exp(-x)), x) == "="
+    assert compare(exp(x + exp(-x)), exp(x), x) == "="
+    assert compare(exp(x + exp(-x)), exp(-x), x) == "="
+    assert compare(exp(-x), x, x) == ">"
+    assert compare(x, exp(-x), x) == "<"
+    assert compare(exp(x + 1/x), x, x) == ">"
+    assert compare(exp(-exp(x)), exp(x), x) == ">"
+    assert compare(exp(exp(-exp(x)) + x), exp(-exp(x)), x) == "<"
+
+
+def test_compare3():
+    assert compare(exp(exp(x)), exp(x + exp(-exp(x))), x) == ">"
+
+
+def test_sign1():
+    assert sign(Rational(0), x) == 0
+    assert sign(Rational(3), x) == 1
+    assert sign(Rational(-5), x) == -1
+    assert sign(log(x), x) == 1
+    assert sign(exp(-x), x) == 1
+    assert sign(exp(x), x) == 1
+    assert sign(-exp(x), x) == -1
+    assert sign(3 - 1/x, x) == 1
+    assert sign(-3 - 1/x, x) == -1
+    assert sign(sin(1/x), x) == 1
+    assert sign((x**Integer(2)), x) == 1
+    assert sign(x**2, x) == 1
+    assert sign(x**5, x) == 1
+
+
+def test_sign2():
+    assert sign(x, x) == 1
+    assert sign(-x, x) == -1
+    y = Symbol("y", positive=True)
+    assert sign(y, x) == 1
+    assert sign(-y, x) == -1
+    assert sign(y*x, x) == 1
+    assert sign(-y*x, x) == -1
+
+
+def mmrv(a, b):
+    return set(mrv(a, b)[0].keys())
+
+
+def test_mrv1():
+    assert mmrv(x, x) == {x}
+    assert mmrv(x + 1/x, x) == {x}
+    assert mmrv(x**2, x) == {x}
+    assert mmrv(log(x), x) == {x}
+    assert mmrv(exp(x), x) == {exp(x)}
+    assert mmrv(exp(-x), x) == {exp(-x)}
+    assert mmrv(exp(x**2), x) == {exp(x**2)}
+    assert mmrv(-exp(1/x), x) == {x}
+    assert mmrv(exp(x + 1/x), x) == {exp(x + 1/x)}
+
+
+def test_mrv2a():
+    assert mmrv(exp(x + exp(-exp(x))), x) == {exp(-exp(x))}
+    assert mmrv(exp(x + exp(-x)), x) == {exp(x + exp(-x)), exp(-x)}
+    assert mmrv(exp(1/x + exp(-x)), x) == {exp(-x)}
+
+#sometimes infinite recursion due to log(exp(x**2)) not simplifying
+
+
+def test_mrv2b():
+    assert mmrv(exp(x + exp(-x**2)), x) == {exp(-x**2)}
+
+#sometimes infinite recursion due to log(exp(x**2)) not simplifying
+
+
+def test_mrv2c():
+    assert mmrv(
+        exp(-x + 1/x**2) - exp(x + 1/x), x) == {exp(x + 1/x), exp(1/x**2 - x)}
+
+#sometimes infinite recursion due to log(exp(x**2)) not simplifying
+
+
+def test_mrv3():
+    assert mmrv(exp(x**2) + x*exp(x) + log(x)**x/x, x) == {exp(x**2)}
+    assert mmrv(
+        exp(x)*(exp(1/x + exp(-x)) - exp(1/x)), x) == {exp(x), exp(-x)}
+    assert mmrv(log(
+        x**2 + 2*exp(exp(3*x**3*log(x)))), x) == {exp(exp(3*x**3*log(x)))}
+    assert mmrv(log(x - log(x))/log(x), x) == {x}
+    assert mmrv(
+        (exp(1/x - exp(-x)) - exp(1/x))*exp(x), x) == {exp(x), exp(-x)}
+    assert mmrv(
+        1/exp(-x + exp(-x)) - exp(x), x) == {exp(x), exp(-x), exp(x - exp(-x))}
+    assert mmrv(log(log(x*exp(x*exp(x)) + 1)), x) == {exp(x*exp(x))}
+    assert mmrv(exp(exp(log(log(x) + 1/x))), x) == {x}
+
+
+def test_mrv4():
+    ln = log
+    assert mmrv((ln(ln(x) + ln(ln(x))) - ln(ln(x)))/ln(ln(x) + ln(ln(ln(x))))*ln(x),
+            x) == {x}
+    assert mmrv(log(log(x*exp(x*exp(x)) + 1)) - exp(exp(log(log(x) + 1/x))), x) == \
+        {exp(x*exp(x))}
+
+
+def mrewrite(a, b, c):
+    return rewrite(a[1], a[0], b, c)
+
+
+def test_rewrite1():
+    e = exp(x)
+    assert mrewrite(mrv(e, x), x, m) == (1/m, -x)
+    e = exp(x**2)
+    assert mrewrite(mrv(e, x), x, m) == (1/m, -x**2)
+    e = exp(x + 1/x)
+    assert mrewrite(mrv(e, x), x, m) == (1/m, -x - 1/x)
+    e = 1/exp(-x + exp(-x)) - exp(x)
+    assert mrewrite(mrv(e, x), x, m) == (1/(m*exp(m)) - 1/m, -x)
+
+
+def test_rewrite2():
+    e = exp(x)*log(log(exp(x)))
+    assert mmrv(e, x) == {exp(x)}
+    assert mrewrite(mrv(e, x), x, m) == (1/m*log(x), -x)
+
+#sometimes infinite recursion due to log(exp(x**2)) not simplifying
+
+
+def test_rewrite3():
+    e = exp(-x + 1/x**2) - exp(x + 1/x)
+    #both of these are correct and should be equivalent:
+    assert mrewrite(mrv(e, x), x, m) in [(-1/m + m*exp(
+        1/x + 1/x**2), -x - 1/x), (m - 1/m*exp(1/x + x**(-2)), x**(-2) - x)]
+
+
+def test_mrv_leadterm1():
+    assert mrv_leadterm(-exp(1/x), x) == (-1, 0)
+    assert mrv_leadterm(1/exp(-x + exp(-x)) - exp(x), x) == (-1, 0)
+    assert mrv_leadterm(
+        (exp(1/x - exp(-x)) - exp(1/x))*exp(x), x) == (-exp(1/x), 0)
+
+
+def test_mrv_leadterm2():
+    #Gruntz: p51, 3.25
+    assert mrv_leadterm((log(exp(x) + x) - x)/log(exp(x) + log(x))*exp(x), x) == \
+        (1, 0)
+
+
+def test_mrv_leadterm3():
+    #Gruntz: p56, 3.27
+    assert mmrv(exp(-x + exp(-x)*exp(-x*log(x))), x) == {exp(-x - x*log(x))}
+    assert mrv_leadterm(exp(-x + exp(-x)*exp(-x*log(x))), x) == (exp(-x), 0)
+
+
+def test_limit1():
+    assert gruntz(x, x, oo) is oo
+    assert gruntz(x, x, -oo) is -oo
+    assert gruntz(-x, x, oo) is -oo
+    assert gruntz(x**2, x, -oo) is oo
+    assert gruntz(-x**2, x, oo) is -oo
+    assert gruntz(x*log(x), x, 0, dir="+") == 0
+    assert gruntz(1/x, x, oo) == 0
+    assert gruntz(exp(x), x, oo) is oo
+    assert gruntz(-exp(x), x, oo) is -oo
+    assert gruntz(exp(x)/x, x, oo) is oo
+    assert gruntz(1/x - exp(-x), x, oo) == 0
+    assert gruntz(x + 1/x, x, oo) is oo
+
+
+def test_limit2():
+    assert gruntz(x**x, x, 0, dir="+") == 1
+    assert gruntz((exp(x) - 1)/x, x, 0) == 1
+    assert gruntz(1 + 1/x, x, oo) == 1
+    assert gruntz(-exp(1/x), x, oo) == -1
+    assert gruntz(x + exp(-x), x, oo) is oo
+    assert gruntz(x + exp(-x**2), x, oo) is oo
+    assert gruntz(x + exp(-exp(x)), x, oo) is oo
+    assert gruntz(13 + 1/x - exp(-x), x, oo) == 13
+
+
+def test_limit3():
+    a = Symbol('a')
+    assert gruntz(x - log(1 + exp(x)), x, oo) == 0
+    assert gruntz(x - log(a + exp(x)), x, oo) == 0
+    assert gruntz(exp(x)/(1 + exp(x)), x, oo) == 1
+    assert gruntz(exp(x)/(a + exp(x)), x, oo) == 1
+
+
+def test_limit4():
+    #issue 3463
+    assert gruntz((3**x + 5**x)**(1/x), x, oo) == 5
+    #issue 3463
+    assert gruntz((3**(1/x) + 5**(1/x))**x, x, 0) == 5
+
+
+@XFAIL
+def test_MrvTestCase_page47_ex3_21():
+    h = exp(-x/(1 + exp(-x)))
+    expr = exp(h)*exp(-x/(1 + h))*exp(exp(-x + h))/h**2 - exp(x) + x
+    assert mmrv(expr, x) == {1/h, exp(-x), exp(x), exp(x - h), exp(x/(1 + h))}
+
+
+def test_gruntz_I():
+    y = Symbol("y")
+    assert gruntz(I*x, x, oo) == I*oo
+    assert gruntz(y*I*x, x, oo) == y*I*oo
+    assert gruntz(y*3*I*x, x, oo) == y*I*oo
+    assert gruntz(y*3*sin(I)*x, x, oo).simplify().rewrite(_sign) == _sign(y)*I*oo
+
+
+def test_issue_4814():
+    assert gruntz((x + 1)**(1/log(x + 1)), x, oo) == E
+
+
+def test_intractable():
+    assert gruntz(1/gamma(x), x, oo) == 0
+    assert gruntz(1/loggamma(x), x, oo) == 0
+    assert gruntz(gamma(x)/loggamma(x), x, oo) is oo
+    assert gruntz(exp(gamma(x))/gamma(x), x, oo) is oo
+    assert gruntz(gamma(x), x, 3) == 2
+    assert gruntz(gamma(Rational(1, 7) + 1/x), x, oo) == gamma(Rational(1, 7))
+    assert gruntz(log(x**x)/log(gamma(x)), x, oo) == 1
+    assert gruntz(log(gamma(gamma(x)))/exp(x), x, oo) is oo
+
+
+def test_aseries_trig():
+    assert cancel(gruntz(1/log(atan(x)), x, oo)
+           - 1/(log(pi) + log(S.Half))) == 0
+    assert gruntz(1/acot(x), x, -oo) is -oo
+
+
+def test_exp_log_series():
+    assert gruntz(x/log(log(x*exp(x))), x, oo) is oo
+
+
+def test_issue_3644():
+    assert gruntz(((x**7 + x + 1)/(2**x + x**2))**(-1/x), x, oo) == 2
+
+
+def test_issue_6843():
+    n = Symbol('n', integer=True, positive=True)
+    r = (n + 1)*x**(n + 1)/(x**(n + 1) - 1) - x/(x - 1)
+    assert gruntz(r, x, 1).simplify() == n/2
+
+
+def test_issue_4190():
+    assert gruntz(x - gamma(1/x), x, oo) == S.EulerGamma
+
+
+@XFAIL
+def test_issue_5172():
+    n = Symbol('n')
+    r = Symbol('r', positive=True)
+    c = Symbol('c')
+    p = Symbol('p', positive=True)
+    m = Symbol('m', negative=True)
+    expr = ((2*n*(n - r + 1)/(n + r*(n - r + 1)))**c + \
+        (r - 1)*(n*(n - r + 2)/(n + r*(n - r + 1)))**c - n)/(n**c - n)
+    expr = expr.subs(c, c + 1)
+    assert gruntz(expr.subs(c, m), n, oo) == 1
+    # fail:
+    assert gruntz(expr.subs(c, p), n, oo).simplify() == \
+        (2**(p + 1) + r - 1)/(r + 1)**(p + 1)
+
+
+def test_issue_4109():
+    assert gruntz(1/gamma(x), x, 0) == 0
+    assert gruntz(x*gamma(x), x, 0) == 1
+
+
+def test_issue_6682():
+    assert gruntz(exp(2*Ei(-x))/x**2, x, 0) == exp(2*EulerGamma)
+
+
+def test_issue_7096():
+    from sympy.functions import sign
+    assert gruntz(x**-pi, x, 0, dir='-') == oo*sign((-1)**(-pi))
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_kauers.py b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_kauers.py
new file mode 100644
index 0000000000000000000000000000000000000000..bfb9044b33416bc38879649b258150ba2906250c
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_kauers.py
@@ -0,0 +1,23 @@
+from sympy.series.kauers import finite_diff
+from sympy.series.kauers import finite_diff_kauers
+from sympy.abc import x, y, z, m, n, w
+from sympy.core.numbers import pi
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.concrete.summations import Sum
+
+
+def test_finite_diff():
+    assert finite_diff(x**2 + 2*x + 1, x) == 2*x + 3
+    assert finite_diff(y**3 + 2*y**2 + 3*y + 5, y) == 3*y**2 + 7*y + 6
+    assert finite_diff(z**2 - 2*z + 3, z) == 2*z - 1
+    assert finite_diff(w**2 + 3*w - 2, w) == 2*w + 4
+    assert finite_diff(sin(x), x, pi/6) == -sin(x) + sin(x + pi/6)
+    assert finite_diff(cos(y), y, pi/3) == -cos(y) + cos(y + pi/3)
+    assert finite_diff(x**2 - 2*x + 3, x, 2) == 4*x
+    assert finite_diff(n**2 - 2*n + 3, n, 3) == 6*n + 3
+
+def test_finite_diff_kauers():
+    assert finite_diff_kauers(Sum(x**2, (x, 1, n))) == (n + 1)**2
+    assert finite_diff_kauers(Sum(y, (y, 1, m))) == (m + 1)
+    assert finite_diff_kauers(Sum((x*y), (x, 1, m), (y, 1, n))) == (m + 1)*(n + 1)
+    assert finite_diff_kauers(Sum((x*y**2), (x, 1, m), (y, 1, n))) == (n + 1)**2*(m + 1)
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_limits.py b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_limits.py
new file mode 100644
index 0000000000000000000000000000000000000000..fcfda5bf6b547490e92115c03812f29db307bfe7
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_limits.py
@@ -0,0 +1,1311 @@
+from itertools import product
+
+from sympy.concrete.summations import Sum
+from sympy.core.function import (Function, diff)
+from sympy.core import EulerGamma
+from sympy.core.numbers import (E, I, Rational, oo, pi, zoo)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.combinatorial.factorials import (binomial, factorial, subfactorial)
+from sympy.functions.elementary.complexes import (Abs, re, sign)
+from sympy.functions.elementary.exponential import (LambertW, exp, log)
+from sympy.functions.elementary.hyperbolic import (acosh, acoth, acsch, asech, atanh, sinh, tanh)
+from sympy.functions.elementary.integers import (ceiling, floor, frac)
+from sympy.functions.elementary.miscellaneous import (cbrt, real_root, sqrt)
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (acos, acot, acsc, asec, asin,
+                                                      atan, cos, cot, csc, sec, sin, tan)
+from sympy.functions.special.bessel import (besseli, bessely, besselj, besselk)
+from sympy.functions.special.error_functions import (Ei, erf, erfc, erfi, fresnelc, fresnels)
+from sympy.functions.special.gamma_functions import (digamma, gamma, uppergamma)
+from sympy.functions.special.hyper import meijerg
+from sympy.integrals.integrals import (Integral, integrate)
+from sympy.series.limits import (Limit, limit)
+from sympy.simplify.simplify import (logcombine, simplify)
+from sympy.simplify.hyperexpand import hyperexpand
+
+from sympy.calculus.accumulationbounds import AccumBounds
+from sympy.core.mul import Mul
+from sympy.series.limits import heuristics
+from sympy.series.order import Order
+from sympy.testing.pytest import XFAIL, raises
+
+from sympy.abc import x, y, z, k
+n = Symbol('n', integer=True, positive=True)
+
+
+def test_basic1():
+    assert limit(x, x, oo) is oo
+    assert limit(x, x, -oo) is -oo
+    assert limit(-x, x, oo) is -oo
+    assert limit(x**2, x, -oo) is oo
+    assert limit(-x**2, x, oo) is -oo
+    assert limit(x*log(x), x, 0, dir="+") == 0
+    assert limit(1/x, x, oo) == 0
+    assert limit(exp(x), x, oo) is oo
+    assert limit(-exp(x), x, oo) is -oo
+    assert limit(exp(x)/x, x, oo) is oo
+    assert limit(1/x - exp(-x), x, oo) == 0
+    assert limit(x + 1/x, x, oo) is oo
+    assert limit(x - x**2, x, oo) is -oo
+    assert limit((1 + x)**(1 + sqrt(2)), x, 0) == 1
+    assert limit((1 + x)**oo, x, 0) == Limit((x + 1)**oo, x, 0)
+    assert limit((1 + x)**oo, x, 0, dir='-') == Limit((x + 1)**oo, x, 0, dir='-')
+    assert limit((1 + x + y)**oo, x, 0, dir='-') == Limit((1 + x + y)**oo, x, 0, dir='-')
+    assert limit(y/x/log(x), x, 0) == -oo*sign(y)
+    assert limit(cos(x + y)/x, x, 0) == sign(cos(y))*oo
+    assert limit(gamma(1/x + 3), x, oo) == 2
+    assert limit(S.NaN, x, -oo) is S.NaN
+    assert limit(Order(2)*x, x, S.NaN) is S.NaN
+    assert limit(1/(x - 1), x, 1, dir="+") is oo
+    assert limit(1/(x - 1), x, 1, dir="-") is -oo
+    assert limit(1/(5 - x)**3, x, 5, dir="+") is -oo
+    assert limit(1/(5 - x)**3, x, 5, dir="-") is oo
+    assert limit(1/sin(x), x, pi, dir="+") is -oo
+    assert limit(1/sin(x), x, pi, dir="-") is oo
+    assert limit(1/cos(x), x, pi/2, dir="+") is -oo
+    assert limit(1/cos(x), x, pi/2, dir="-") is oo
+    assert limit(1/tan(x**3), x, (2*pi)**Rational(1, 3), dir="+") is oo
+    assert limit(1/tan(x**3), x, (2*pi)**Rational(1, 3), dir="-") is -oo
+    assert limit(1/cot(x)**3, x, (pi*Rational(3, 2)), dir="+") is -oo
+    assert limit(1/cot(x)**3, x, (pi*Rational(3, 2)), dir="-") is oo
+    assert limit(tan(x), x, oo) == AccumBounds(S.NegativeInfinity, S.Infinity)
+    assert limit(cot(x), x, oo) == AccumBounds(S.NegativeInfinity, S.Infinity)
+    assert limit(sec(x), x, oo) == AccumBounds(S.NegativeInfinity, S.Infinity)
+    assert limit(csc(x), x, oo) == AccumBounds(S.NegativeInfinity, S.Infinity)
+
+    # test bi-directional limits
+    assert limit(sin(x)/x, x, 0, dir="+-") == 1
+    assert limit(x**2, x, 0, dir="+-") == 0
+    assert limit(1/x**2, x, 0, dir="+-") is oo
+
+    # test failing bi-directional limits
+    assert limit(1/x, x, 0, dir="+-") is zoo
+    # approaching 0
+    # from dir="+"
+    assert limit(1 + 1/x, x, 0) is oo
+    # from dir='-'
+    # Add
+    assert limit(1 + 1/x, x, 0, dir='-') is -oo
+    # Pow
+    assert limit(x**(-2), x, 0, dir='-') is oo
+    assert limit(x**(-3), x, 0, dir='-') is -oo
+    assert limit(1/sqrt(x), x, 0, dir='-') == (-oo)*I
+    assert limit(x**2, x, 0, dir='-') == 0
+    assert limit(sqrt(x), x, 0, dir='-') == 0
+    assert limit(x**-pi, x, 0, dir='-') == -oo*(-1)**(1 - pi)
+    assert limit((1 + cos(x))**oo, x, 0) == Limit((cos(x) + 1)**oo, x, 0)
+
+    # test pull request 22491
+    assert limit(1/asin(x), x, 0, dir = '+') == oo
+    assert limit(1/asin(x), x, 0, dir = '-') == -oo
+    assert limit(1/sinh(x), x, 0, dir = '+') == oo
+    assert limit(1/sinh(x), x, 0, dir = '-') == -oo
+    assert limit(log(1/x) + 1/sin(x), x, 0, dir = '+') == oo
+    assert limit(log(1/x) + 1/x, x, 0, dir = '+') == oo
+
+
+def test_basic2():
+    assert limit(x**x, x, 0, dir="+") == 1
+    assert limit((exp(x) - 1)/x, x, 0) == 1
+    assert limit(1 + 1/x, x, oo) == 1
+    assert limit(-exp(1/x), x, oo) == -1
+    assert limit(x + exp(-x), x, oo) is oo
+    assert limit(x + exp(-x**2), x, oo) is oo
+    assert limit(x + exp(-exp(x)), x, oo) is oo
+    assert limit(13 + 1/x - exp(-x), x, oo) == 13
+
+
+def test_basic3():
+    assert limit(1/x, x, 0, dir="+") is oo
+    assert limit(1/x, x, 0, dir="-") is -oo
+
+
+def test_basic4():
+    assert limit(2*x + y*x, x, 0) == 0
+    assert limit(2*x + y*x, x, 1) == 2 + y
+    assert limit(2*x**8 + y*x**(-3), x, -2) == 512 - y/8
+    assert limit(sqrt(x + 1) - sqrt(x), x, oo) == 0
+    assert integrate(1/(x**3 + 1), (x, 0, oo)) == 2*pi*sqrt(3)/9
+
+
+def test_log():
+    # https://github.com/sympy/sympy/issues/21598
+    a, b, c = symbols('a b c', positive=True)
+    A = log(a/b) - (log(a) - log(b))
+    assert A.limit(a, oo) == 0
+    assert (A * c).limit(a, oo) == 0
+
+    tau, x = symbols('tau x', positive=True)
+    # The value of manualintegrate in the issue
+    expr = tau**2*((tau - 1)*(tau + 1)*log(x + 1)/(tau**2 + 1)**2 + 1/((tau**2\
+            + 1)*(x + 1)) - (-2*tau*atan(x/tau) + (tau**2/2 - 1/2)*log(tau**2\
+            + x**2))/(tau**2 + 1)**2)
+    assert limit(expr, x, oo) == pi*tau**3/(tau**2 + 1)**2
+
+
+def test_piecewise():
+    # https://github.com/sympy/sympy/issues/18363
+    assert limit((real_root(x - 6, 3) + 2)/(x + 2), x, -2, '+') == Rational(1, 12)
+
+
+def test_piecewise2():
+    func1 = 2*sqrt(x)*Piecewise(((4*x - 2)/Abs(sqrt(4 - 4*(2*x - 1)**2)), 4*x - 2\
+            >= 0), ((2 - 4*x)/Abs(sqrt(4 - 4*(2*x - 1)**2)), True))
+    func2 = Piecewise((x**2/2, x <= 0.5), (x/2 - 0.125, True))
+    func3 = Piecewise(((x - 9) / 5, x < -1), ((x - 9) / 5, x > 4), (sqrt(Abs(x - 3)), True))
+    assert limit(func1, x, 0) == 1
+    assert limit(func2, x, 0) == 0
+    assert limit(func3, x, -1) == 2
+
+
+def test_basic5():
+    class my(Function):
+        @classmethod
+        def eval(cls, arg):
+            if arg is S.Infinity:
+                return S.NaN
+    assert limit(my(x), x, oo) == Limit(my(x), x, oo)
+
+
+def test_issue_3885():
+    assert limit(x*y + x*z, z, 2) == x*y + 2*x
+
+
+def test_Limit():
+    assert Limit(sin(x)/x, x, 0) != 1
+    assert Limit(sin(x)/x, x, 0).doit() == 1
+    assert Limit(x, x, 0, dir='+-').args == (x, x, 0, Symbol('+-'))
+
+
+def test_floor():
+    assert limit(floor(x), x, -2, "+") == -2
+    assert limit(floor(x), x, -2, "-") == -3
+    assert limit(floor(x), x, -1, "+") == -1
+    assert limit(floor(x), x, -1, "-") == -2
+    assert limit(floor(x), x, 0, "+") == 0
+    assert limit(floor(x), x, 0, "-") == -1
+    assert limit(floor(x), x, 1, "+") == 1
+    assert limit(floor(x), x, 1, "-") == 0
+    assert limit(floor(x), x, 2, "+") == 2
+    assert limit(floor(x), x, 2, "-") == 1
+    assert limit(floor(x), x, 248, "+") == 248
+    assert limit(floor(x), x, 248, "-") == 247
+
+    # https://github.com/sympy/sympy/issues/14478
+    assert limit(x*floor(3/x)/2, x, 0, '+') == Rational(3, 2)
+    assert limit(floor(x + 1/2) - floor(x), x, oo) == AccumBounds(-S.Half, S(3)/2)
+
+    # test issue 9158
+    assert limit(floor(atan(x)), x, oo) == 1
+    assert limit(floor(atan(x)), x, -oo) == -2
+    assert limit(ceiling(atan(x)), x, oo) == 2
+    assert limit(ceiling(atan(x)), x, -oo) == -1
+
+
+def test_floor_requires_robust_assumptions():
+    assert limit(floor(sin(x)), x, 0, "+") == 0
+    assert limit(floor(sin(x)), x, 0, "-") == -1
+    assert limit(floor(cos(x)), x, 0, "+") == 0
+    assert limit(floor(cos(x)), x, 0, "-") == 0
+    assert limit(floor(5 + sin(x)), x, 0, "+") == 5
+    assert limit(floor(5 + sin(x)), x, 0, "-") == 4
+    assert limit(floor(5 + cos(x)), x, 0, "+") == 5
+    assert limit(floor(5 + cos(x)), x, 0, "-") == 5
+
+
+def test_ceiling():
+    assert limit(ceiling(x), x, -2, "+") == -1
+    assert limit(ceiling(x), x, -2, "-") == -2
+    assert limit(ceiling(x), x, -1, "+") == 0
+    assert limit(ceiling(x), x, -1, "-") == -1
+    assert limit(ceiling(x), x, 0, "+") == 1
+    assert limit(ceiling(x), x, 0, "-") == 0
+    assert limit(ceiling(x), x, 1, "+") == 2
+    assert limit(ceiling(x), x, 1, "-") == 1
+    assert limit(ceiling(x), x, 2, "+") == 3
+    assert limit(ceiling(x), x, 2, "-") == 2
+    assert limit(ceiling(x), x, 248, "+") == 249
+    assert limit(ceiling(x), x, 248, "-") == 248
+
+    # https://github.com/sympy/sympy/issues/14478
+    assert limit(x*ceiling(3/x)/2, x, 0, '+') == Rational(3, 2)
+    assert limit(ceiling(x + 1/2) - ceiling(x), x, oo) == AccumBounds(-S.Half, S(3)/2)
+
+
+def test_ceiling_requires_robust_assumptions():
+    assert limit(ceiling(sin(x)), x, 0, "+") == 1
+    assert limit(ceiling(sin(x)), x, 0, "-") == 0
+    assert limit(ceiling(cos(x)), x, 0, "+") == 1
+    assert limit(ceiling(cos(x)), x, 0, "-") == 1
+    assert limit(ceiling(5 + sin(x)), x, 0, "+") == 6
+    assert limit(ceiling(5 + sin(x)), x, 0, "-") == 5
+    assert limit(ceiling(5 + cos(x)), x, 0, "+") == 6
+    assert limit(ceiling(5 + cos(x)), x, 0, "-") == 6
+
+
+def test_frac():
+    assert limit(frac(x), x, oo) == AccumBounds(0, 1)
+    assert limit(frac(x)**(1/x), x, oo) == AccumBounds(0, 1)
+    assert limit(frac(x)**(1/x), x, -oo) == AccumBounds(1, oo)
+    assert limit(frac(x)**x, x, oo) == AccumBounds(0, oo)  # wolfram gives (0, 1)
+    assert limit(frac(sin(x)), x, 0, "+") == 0
+    assert limit(frac(sin(x)), x, 0, "-") == 1
+    assert limit(frac(cos(x)), x, 0, "+-") == 1
+    assert limit(frac(x**2), x, 0, "+-") == 0
+    raises(ValueError, lambda: limit(frac(x), x, 0, '+-'))
+    assert limit(frac(-2*x + 1), x, 0, "+") == 1
+    assert limit(frac(-2*x + 1), x, 0, "-") == 0
+    assert limit(frac(x + S.Half), x, 0, "+-") == 1/2
+    assert limit(frac(1/x), x, 0) == AccumBounds(0, 1)
+
+
+def test_issue_14355():
+    assert limit(floor(sin(x)/x), x, 0, '+') == 0
+    assert limit(floor(sin(x)/x), x, 0, '-') == 0
+    # test comment https://github.com/sympy/sympy/issues/14355#issuecomment-372121314
+    assert limit(floor(-tan(x)/x), x, 0, '+') == -2
+    assert limit(floor(-tan(x)/x), x, 0, '-') == -2
+
+
+def test_atan():
+    x = Symbol("x", real=True)
+    assert limit(atan(x)*sin(1/x), x, 0) == 0
+    assert limit(atan(x) + sqrt(x + 1) - sqrt(x), x, oo) == pi/2
+
+
+def test_set_signs():
+    assert limit(abs(x), x, 0) == 0
+    assert limit(abs(sin(x)), x, 0) == 0
+    assert limit(abs(cos(x)), x, 0) == 1
+    assert limit(abs(sin(x + 1)), x, 0) == sin(1)
+
+    # https://github.com/sympy/sympy/issues/9449
+    assert limit((Abs(x + y) - Abs(x - y))/(2*x), x, 0) == sign(y)
+
+    # https://github.com/sympy/sympy/issues/12398
+    assert limit(Abs(log(x)/x**3), x, oo) == 0
+    assert limit(x*(Abs(log(x)/x**3)/Abs(log(x + 1)/(x + 1)**3) - 1), x, oo) == 3
+
+    # https://github.com/sympy/sympy/issues/18501
+    assert limit(Abs(log(x - 1)**3 - 1), x, 1, '+') == oo
+
+    # https://github.com/sympy/sympy/issues/18997
+    assert limit(Abs(log(x)), x, 0) == oo
+    assert limit(Abs(log(Abs(x))), x, 0) == oo
+
+    # https://github.com/sympy/sympy/issues/19026
+    z = Symbol('z', positive=True)
+    assert limit(Abs(log(z) + 1)/log(z), z, oo) == 1
+
+    # https://github.com/sympy/sympy/issues/20704
+    assert limit(z*(Abs(1/z + y) - Abs(y - 1/z))/2, z, 0) == 0
+
+    # https://github.com/sympy/sympy/issues/21606
+    assert limit(cos(z)/sign(z), z, pi, '-') == -1
+
+
+def test_heuristic():
+    x = Symbol("x", real=True)
+    assert heuristics(sin(1/x) + atan(x), x, 0, '+') == AccumBounds(-1, 1)
+    assert limit(log(2 + sqrt(atan(x))*sqrt(sin(1/x))), x, 0) == log(2)
+
+
+def test_issue_3871():
+    z = Symbol("z", positive=True)
+    f = -1/z*exp(-z*x)
+    assert limit(f, x, oo) == 0
+    assert f.limit(x, oo) == 0
+
+
+def test_exponential():
+    n = Symbol('n')
+    x = Symbol('x', real=True)
+    assert limit((1 + x/n)**n, n, oo) == exp(x)
+    assert limit((1 + x/(2*n))**n, n, oo) == exp(x/2)
+    assert limit((1 + x/(2*n + 1))**n, n, oo) == exp(x/2)
+    assert limit(((x - 1)/(x + 1))**x, x, oo) == exp(-2)
+    assert limit(1 + (1 + 1/x)**x, x, oo) == 1 + S.Exp1
+    assert limit((2 + 6*x)**x/(6*x)**x, x, oo) == exp(S('1/3'))
+
+
+def test_exponential2():
+    n = Symbol('n')
+    assert limit((1 + x/(n + sin(n)))**n, n, oo) == exp(x)
+
+
+def test_doit():
+    f = Integral(2 * x, x)
+    l = Limit(f, x, oo)
+    assert l.doit() is oo
+
+
+def test_series_AccumBounds():
+    assert limit(sin(k) - sin(k + 1), k, oo) == AccumBounds(-2, 2)
+    assert limit(cos(k) - cos(k + 1) + 1, k, oo) == AccumBounds(-1, 3)
+
+    # not the exact bound
+    assert limit(sin(k) - sin(k)*cos(k), k, oo) == AccumBounds(-2, 2)
+
+    # test for issue #9934
+    lo = (-3 + cos(1))/2
+    hi = (1 + cos(1))/2
+    t1 = Mul(AccumBounds(lo, hi), 1/(-1 + cos(1)), evaluate=False)
+    assert limit(simplify(Sum(cos(n).rewrite(exp), (n, 0, k)).doit().rewrite(sin)), k, oo) == t1
+
+    t2 = Mul(AccumBounds(-1 + sin(1)/2, sin(1)/2 + 1), 1/(1 - cos(1)))
+    assert limit(simplify(Sum(sin(n).rewrite(exp), (n, 0, k)).doit().rewrite(sin)), k, oo) == t2
+
+    assert limit(((sin(x) + 1)/2)**x, x, oo) == AccumBounds(0, oo)  # wolfram says 0
+
+    # https://github.com/sympy/sympy/issues/12312
+    e = 2**(-x)*(sin(x) + 1)**x
+    assert limit(e, x, oo) == AccumBounds(0, oo)
+
+
+def test_bessel_functions_at_infinity():
+    # Pull Request 23844 implements limits for all bessel and modified bessel
+    # functions approaching infinity along any direction i.e. abs(z0) tends to oo
+
+    assert limit(besselj(1, x), x, oo) == 0
+    assert limit(besselj(1, x), x, -oo) == 0
+    assert limit(besselj(1, x), x, I*oo) == oo*I
+    assert limit(besselj(1, x), x, -I*oo) == -oo*I
+    assert limit(bessely(1, x), x, oo) == 0
+    assert limit(bessely(1, x), x, -oo) == 0
+    assert limit(bessely(1, x), x, I*oo) == -oo
+    assert limit(bessely(1, x), x, -I*oo) == -oo
+    assert limit(besseli(1, x), x, oo) == oo
+    assert limit(besseli(1, x), x, -oo) == -oo
+    assert limit(besseli(1, x), x, I*oo) == 0
+    assert limit(besseli(1, x), x, -I*oo) == 0
+    assert limit(besselk(1, x), x, oo) == 0
+    assert limit(besselk(1, x), x, -oo) == -oo*I
+    assert limit(besselk(1, x), x, I*oo) == 0
+    assert limit(besselk(1, x), x, -I*oo) == 0
+
+    # test issue 14874
+    assert limit(besselk(0, x), x, oo) == 0
+
+
+@XFAIL
+def test_doit2():
+    f = Integral(2 * x, x)
+    l = Limit(f, x, oo)
+    # limit() breaks on the contained Integral.
+    assert l.doit(deep=False) == l
+
+
+def test_issue_2929():
+    assert limit((x * exp(x))/(exp(x) - 1), x, -oo) == 0
+
+
+def test_issue_3792():
+    assert limit((1 - cos(x))/x**2, x, S.Half) == 4 - 4*cos(S.Half)
+    assert limit(sin(sin(x + 1) + 1), x, 0) == sin(1 + sin(1))
+    assert limit(abs(sin(x + 1) + 1), x, 0) == 1 + sin(1)
+
+
+def test_issue_4090():
+    assert limit(1/(x + 3), x, 2) == Rational(1, 5)
+    assert limit(1/(x + pi), x, 2) == S.One/(2 + pi)
+    assert limit(log(x)/(x**2 + 3), x, 2) == log(2)/7
+    assert limit(log(x)/(x**2 + pi), x, 2) == log(2)/(4 + pi)
+
+
+def test_issue_4547():
+    assert limit(cot(x), x, 0, dir='+') is oo
+    assert limit(cot(x), x, pi/2, dir='+') == 0
+
+
+def test_issue_5164():
+    assert limit(x**0.5, x, oo) == oo**0.5 is oo
+    assert limit(x**0.5, x, 16) == S(16)**0.5
+    assert limit(x**0.5, x, 0) == 0
+    assert limit(x**(-0.5), x, oo) == 0
+    assert limit(x**(-0.5), x, 4) == S(4)**(-0.5)
+
+
+def test_issue_5383():
+    func = (1.0 * 1 + 1.0 * x)**(1.0 * 1 / x)
+    assert limit(func, x, 0) == E
+
+
+def test_issue_14793():
+    expr = ((x + S(1)/2) * log(x) - x + log(2*pi)/2 - \
+        log(factorial(x)) + S(1)/(12*x))*x**3
+    assert limit(expr, x, oo) == S(1)/360
+
+
+def test_issue_5183():
+    # using list(...) so py.test can recalculate values
+    tests = list(product([x, -x],
+                         [-1, 1],
+                         [2, 3, S.Half, Rational(2, 3)],
+                         ['-', '+']))
+    results = (oo, oo, -oo, oo, -oo*I, oo, -oo*(-1)**Rational(1, 3), oo,
+               0, 0, 0, 0, 0, 0, 0, 0,
+               oo, oo, oo, -oo, oo, -oo*I, oo, -oo*(-1)**Rational(1, 3),
+               0, 0, 0, 0, 0, 0, 0, 0)
+    assert len(tests) == len(results)
+    for i, (args, res) in enumerate(zip(tests, results)):
+        y, s, e, d = args
+        eq = y**(s*e)
+        try:
+            assert limit(eq, x, 0, dir=d) == res
+        except AssertionError:
+            if 0:  # change to 1 if you want to see the failing tests
+                print()
+                print(i, res, eq, d, limit(eq, x, 0, dir=d))
+            else:
+                assert None
+
+
+def test_issue_5184():
+    assert limit(sin(x)/x, x, oo) == 0
+    assert limit(atan(x), x, oo) == pi/2
+    assert limit(gamma(x), x, oo) is oo
+    assert limit(cos(x)/x, x, oo) == 0
+    assert limit(gamma(x), x, S.Half) == sqrt(pi)
+
+    r = Symbol('r', real=True)
+    assert limit(r*sin(1/r), r, 0) == 0
+
+
+def test_issue_5229():
+    assert limit((1 + y)**(1/y) - S.Exp1, y, 0) == 0
+
+
+def test_issue_4546():
+    # using list(...) so py.test can recalculate values
+    tests = list(product([cot, tan],
+                         [-pi/2, 0, pi/2, pi, pi*Rational(3, 2)],
+                         ['-', '+']))
+    results = (0, 0, -oo, oo, 0, 0, -oo, oo, 0, 0,
+               oo, -oo, 0, 0, oo, -oo, 0, 0, oo, -oo)
+    assert len(tests) == len(results)
+    for i, (args, res) in enumerate(zip(tests, results)):
+        f, l, d = args
+        eq = f(x)
+        try:
+            assert limit(eq, x, l, dir=d) == res
+        except AssertionError:
+            if 0:  # change to 1 if you want to see the failing tests
+                print()
+                print(i, res, eq, l, d, limit(eq, x, l, dir=d))
+            else:
+                assert None
+
+
+def test_issue_3934():
+    assert limit((1 + x**log(3))**(1/x), x, 0) == 1
+    assert limit((5**(1/x) + 3**(1/x))**x, x, 0) == 5
+
+
+def test_calculate_series():
+    # NOTE
+    # The calculate_series method is being deprecated and is no longer responsible
+    # for result being returned. The mrv_leadterm function now uses simple leadterm
+    # calls rather than calculate_series.
+
+    # needs gruntz calculate_series to go to n = 32
+    assert limit(x**Rational(77, 3)/(1 + x**Rational(77, 3)), x, oo) == 1
+    # needs gruntz calculate_series to go to n = 128
+    assert limit(x**101.1/(1 + x**101.1), x, oo) == 1
+
+
+def test_issue_5955():
+    assert limit((x**16)/(1 + x**16), x, oo) == 1
+    assert limit((x**100)/(1 + x**100), x, oo) == 1
+    assert limit((x**1885)/(1 + x**1885), x, oo) == 1
+    assert limit((x**1000/((x + 1)**1000 + exp(-x))), x, oo) == 1
+
+
+def test_newissue():
+    assert limit(exp(1/sin(x))/exp(cot(x)), x, 0) == 1
+
+
+def test_extended_real_line():
+    assert limit(x - oo, x, oo) == Limit(x - oo, x, oo)
+    assert limit(1/(x + sin(x)) - oo, x, 0) == Limit(1/(x + sin(x)) - oo, x, 0)
+    assert limit(oo/x, x, oo) == Limit(oo/x, x, oo)
+    assert limit(x - oo + 1/x, x, oo) == Limit(x - oo + 1/x, x, oo)
+
+
+@XFAIL
+def test_order_oo():
+    x = Symbol('x', positive=True)
+    assert Order(x)*oo != Order(1, x)
+    assert limit(oo/(x**2 - 4), x, oo) is oo
+
+
+def test_issue_5436():
+    raises(NotImplementedError, lambda: limit(exp(x*y), x, oo))
+    raises(NotImplementedError, lambda: limit(exp(-x*y), x, oo))
+
+
+def test_Limit_dir():
+    raises(TypeError, lambda: Limit(x, x, 0, dir=0))
+    raises(ValueError, lambda: Limit(x, x, 0, dir='0'))
+
+
+def test_polynomial():
+    assert limit((x + 1)**1000/((x + 1)**1000 + 1), x, oo) == 1
+    assert limit((x + 1)**1000/((x + 1)**1000 + 1), x, -oo) == 1
+
+
+def test_rational():
+    assert limit(1/y - (1/(y + x) + x/(y + x)/y)/z, x, oo) == (z - 1)/(y*z)
+    assert limit(1/y - (1/(y + x) + x/(y + x)/y)/z, x, -oo) == (z - 1)/(y*z)
+
+
+def test_issue_5740():
+    assert limit(log(x)*z - log(2*x)*y, x, 0) == oo*sign(y - z)
+
+
+def test_issue_6366():
+    n = Symbol('n', integer=True, positive=True)
+    r = (n + 1)*x**(n + 1)/(x**(n + 1) - 1) - x/(x - 1)
+    assert limit(r, x, 1).cancel() == n/2
+
+
+def test_factorial():
+    f = factorial(x)
+    assert limit(f, x, oo) is oo
+    assert limit(x/f, x, oo) == 0
+    # see Stirling's approximation:
+    # https://en.wikipedia.org/wiki/Stirling's_approximation
+    assert limit(f/(sqrt(2*pi*x)*(x/E)**x), x, oo) == 1
+    assert limit(f, x, -oo) == gamma(-oo)
+
+
+def test_issue_6560():
+    e = (5*x**3/4 - x*Rational(3, 4) + (y*(3*x**2/2 - S.Half) +
+                             35*x**4/8 - 15*x**2/4 + Rational(3, 8))/(2*(y + 1)))
+    assert limit(e, y, oo) == 5*x**3/4 + 3*x**2/4 - 3*x/4 - Rational(1, 4)
+
+@XFAIL
+def test_issue_5172():
+    n = Symbol('n')
+    r = Symbol('r', positive=True)
+    c = Symbol('c')
+    p = Symbol('p', positive=True)
+    m = Symbol('m', negative=True)
+    expr = ((2*n*(n - r + 1)/(n + r*(n - r + 1)))**c +
+            (r - 1)*(n*(n - r + 2)/(n + r*(n - r + 1)))**c - n)/(n**c - n)
+    expr = expr.subs(c, c + 1)
+    raises(NotImplementedError, lambda: limit(expr, n, oo))
+    assert limit(expr.subs(c, m), n, oo) == 1
+    assert limit(expr.subs(c, p), n, oo).simplify() == \
+        (2**(p + 1) + r - 1)/(r + 1)**(p + 1)
+
+
+def test_issue_7088():
+    a = Symbol('a')
+    assert limit(sqrt(x/(x + a)), x, oo) == 1
+
+
+def test_branch_cuts():
+    assert limit(asin(I*x + 2), x, 0) == pi - asin(2)
+    assert limit(asin(I*x + 2), x, 0, '-') == asin(2)
+    assert limit(asin(I*x - 2), x, 0) == -asin(2)
+    assert limit(asin(I*x - 2), x, 0, '-') == -pi + asin(2)
+    assert limit(acos(I*x + 2), x, 0) == -acos(2)
+    assert limit(acos(I*x + 2), x, 0, '-') == acos(2)
+    assert limit(acos(I*x - 2), x, 0) == acos(-2)
+    assert limit(acos(I*x - 2), x, 0, '-') == 2*pi - acos(-2)
+    assert limit(atan(x + 2*I), x, 0) == I*atanh(2)
+    assert limit(atan(x + 2*I), x, 0, '-') == -pi + I*atanh(2)
+    assert limit(atan(x - 2*I), x, 0) == pi - I*atanh(2)
+    assert limit(atan(x - 2*I), x, 0, '-') == -I*atanh(2)
+    assert limit(atan(1/x), x, 0) == pi/2
+    assert limit(atan(1/x), x, 0, '-') == -pi/2
+    assert limit(atan(x), x, oo) == pi/2
+    assert limit(atan(x), x, -oo) == -pi/2
+    assert limit(acot(x + S(1)/2*I), x, 0) == pi - I*acoth(S(1)/2)
+    assert limit(acot(x + S(1)/2*I), x, 0, '-') == -I*acoth(S(1)/2)
+    assert limit(acot(x - S(1)/2*I), x, 0) == I*acoth(S(1)/2)
+    assert limit(acot(x - S(1)/2*I), x, 0, '-') == -pi + I*acoth(S(1)/2)
+    assert limit(acot(x), x, 0) == pi/2
+    assert limit(acot(x), x, 0, '-') == -pi/2
+    assert limit(asec(I*x + S(1)/2), x, 0) == asec(S(1)/2)
+    assert limit(asec(I*x + S(1)/2), x, 0, '-') == -asec(S(1)/2)
+    assert limit(asec(I*x - S(1)/2), x, 0) == 2*pi - asec(-S(1)/2)
+    assert limit(asec(I*x - S(1)/2), x, 0, '-') == asec(-S(1)/2)
+    assert limit(acsc(I*x + S(1)/2), x, 0) == acsc(S(1)/2)
+    assert limit(acsc(I*x + S(1)/2), x, 0, '-') == pi - acsc(S(1)/2)
+    assert limit(acsc(I*x - S(1)/2), x, 0) == -pi + acsc(S(1)/2)
+    assert limit(acsc(I*x - S(1)/2), x, 0, '-') == -acsc(S(1)/2)
+
+    assert limit(log(I*x - 1), x, 0) == I*pi
+    assert limit(log(I*x - 1), x, 0, '-') == -I*pi
+    assert limit(log(-I*x - 1), x, 0) == -I*pi
+    assert limit(log(-I*x - 1), x, 0, '-') == I*pi
+
+    assert limit(sqrt(I*x - 1), x, 0) == I
+    assert limit(sqrt(I*x - 1), x, 0, '-') == -I
+    assert limit(sqrt(-I*x - 1), x, 0) == -I
+    assert limit(sqrt(-I*x - 1), x, 0, '-') == I
+
+    assert limit(cbrt(I*x - 1), x, 0) == (-1)**(S(1)/3)
+    assert limit(cbrt(I*x - 1), x, 0, '-') == -(-1)**(S(2)/3)
+    assert limit(cbrt(-I*x - 1), x, 0) == -(-1)**(S(2)/3)
+    assert limit(cbrt(-I*x - 1), x, 0, '-') == (-1)**(S(1)/3)
+
+
+def test_issue_6364():
+    a = Symbol('a')
+    e = z/(1 - sqrt(1 + z)*sin(a)**2 - sqrt(1 - z)*cos(a)**2)
+    assert limit(e, z, 0) == 1/(cos(a)**2 - S.Half)
+
+
+def test_issue_6682():
+    assert limit(exp(2*Ei(-x))/x**2, x, 0) == exp(2*EulerGamma)
+
+
+def test_issue_4099():
+    a = Symbol('a')
+    assert limit(a/x, x, 0) == oo*sign(a)
+    assert limit(-a/x, x, 0) == -oo*sign(a)
+    assert limit(-a*x, x, oo) == -oo*sign(a)
+    assert limit(a*x, x, oo) == oo*sign(a)
+
+
+def test_issue_4503():
+    dx = Symbol('dx')
+    assert limit((sqrt(1 + exp(x + dx)) - sqrt(1 + exp(x)))/dx, dx, 0) == \
+        exp(x)/(2*sqrt(exp(x) + 1))
+
+
+def test_issue_6052():
+    G = meijerg((), (), (1,), (0,), -x)
+    g = hyperexpand(G)
+    assert limit(g, x, 0, '+-') == 0
+    assert limit(g, x, oo) == -oo
+
+
+def test_issue_7224():
+    expr = sqrt(x)*besseli(1,sqrt(8*x))
+    assert limit(x*diff(expr, x, x)/expr, x, 0) == 2
+    assert limit(x*diff(expr, x, x)/expr, x, 1).evalf() == 2.0
+
+
+def test_issue_8208():
+    assert limit(n**(Rational(1, 1e9) - 1), n, oo) == 0
+
+
+def test_issue_8229():
+    assert limit((x**Rational(1, 4) - 2)/(sqrt(x) - 4)**Rational(2, 3), x, 16) == 0
+
+
+def test_issue_8433():
+    d, t = symbols('d t', positive=True)
+    assert limit(erf(1 - t/d), t, oo) == -1
+
+
+def test_issue_8481():
+    k = Symbol('k', integer=True, nonnegative=True)
+    lamda = Symbol('lamda', positive=True)
+    assert limit(lamda**k * exp(-lamda) / factorial(k), k, oo) == 0
+
+
+def test_issue_8462():
+    assert limit(binomial(n, n/2), n, oo) == oo
+    assert limit(binomial(n, n/2) * 3 ** (-n), n, oo) == 0
+
+
+def test_issue_8634():
+    n = Symbol('n', integer=True, positive=True)
+    x = Symbol('x')
+    assert limit(x**n, x, -oo) == oo*sign((-1)**n)
+
+
+def test_issue_8635_18176():
+    x = Symbol('x', real=True)
+    k = Symbol('k', positive=True)
+    assert limit(x**n - x**(n - 0), x, oo) == 0
+    assert limit(x**n - x**(n - 5), x, oo) == oo
+    assert limit(x**n - x**(n - 2.5), x, oo) == oo
+    assert limit(x**n - x**(n - k - 1), x, oo) == oo
+    x = Symbol('x', positive=True)
+    assert limit(x**n - x**(n - 1), x, oo) == oo
+    assert limit(x**n - x**(n + 2), x, oo) == -oo
+
+
+def test_issue_8730():
+    assert limit(subfactorial(x), x, oo) is oo
+
+
+def test_issue_9252():
+    n = Symbol('n', integer=True)
+    c = Symbol('c', positive=True)
+    assert limit((log(n))**(n/log(n)) / (1 + c)**n, n, oo) == 0
+    # limit should depend on the value of c
+    raises(NotImplementedError, lambda: limit((log(n))**(n/log(n)) / c**n, n, oo))
+
+
+def test_issue_9558():
+    assert limit(sin(x)**15, x, 0, '-') == 0
+
+
+def test_issue_10801():
+    # make sure limits work with binomial
+    assert limit(16**k / (k * binomial(2*k, k)**2), k, oo) == pi
+
+
+def test_issue_10976():
+    s, x = symbols('s x', real=True)
+    assert limit(erf(s*x)/erf(s), s, 0) == x
+
+
+def test_issue_9041():
+    assert limit(factorial(n) / ((n/exp(1))**n * sqrt(2*pi*n)), n, oo) == 1
+
+
+def test_issue_9205():
+    x, y, a = symbols('x, y, a')
+    assert Limit(x, x, a).free_symbols == {a}
+    assert Limit(x, x, a, '-').free_symbols == {a}
+    assert Limit(x + y, x + y, a).free_symbols == {a}
+    assert Limit(-x**2 + y, x**2, a).free_symbols == {y, a}
+
+
+def test_issue_9471():
+    assert limit(((27**(log(n,3)))/n**3),n,oo) == 1
+    assert limit(((27**(log(n,3)+1))/n**3),n,oo) == 27
+
+
+def test_issue_11496():
+    assert limit(erfc(log(1/x)), x, oo) == 2
+
+
+def test_issue_11879():
+    assert simplify(limit(((x+y)**n-x**n)/y, y, 0)) == n*x**(n-1)
+
+
+def test_limit_with_Float():
+    k = symbols("k")
+    assert limit(1.0 ** k, k, oo) == 1
+    assert limit(0.3*1.0**k, k, oo) == Rational(3, 10)
+
+
+def test_issue_10610():
+    assert limit(3**x*3**(-x - 1)*(x + 1)**2/x**2, x, oo) == Rational(1, 3)
+
+
+def test_issue_10868():
+    assert limit(log(x) + asech(x), x, 0, '+') == log(2)
+    assert limit(log(x) + asech(x), x, 0, '-') == log(2) + 2*I*pi
+    raises(ValueError, lambda: limit(log(x) + asech(x), x, 0, '+-'))
+    assert limit(log(x) + asech(x), x, oo) == oo
+    assert limit(log(x) + acsch(x), x, 0, '+') == log(2)
+    assert limit(log(x) + acsch(x), x, 0, '-') == -oo
+    raises(ValueError, lambda: limit(log(x) + acsch(x), x, 0, '+-'))
+    assert limit(log(x) + acsch(x), x, oo) == oo
+
+
+def test_issue_6599():
+    assert limit((n + cos(n))/n, n, oo) == 1
+
+
+def test_issue_12555():
+    assert limit((3**x + 2* x**10) / (x**10 + exp(x)), x, -oo) == 2
+    assert limit((3**x + 2* x**10) / (x**10 + exp(x)), x, oo) is oo
+
+
+def test_issue_12769():
+    r, z, x = symbols('r z x', real=True)
+    a, b, s0, K, F0, s, T = symbols('a b s0 K F0 s T', positive=True, real=True)
+    fx = (F0**b*K**b*r*s0 - sqrt((F0**2*K**(2*b)*a**2*(b - 1) + \
+        F0**(2*b)*K**2*a**2*(b - 1) + F0**(2*b)*K**(2*b)*s0**2*(b - 1)*(b**2 - 2*b + 1) - \
+        2*F0**(2*b)*K**(b + 1)*a*r*s0*(b**2 - 2*b +  1) + \
+        2*F0**(b + 1)*K**(2*b)*a*r*s0*(b**2 - 2*b + 1) - \
+        2*F0**(b + 1)*K**(b + 1)*a**2*(b - 1))/((b - 1)*(b**2 - 2*b + 1))))*(b*r -  b - r + 1)
+
+    assert fx.subs(K, F0).factor(deep=True) == limit(fx, K, F0).factor(deep=True)
+
+
+def test_issue_13332():
+    assert limit(sqrt(30)*5**(-5*x - 1)*(46656*x)**x*(5*x + 2)**(5*x + 5*S.Half) *
+                (6*x + 2)**(-6*x - 5*S.Half), x, oo) == Rational(25, 36)
+
+
+def test_issue_12564():
+    assert limit(x**2 + x*sin(x) + cos(x), x, -oo) is oo
+    assert limit(x**2 + x*sin(x) + cos(x), x, oo) is oo
+    assert limit(((x + cos(x))**2).expand(), x, oo) is oo
+    assert limit(((x + sin(x))**2).expand(), x, oo) is oo
+    assert limit(((x + cos(x))**2).expand(), x, -oo) is oo
+    assert limit(((x + sin(x))**2).expand(), x, -oo) is oo
+
+
+def test_issue_14456():
+    raises(NotImplementedError, lambda: Limit(exp(x), x, zoo).doit())
+    raises(NotImplementedError, lambda: Limit(x**2/(x+1), x, zoo).doit())
+
+
+def test_issue_14411():
+    assert limit(3*sec(4*pi*x - x/3), x, 3*pi/(24*pi - 2)) is -oo
+
+
+def test_issue_13382():
+    assert limit(x*(((x + 1)**2 + 1)/(x**2 + 1) - 1), x, oo) == 2
+
+
+def test_issue_13403():
+    assert limit(x*(-1 + (x + log(x + 1) + 1)/(x + log(x))), x, oo) == 1
+
+
+def test_issue_13416():
+    assert limit((-x**3*log(x)**3 + (x - 1)*(x + 1)**2*log(x + 1)**3)/(x**2*log(x)**3), x, oo) == 1
+
+
+def test_issue_13462():
+    assert limit(n**2*(2*n*(-(1 - 1/(2*n))**x + 1) - x - (-x**2/4 + x/4)/n), n, oo) == x**3/24 - x**2/8 + x/12
+
+
+def test_issue_13750():
+    a = Symbol('a')
+    assert limit(erf(a - x), x, oo) == -1
+    assert limit(erf(sqrt(x) - x), x, oo) == -1
+
+
+def test_issue_14276():
+    assert isinstance(limit(sin(x)**log(x), x, oo), Limit)
+    assert isinstance(limit(sin(x)**cos(x), x, oo), Limit)
+    assert isinstance(limit(sin(log(cos(x))), x, oo), Limit)
+    assert limit((1 + 1/(x**2 + cos(x)))**(x**2 + x), x, oo) == E
+
+
+def test_issue_14514():
+    assert limit((1/(log(x)**log(x)))**(1/x), x, oo) == 1
+
+
+def test_issues_14525():
+    assert limit(sin(x)**2 - cos(x) + tan(x)*csc(x), x, oo) == AccumBounds(S.NegativeInfinity, S.Infinity)
+    assert limit(sin(x)**2 - cos(x) + sin(x)*cot(x), x, oo) == AccumBounds(S.NegativeInfinity, S.Infinity)
+    assert limit(cot(x) - tan(x)**2, x, oo) == AccumBounds(S.NegativeInfinity, S.Infinity)
+    assert limit(cos(x) - tan(x)**2, x, oo) == AccumBounds(S.NegativeInfinity, S.One)
+    assert limit(sin(x) - tan(x)**2, x, oo) == AccumBounds(S.NegativeInfinity, S.One)
+    assert limit(cos(x)**2 - tan(x)**2, x, oo) == AccumBounds(S.NegativeInfinity, S.One)
+    assert limit(tan(x)**2 + sin(x)**2 - cos(x), x, oo) == AccumBounds(-S.One, S.Infinity)
+
+
+def test_issue_14574():
+    assert limit(sqrt(x)*cos(x - x**2) / (x + 1), x, oo) == 0
+
+
+def test_issue_10102():
+    assert limit(fresnels(x), x, oo) == S.Half
+    assert limit(3 + fresnels(x), x, oo) == 3 + S.Half
+    assert limit(5*fresnels(x), x, oo) == Rational(5, 2)
+    assert limit(fresnelc(x), x, oo) == S.Half
+    assert limit(fresnels(x), x, -oo) == Rational(-1, 2)
+    assert limit(4*fresnelc(x), x, -oo) == -2
+
+
+def test_issue_14377():
+    raises(NotImplementedError, lambda: limit(exp(I*x)*sin(pi*x), x, oo))
+
+
+def test_issue_15146():
+    e = (x/2) * (-2*x**3 - 2*(x**3 - 1) * x**2 * digamma(x**3 + 1) + \
+        2*(x**3 - 1) * x**2 * digamma(x**3 + x + 1) + x + 3)
+    assert limit(e, x, oo) == S(1)/3
+
+
+def test_issue_15202():
+    e = (2**x*(2 + 2**(-x)*(-2*2**x + x + 2))/(x + 1))**(x + 1)
+    assert limit(e, x, oo) == exp(1)
+
+    e = (log(x, 2)**7 + 10*x*factorial(x) + 5**x) / (factorial(x + 1) + 3*factorial(x) + 10**x)
+    assert limit(e, x, oo) == 10
+
+
+def test_issue_15282():
+    assert limit((x**2000 - (x + 1)**2000) / x**1999, x, oo) == -2000
+
+
+def test_issue_15984():
+    assert limit((-x + log(exp(x) + 1))/x, x, oo, dir='-') == 0
+
+
+def test_issue_13571():
+    assert limit(uppergamma(x, 1) / gamma(x), x, oo) == 1
+
+
+def test_issue_13575():
+    assert limit(acos(erfi(x)), x, 1) == acos(erfi(S.One))
+
+
+def test_issue_17325():
+    assert Limit(sin(x)/x, x, 0, dir="+-").doit() == 1
+    assert Limit(x**2, x, 0, dir="+-").doit() == 0
+    assert Limit(1/x**2, x, 0, dir="+-").doit() is oo
+    assert Limit(1/x, x, 0, dir="+-").doit() is zoo
+
+
+def test_issue_10978():
+    assert LambertW(x).limit(x, 0) == 0
+
+
+def test_issue_14313_comment():
+    assert limit(floor(n/2), n, oo) is oo
+
+
+@XFAIL
+def test_issue_15323():
+    d = ((1 - 1/x)**x).diff(x)
+    assert limit(d, x, 1, dir='+') == 1
+
+
+def test_issue_12571():
+    assert limit(-LambertW(-log(x))/log(x), x, 1) == 1
+
+
+def test_issue_14590():
+    assert limit((x**3*((x + 1)/x)**x)/((x + 1)*(x + 2)*(x + 3)), x, oo) == exp(1)
+
+
+def test_issue_14393():
+    a, b = symbols('a b')
+    assert limit((x**b - y**b)/(x**a - y**a), x, y) == b*y**(-a + b)/a
+
+
+def test_issue_14556():
+    assert limit(factorial(n + 1)**(1/(n + 1)) - factorial(n)**(1/n), n, oo) == exp(-1)
+
+
+def test_issue_14811():
+    assert limit(((1 + ((S(2)/3)**(x + 1)))**(2**x))/(2**((S(4)/3)**(x - 1))), x, oo) == oo
+
+
+def test_issue_16222():
+    assert limit(exp(x), x, 1000000000) == exp(1000000000)
+
+
+def test_issue_16714():
+    assert limit(((x**(x + 1) + (x + 1)**x) / x**(x + 1))**x, x, oo) == exp(exp(1))
+
+
+def test_issue_16722():
+    z = symbols('z', positive=True)
+    assert limit(binomial(n + z, n)*n**-z, n, oo) == 1/gamma(z + 1)
+    z = symbols('z', positive=True, integer=True)
+    assert limit(binomial(n + z, n)*n**-z, n, oo) == 1/gamma(z + 1)
+
+
+def test_issue_17431():
+    assert limit(((n + 1) + 1) / (((n + 1) + 2) * factorial(n + 1)) *
+                 (n + 2) * factorial(n) / (n + 1), n, oo) == 0
+    assert limit((n + 2)**2*factorial(n)/((n + 1)*(n + 3)*factorial(n + 1))
+                 , n, oo) == 0
+    assert limit((n + 1) * factorial(n) / (n * factorial(n + 1)), n, oo) == 0
+
+
+def test_issue_17671():
+    assert limit(Ei(-log(x)) - log(log(x))/x, x, 1) == EulerGamma
+
+
+def test_issue_17751():
+    a, b, c, x = symbols('a b c x', positive=True)
+    assert limit((a + 1)*x - sqrt((a + 1)**2*x**2 + b*x + c), x, oo) == -b/(2*a + 2)
+
+
+def test_issue_17792():
+    assert limit(factorial(n)/sqrt(n)*(exp(1)/n)**n, n, oo) == sqrt(2)*sqrt(pi)
+
+
+def test_issue_18118():
+    assert limit(sign(sin(x)), x, 0, "-") == -1
+    assert limit(sign(sin(x)), x, 0, "+") == 1
+
+
+def test_issue_18306():
+    assert limit(sin(sqrt(x))/sqrt(sin(x)), x, 0, '+') == 1
+
+
+def test_issue_18378():
+    assert limit(log(exp(3*x) + x)/log(exp(x) + x**100), x, oo) == 3
+
+
+def test_issue_18399():
+    assert limit((1 - S(1)/2*x)**(3*x), x, oo) is zoo
+    assert limit((-x)**x, x, oo) is zoo
+
+
+def test_issue_18442():
+    assert limit(tan(x)**(2**(sqrt(pi))), x, oo, dir='-') == Limit(tan(x)**(2**(sqrt(pi))), x, oo, dir='-')
+
+
+def test_issue_18452():
+    assert limit(abs(log(x))**x, x, 0) == 1
+    assert limit(abs(log(x))**x, x, 0, "-") == 1
+
+
+def test_issue_18473():
+    assert limit(sin(x)**(1/x), x, oo) == Limit(sin(x)**(1/x), x, oo, dir='-')
+    assert limit(cos(x)**(1/x), x, oo) == Limit(cos(x)**(1/x), x, oo, dir='-')
+    assert limit(tan(x)**(1/x), x, oo) == Limit(tan(x)**(1/x), x, oo, dir='-')
+    assert limit((cos(x) + 2)**(1/x), x, oo) == 1
+    assert limit((sin(x) + 10)**(1/x), x, oo) == 1
+    assert limit((cos(x) - 2)**(1/x), x, oo) == Limit((cos(x) - 2)**(1/x), x, oo, dir='-')
+    assert limit((cos(x) + 1)**(1/x), x, oo) == AccumBounds(0, 1)
+    assert limit((tan(x)**2)**(2/x) , x, oo) == AccumBounds(0, oo)
+    assert limit((sin(x)**2)**(1/x), x, oo) == AccumBounds(0, 1)
+    # Tests for issue #23751
+    assert limit((cos(x) + 1)**(1/x), x, -oo) == AccumBounds(1, oo)
+    assert limit((sin(x)**2)**(1/x), x, -oo) == AccumBounds(1, oo)
+    assert limit((tan(x)**2)**(2/x) , x, -oo) == AccumBounds(0, oo)
+
+
+def test_issue_18482():
+    assert limit((2*exp(3*x)/(exp(2*x) + 1))**(1/x), x, oo) == exp(1)
+
+
+def test_issue_18508():
+    assert limit(sin(x)/sqrt(1-cos(x)), x, 0) == sqrt(2)
+    assert limit(sin(x)/sqrt(1-cos(x)), x, 0, dir='+') == sqrt(2)
+    assert limit(sin(x)/sqrt(1-cos(x)), x, 0, dir='-') == -sqrt(2)
+
+
+def test_issue_18521():
+    raises(NotImplementedError, lambda: limit(exp((2 - n) * x), x, oo))
+
+
+def test_issue_18969():
+    a, b = symbols('a b', positive=True)
+    assert limit(LambertW(a), a, b) == LambertW(b)
+    assert limit(exp(LambertW(a)), a, b) == exp(LambertW(b))
+
+
+def test_issue_18992():
+    assert limit(n/(factorial(n)**(1/n)), n, oo) == exp(1)
+
+
+def test_issue_19067():
+    x = Symbol('x')
+    assert limit(gamma(x)/(gamma(x - 1)*gamma(x + 2)), x, 0) == -1
+
+
+def test_issue_19586():
+    assert limit(x**(2**x*3**(-x)), x, oo) == 1
+
+
+def test_issue_13715():
+    n = Symbol('n')
+    p = Symbol('p', zero=True)
+    assert limit(n + p, n, 0) == 0
+
+
+def test_issue_15055():
+    assert limit(n**3*((-n - 1)*sin(1/n) + (n + 2)*sin(1/(n + 1)))/(-n + 1), n, oo) == 1
+
+
+def test_issue_16708():
+    m, vi = symbols('m vi', positive=True)
+    B, ti, d = symbols('B ti d')
+    assert limit((B*ti*vi - sqrt(m)*sqrt(-2*B*d*vi + m*(vi)**2) + m*vi)/(B*vi), B, 0) == (d + ti*vi)/vi
+
+
+def test_issue_19154():
+    assert limit(besseli(1, 3 *x)/(x *besseli(1, x)**3), x , oo) == 2*sqrt(3)*pi/3
+    assert limit(besseli(1, 3 *x)/(x *besseli(1, x)**3), x , -oo) == -2*sqrt(3)*pi/3
+
+
+def test_issue_19453():
+    beta = Symbol("beta", positive=True)
+    h = Symbol("h", positive=True)
+    m = Symbol("m", positive=True)
+    w = Symbol("omega", positive=True)
+    g = Symbol("g", positive=True)
+
+    e = exp(1)
+    q = 3*h**2*beta*g*e**(0.5*h*beta*w)
+    p = m**2*w**2
+    s = e**(h*beta*w) - 1
+    Z = -q/(4*p*s) - q/(2*p*s**2) - q*(e**(h*beta*w) + 1)/(2*p*s**3)\
+            + e**(0.5*h*beta*w)/s
+    E = -diff(log(Z), beta)
+
+    assert limit(E - 0.5*h*w, beta, oo) == 0
+    assert limit(E.simplify() - 0.5*h*w, beta, oo) == 0
+
+
+def test_issue_19739():
+    assert limit((-S(1)/4)**x, x, oo) == 0
+
+
+def test_issue_19766():
+    assert limit(2**(-x)*sqrt(4**(x + 1) + 1), x, oo) == 2
+
+
+def test_issue_19770():
+    m = Symbol('m')
+    # the result is not 0 for non-real m
+    assert limit(cos(m*x)/x, x, oo) == Limit(cos(m*x)/x, x, oo, dir='-')
+    m = Symbol('m', real=True)
+    # can be improved to give the correct result 0
+    assert limit(cos(m*x)/x, x, oo) == Limit(cos(m*x)/x, x, oo, dir='-')
+    m = Symbol('m', nonzero=True)
+    assert limit(cos(m*x), x, oo) == AccumBounds(-1, 1)
+    assert limit(cos(m*x)/x, x, oo) == 0
+
+
+def test_issue_7535():
+    assert limit(tan(x)/sin(tan(x)), x, pi/2) == Limit(tan(x)/sin(tan(x)), x, pi/2, dir='+')
+    assert limit(tan(x)/sin(tan(x)), x, pi/2, dir='-') == Limit(tan(x)/sin(tan(x)), x, pi/2, dir='-')
+    assert limit(tan(x)/sin(tan(x)), x, pi/2, dir='+-') == Limit(tan(x)/sin(tan(x)), x, pi/2, dir='+-')
+    assert limit(sin(tan(x)),x,pi/2) == AccumBounds(-1, 1)
+    assert -oo*(1/sin(-oo)) == AccumBounds(-oo, oo)
+    assert oo*(1/sin(oo)) == AccumBounds(-oo, oo)
+    assert oo*(1/sin(-oo)) == AccumBounds(-oo, oo)
+    assert -oo*(1/sin(oo)) == AccumBounds(-oo, oo)
+
+
+def test_issue_20365():
+    assert limit(((x + 1)**(1/x) - E)/x, x, 0) == -E/2
+
+
+def test_issue_21031():
+    assert limit(((1 + x)**(1/x) - (1 + 2*x)**(1/(2*x)))/asin(x), x, 0) == E/2
+
+
+def test_issue_21038():
+    assert limit(sin(pi*x)/(3*x - 12), x, 4) == pi/3
+
+
+def test_issue_20578():
+    expr = abs(x) * sin(1/x)
+    assert limit(expr,x,0,'+') == 0
+    assert limit(expr,x,0,'-') == 0
+    assert limit(expr,x,0,'+-') == 0
+
+
+def test_issue_21227():
+    f = log(x)
+
+    assert f.nseries(x, logx=y) == y
+    assert f.nseries(x, logx=-x) == -x
+
+    f = log(-log(x))
+
+    assert f.nseries(x, logx=y) == log(-y)
+    assert f.nseries(x, logx=-x) == log(x)
+
+    f = log(log(x))
+
+    assert f.nseries(x, logx=y) == log(y)
+    assert f.nseries(x, logx=-x) == log(-x)
+    assert f.nseries(x, logx=x) == log(x)
+
+    f = log(log(log(1/x)))
+
+    assert f.nseries(x, logx=y) == log(log(-y))
+    assert f.nseries(x, logx=-y) == log(log(y))
+    assert f.nseries(x, logx=x) == log(log(-x))
+    assert f.nseries(x, logx=-x) == log(log(x))
+
+
+def test_issue_21415():
+    exp = (x-1)*cos(1/(x-1))
+    assert exp.limit(x,1) == 0
+    assert exp.expand().limit(x,1) == 0
+
+
+def test_issue_21530():
+    assert limit(sinh(n + 1)/sinh(n), n, oo) == E
+
+
+def test_issue_21550():
+    r = (sqrt(5) - 1)/2
+    assert limit((x - r)/(x**2 + x - 1), x, r) == sqrt(5)/5
+
+
+def test_issue_21661():
+    out = limit((x**(x + 1) * (log(x) + 1) + 1) / x, x, 11)
+    assert out == S(3138428376722)/11 + 285311670611*log(11)
+
+
+def test_issue_21701():
+    assert limit((besselj(z, x)/x**z).subs(z, 7), x, 0) == S(1)/645120
+
+
+def test_issue_21721():
+    a = Symbol('a', real=True)
+    I = integrate(1/(pi*(1 + (x - a)**2)), x)
+    assert I.limit(x, oo) == S.Half
+
+
+def test_issue_21756():
+    term = (1 - exp(-2*I*pi*z))/(1 - exp(-2*I*pi*z/5))
+    assert term.limit(z, 0) == 5
+    assert re(term).limit(z, 0) == 5
+
+
+def test_issue_21785():
+    a = Symbol('a')
+    assert sqrt((-a**2 + x**2)/(1 - x**2)).limit(a, 1, '-') == I
+
+
+def test_issue_22181():
+    assert limit((-1)**x * 2**(-x), x, oo) == 0
+
+
+def test_issue_22220():
+    e1 = sqrt(30)*atan(sqrt(30)*tan(x/2)/6)/30
+    e2 = sqrt(30)*I*(-log(sqrt(2)*tan(x/2) - 2*sqrt(15)*I/5) +
+                     +log(sqrt(2)*tan(x/2) + 2*sqrt(15)*I/5))/60
+
+    assert limit(e1, x, -pi) == -sqrt(30)*pi/60
+    assert limit(e2, x, -pi) == -sqrt(30)*pi/30
+
+    assert limit(e1, x, -pi, '-') == sqrt(30)*pi/60
+    assert limit(e2, x, -pi, '-') == 0
+
+    # test https://github.com/sympy/sympy/issues/22220#issuecomment-972727694
+    expr = log(x - I) - log(-x - I)
+    expr2 = logcombine(expr, force=True)
+    assert limit(expr, x, oo) == limit(expr2, x, oo) == I*pi
+
+    # test https://github.com/sympy/sympy/issues/22220#issuecomment-1077618340
+    expr = expr = (-log(tan(x/2) - I) +log(tan(x/2) + I))
+    assert limit(expr, x, pi, '+') == 2*I*pi
+    assert limit(expr, x, pi, '-') == 0
+
+
+def test_issue_22334():
+    k, n  = symbols('k, n', positive=True)
+    assert limit((n+1)**k/((n+1)**(k+1) - (n)**(k+1)), n, oo) == 1/(k + 1)
+    assert limit((n+1)**k/((n+1)**(k+1) - (n)**(k+1)).expand(), n, oo) == 1/(k + 1)
+    assert limit((n+1)**k/(n*(-n**k + (n + 1)**k) + (n + 1)**k), n, oo) == 1/(k + 1)
+
+
+def test_sympyissue_22986():
+    assert limit(acosh(1 + 1/x)*sqrt(x), x, oo) == sqrt(2)
+
+
+def test_issue_23231():
+    f = (2**x - 2**(-x))/(2**x + 2**(-x))
+    assert limit(f, x, -oo) == -1
+
+
+def test_issue_23596():
+    assert integrate(((1 + x)/x**2)*exp(-1/x), (x, 0, oo)) == oo
+
+
+def test_issue_23752():
+    expr1 = sqrt(-I*x**2 + x - 3)
+    expr2 = sqrt(-I*x**2 + I*x - 3)
+    assert limit(expr1, x, 0, '+') == -sqrt(3)*I
+    assert limit(expr1, x, 0, '-') == -sqrt(3)*I
+    assert limit(expr2, x, 0, '+') == sqrt(3)*I
+    assert limit(expr2, x, 0, '-') == -sqrt(3)*I
+
+
+def test_issue_24276():
+    fx = log(tan(pi/2*tanh(x))).diff(x)
+    assert fx.limit(x, oo) == 2
+    assert fx.simplify().limit(x, oo) == 2
+    assert fx.rewrite(sin).limit(x, oo) == 2
+    assert fx.rewrite(sin).simplify().limit(x, oo) == 2
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_limitseq.py b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_limitseq.py
new file mode 100644
index 0000000000000000000000000000000000000000..362bb0397feb0ec63929920855c81279eca0bd6a
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_limitseq.py
@@ -0,0 +1,177 @@
+from sympy.concrete.summations import Sum
+from sympy.core.add import Add
+from sympy.core.numbers import (I, Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.combinatorial.factorials import (binomial, factorial, subfactorial)
+from sympy.functions.combinatorial.numbers import (fibonacci, harmonic)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.gamma_functions import gamma
+from sympy.series.limitseq import limit_seq
+from sympy.series.limitseq import difference_delta as dd
+from sympy.testing.pytest import raises, XFAIL
+from sympy.calculus.accumulationbounds import AccumulationBounds
+
+n, m, k = symbols('n m k', integer=True)
+
+
+def test_difference_delta():
+    e = n*(n + 1)
+    e2 = e * k
+
+    assert dd(e) == 2*n + 2
+    assert dd(e2, n, 2) == k*(4*n + 6)
+
+    raises(ValueError, lambda: dd(e2))
+    raises(ValueError, lambda: dd(e2, n, oo))
+
+
+def test_difference_delta__Sum():
+    e = Sum(1/k, (k, 1, n))
+    assert dd(e, n) == 1/(n + 1)
+    assert dd(e, n, 5) == Add(*[1/(i + n + 1) for i in range(5)])
+
+    e = Sum(1/k, (k, 1, 3*n))
+    assert dd(e, n) == Add(*[1/(i + 3*n + 1) for i in range(3)])
+
+    e = n * Sum(1/k, (k, 1, n))
+    assert dd(e, n) == 1 + Sum(1/k, (k, 1, n))
+
+    e = Sum(1/k, (k, 1, n), (m, 1, n))
+    assert dd(e, n) == harmonic(n)
+
+
+def test_difference_delta__Add():
+    e = n + n*(n + 1)
+    assert dd(e, n) == 2*n + 3
+    assert dd(e, n, 2) == 4*n + 8
+
+    e = n + Sum(1/k, (k, 1, n))
+    assert dd(e, n) == 1 + 1/(n + 1)
+    assert dd(e, n, 5) == 5 + Add(*[1/(i + n + 1) for i in range(5)])
+
+
+def test_difference_delta__Pow():
+    e = 4**n
+    assert dd(e, n) == 3*4**n
+    assert dd(e, n, 2) == 15*4**n
+
+    e = 4**(2*n)
+    assert dd(e, n) == 15*4**(2*n)
+    assert dd(e, n, 2) == 255*4**(2*n)
+
+    e = n**4
+    assert dd(e, n) == (n + 1)**4 - n**4
+
+    e = n**n
+    assert dd(e, n) == (n + 1)**(n + 1) - n**n
+
+
+def test_limit_seq():
+    e = binomial(2*n, n) / Sum(binomial(2*k, k), (k, 1, n))
+    assert limit_seq(e) == S(3) / 4
+    assert limit_seq(e, m) == e
+
+    e = (5*n**3 + 3*n**2 + 4) / (3*n**3 + 4*n - 5)
+    assert limit_seq(e, n) == S(5) / 3
+
+    e = (harmonic(n) * Sum(harmonic(k), (k, 1, n))) / (n * harmonic(2*n)**2)
+    assert limit_seq(e, n) == 1
+
+    e = Sum(k**2 * Sum(2**m/m, (m, 1, k)), (k, 1, n)) / (2**n*n)
+    assert limit_seq(e, n) == 4
+
+    e = (Sum(binomial(3*k, k) * binomial(5*k, k), (k, 1, n)) /
+         (binomial(3*n, n) * binomial(5*n, n)))
+    assert limit_seq(e, n) == S(84375) / 83351
+
+    e = Sum(harmonic(k)**2/k, (k, 1, 2*n)) / harmonic(n)**3
+    assert limit_seq(e, n) == S.One / 3
+
+    raises(ValueError, lambda: limit_seq(e * m))
+
+
+def test_alternating_sign():
+    assert limit_seq((-1)**n/n**2, n) == 0
+    assert limit_seq((-2)**(n+1)/(n + 3**n), n) == 0
+    assert limit_seq((2*n + (-1)**n)/(n + 1), n) == 2
+    assert limit_seq(sin(pi*n), n) == 0
+    assert limit_seq(cos(2*pi*n), n) == 1
+    assert limit_seq((S.NegativeOne/5)**n, n) == 0
+    assert limit_seq((Rational(-1, 5))**n, n) == 0
+    assert limit_seq((I/3)**n, n) == 0
+    assert limit_seq(sqrt(n)*(I/2)**n, n) == 0
+    assert limit_seq(n**7*(I/3)**n, n) == 0
+    assert limit_seq(n/(n + 1) + (I/2)**n, n) == 1
+
+
+def test_accum_bounds():
+    assert limit_seq((-1)**n, n) == AccumulationBounds(-1, 1)
+    assert limit_seq(cos(pi*n), n) == AccumulationBounds(-1, 1)
+    assert limit_seq(sin(pi*n/2)**2, n) == AccumulationBounds(0, 1)
+    assert limit_seq(2*(-3)**n/(n + 3**n), n) == AccumulationBounds(-2, 2)
+    assert limit_seq(3*n/(n + 1) + 2*(-1)**n, n) == AccumulationBounds(1, 5)
+
+
+def test_limitseq_sum():
+    from sympy.abc import x, y, z
+    assert limit_seq(Sum(1/x, (x, 1, y)) - log(y), y) == S.EulerGamma
+    assert limit_seq(Sum(1/x, (x, 1, y)) - 1/y, y) is S.Infinity
+    assert (limit_seq(binomial(2*x, x) / Sum(binomial(2*y, y), (y, 1, x)), x) ==
+            S(3) / 4)
+    assert (limit_seq(Sum(y**2 * Sum(2**z/z, (z, 1, y)), (y, 1, x)) /
+                  (2**x*x), x) == 4)
+
+
+def test_issue_9308():
+    assert limit_seq(subfactorial(n)/factorial(n), n) == exp(-1)
+
+
+def test_issue_10382():
+    n = Symbol('n', integer=True)
+    assert limit_seq(fibonacci(n+1)/fibonacci(n), n).together() == S.GoldenRatio
+
+
+def test_issue_11672():
+    assert limit_seq(Rational(-1, 2)**n, n) == 0
+
+
+def test_issue_14196():
+    k, n  = symbols('k, n', positive=True)
+    m = Symbol('m')
+    assert limit_seq(Sum(m**k, (m, 1, n)).doit()/(n**(k + 1)), n) == 1/(k + 1)
+
+
+def test_issue_16735():
+    assert limit_seq(5**n/factorial(n), n) == 0
+
+
+def test_issue_19868():
+    assert limit_seq(1/gamma(n + S.One/2), n) == 0
+
+
+@XFAIL
+def test_limit_seq_fail():
+    # improve Summation algorithm or add ad-hoc criteria
+    e = (harmonic(n)**3 * Sum(1/harmonic(k), (k, 1, n)) /
+         (n * Sum(harmonic(k)/k, (k, 1, n))))
+    assert limit_seq(e, n) == 2
+
+    # No unique dominant term
+    e = (Sum(2**k * binomial(2*k, k) / k**2, (k, 1, n)) /
+         (Sum(2**k/k*2, (k, 1, n)) * Sum(binomial(2*k, k), (k, 1, n))))
+    assert limit_seq(e, n) == S(3) / 7
+
+    # Simplifications of summations needs to be improved.
+    e = n**3*Sum(2**k/k**2, (k, 1, n))**2 / (2**n * Sum(2**k/k, (k, 1, n)))
+    assert limit_seq(e, n) == 2
+
+    e = (harmonic(n) * Sum(2**k/k, (k, 1, n)) /
+         (n * Sum(2**k*harmonic(k)/k**2, (k, 1, n))))
+    assert limit_seq(e, n) == 1
+
+    e = (Sum(2**k*factorial(k) / k**2, (k, 1, 2*n)) /
+         (Sum(4**k/k**2, (k, 1, n)) * Sum(factorial(k), (k, 1, 2*n))))
+    assert limit_seq(e, n) == S(3) / 16
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_lseries.py b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_lseries.py
new file mode 100644
index 0000000000000000000000000000000000000000..42d327bf60c76eebdc4570d631efef4bc84b58e3
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_lseries.py
@@ -0,0 +1,65 @@
+from sympy.core.numbers import E
+from sympy.core.singleton import S
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.hyperbolic import tanh
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.series.order import Order
+from sympy.abc import x, y
+
+
+def test_sin():
+    e = sin(x).lseries(x)
+    assert next(e) == x
+    assert next(e) == -x**3/6
+    assert next(e) == x**5/120
+
+
+def test_cos():
+    e = cos(x).lseries(x)
+    assert next(e) == 1
+    assert next(e) == -x**2/2
+    assert next(e) == x**4/24
+
+
+def test_exp():
+    e = exp(x).lseries(x)
+    assert next(e) == 1
+    assert next(e) == x
+    assert next(e) == x**2/2
+    assert next(e) == x**3/6
+
+
+def test_exp2():
+    e = exp(cos(x)).lseries(x)
+    assert next(e) == E
+    assert next(e) == -E*x**2/2
+    assert next(e) == E*x**4/6
+    assert next(e) == -31*E*x**6/720
+
+
+def test_simple():
+    assert list(x.lseries()) == [x]
+    assert list(S.One.lseries(x)) == [1]
+    assert not next((x/(x + y)).lseries(y)).has(Order)
+
+
+def test_issue_5183():
+    s = (x + 1/x).lseries()
+    assert list(s) == [1/x, x]
+    assert next((x + x**2).lseries()) == x
+    assert next(((1 + x)**7).lseries(x)) == 1
+    assert next((sin(x + y)).series(x, n=3).lseries(y)) == x
+    # it would be nice if all terms were grouped, but in the
+    # following case that would mean that all the terms would have
+    # to be known since, for example, every term has a constant in it.
+    s = ((1 + x)**7).series(x, 1, n=None)
+    assert [next(s) for i in range(2)] == [128, -448 + 448*x]
+
+
+def test_issue_6999():
+    s = tanh(x).lseries(x, 1)
+    assert next(s) == tanh(1)
+    assert next(s) == x - (x - 1)*tanh(1)**2 - 1
+    assert next(s) == -(x - 1)**2*tanh(1) + (x - 1)**2*tanh(1)**3
+    assert next(s) == -(x - 1)**3*tanh(1)**4 - (x - 1)**3/3 + \
+        4*(x - 1)**3*tanh(1)**2/3
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_nseries.py b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_nseries.py
new file mode 100644
index 0000000000000000000000000000000000000000..a2f20add82d3e858e2ce145fc9fcd4a6548a48cc
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_nseries.py
@@ -0,0 +1,557 @@
+from sympy.calculus.util import AccumBounds
+from sympy.core.function import (Derivative, PoleError)
+from sympy.core.numbers import (E, I, Integer, Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import sign
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.hyperbolic import (acosh, acoth, asinh, atanh, cosh, coth, sinh, tanh)
+from sympy.functions.elementary.integers import (ceiling, floor, frac)
+from sympy.functions.elementary.miscellaneous import (cbrt, sqrt)
+from sympy.functions.elementary.trigonometric import (asin, cos, cot, sin, tan)
+from sympy.series.limits import limit
+from sympy.series.order import O
+from sympy.abc import x, y, z
+
+from sympy.testing.pytest import raises, XFAIL
+
+
+def test_simple_1():
+    assert x.nseries(x, n=5) == x
+    assert y.nseries(x, n=5) == y
+    assert (1/(x*y)).nseries(y, n=5) == 1/(x*y)
+    assert Rational(3, 4).nseries(x, n=5) == Rational(3, 4)
+    assert x.nseries() == x
+
+
+def test_mul_0():
+    assert (x*log(x)).nseries(x, n=5) == x*log(x)
+
+
+def test_mul_1():
+    assert (x*log(2 + x)).nseries(x, n=5) == x*log(2) + x**2/2 - x**3/8 + \
+        x**4/24 + O(x**5)
+    assert (x*log(1 + x)).nseries(
+        x, n=5) == x**2 - x**3/2 + x**4/3 + O(x**5)
+
+
+def test_pow_0():
+    assert (x**2).nseries(x, n=5) == x**2
+    assert (1/x).nseries(x, n=5) == 1/x
+    assert (1/x**2).nseries(x, n=5) == 1/x**2
+    assert (x**Rational(2, 3)).nseries(x, n=5) == (x**Rational(2, 3))
+    assert (sqrt(x)**3).nseries(x, n=5) == (sqrt(x)**3)
+
+
+def test_pow_1():
+    assert ((1 + x)**2).nseries(x, n=5) == x**2 + 2*x + 1
+
+    # https://github.com/sympy/sympy/issues/21075
+    assert ((sqrt(x) + 1)**2).nseries(x) == 2*sqrt(x) + x + 1
+    assert ((sqrt(x) + cbrt(x))**2).nseries(x) == 2*x**Rational(5, 6)\
+        + x**Rational(2, 3) + x
+
+
+def test_geometric_1():
+    assert (1/(1 - x)).nseries(x, n=5) == 1 + x + x**2 + x**3 + x**4 + O(x**5)
+    assert (x/(1 - x)).nseries(x, n=6) == x + x**2 + x**3 + x**4 + x**5 + O(x**6)
+    assert (x**3/(1 - x)).nseries(x, n=8) == x**3 + x**4 + x**5 + x**6 + \
+        x**7 + O(x**8)
+
+
+def test_sqrt_1():
+    assert sqrt(1 + x).nseries(x, n=5) == 1 + x/2 - x**2/8 + x**3/16 - 5*x**4/128 + O(x**5)
+
+
+def test_exp_1():
+    assert exp(x).nseries(x, n=5) == 1 + x + x**2/2 + x**3/6 + x**4/24 + O(x**5)
+    assert exp(x).nseries(x, n=12) == 1 + x + x**2/2 + x**3/6 + x**4/24 + x**5/120 +  \
+        x**6/720 + x**7/5040 + x**8/40320 + x**9/362880 + x**10/3628800 +  \
+        x**11/39916800 + O(x**12)
+    assert exp(1/x).nseries(x, n=5) == exp(1/x)
+    assert exp(1/(1 + x)).nseries(x, n=4) ==  \
+        (E*(1 - x - 13*x**3/6 + 3*x**2/2)).expand() + O(x**4)
+    assert exp(2 + x).nseries(x, n=5) ==  \
+        (exp(2)*(1 + x + x**2/2 + x**3/6 + x**4/24)).expand() + O(x**5)
+
+
+def test_exp_sqrt_1():
+    assert exp(1 + sqrt(x)).nseries(x, n=3) ==  \
+        (exp(1)*(1 + sqrt(x) + x/2 + sqrt(x)*x/6)).expand() + O(sqrt(x)**3)
+
+
+def test_power_x_x1():
+    assert (exp(x*log(x))).nseries(x, n=4) == \
+        1 + x*log(x) + x**2*log(x)**2/2 + x**3*log(x)**3/6 + O(x**4*log(x)**4)
+
+
+def test_power_x_x2():
+    assert (x**x).nseries(x, n=4) == \
+        1 + x*log(x) + x**2*log(x)**2/2 + x**3*log(x)**3/6 + O(x**4*log(x)**4)
+
+
+def test_log_singular1():
+    assert log(1 + 1/x).nseries(x, n=5) == x - log(x) - x**2/2 + x**3/3 - \
+        x**4/4 + O(x**5)
+
+
+def test_log_power1():
+    e = 1 / (1/x + x ** (log(3)/log(2)))
+    assert e.nseries(x, n=5) == -x**(log(3)/log(2) + 2) + x + O(x**5)
+
+
+def test_log_series():
+    l = Symbol('l')
+    e = 1/(1 - log(x))
+    assert e.nseries(x, n=5, logx=l) == 1/(1 - l)
+
+
+def test_log2():
+    e = log(-1/x)
+    assert e.nseries(x, n=5) == -log(x) + log(-1)
+
+
+def test_log3():
+    l = Symbol('l')
+    e = 1/log(-1/x)
+    assert e.nseries(x, n=4, logx=l) == 1/(-l + log(-1))
+
+
+def test_series1():
+    e = sin(x)
+    assert e.nseries(x, 0, 0) != 0
+    assert e.nseries(x, 0, 0) == O(1, x)
+    assert e.nseries(x, 0, 1) == O(x, x)
+    assert e.nseries(x, 0, 2) == x + O(x**2, x)
+    assert e.nseries(x, 0, 3) == x + O(x**3, x)
+    assert e.nseries(x, 0, 4) == x - x**3/6 + O(x**4, x)
+
+    e = (exp(x) - 1)/x
+    assert e.nseries(x, 0, 3) == 1 + x/2 + x**2/6 + O(x**3)
+
+    assert x.nseries(x, 0, 2) == x
+
+
+@XFAIL
+def test_series1_failing():
+    assert x.nseries(x, 0, 0) == O(1, x)
+    assert x.nseries(x, 0, 1) == O(x, x)
+
+
+def test_seriesbug1():
+    assert (1/x).nseries(x, 0, 3) == 1/x
+    assert (x + 1/x).nseries(x, 0, 3) == x + 1/x
+
+
+def test_series2x():
+    assert ((x + 1)**(-2)).nseries(x, 0, 4) == 1 - 2*x + 3*x**2 - 4*x**3 + O(x**4, x)
+    assert ((x + 1)**(-1)).nseries(x, 0, 4) == 1 - x + x**2 - x**3 + O(x**4, x)
+    assert ((x + 1)**0).nseries(x, 0, 3) == 1
+    assert ((x + 1)**1).nseries(x, 0, 3) == 1 + x
+    assert ((x + 1)**2).nseries(x, 0, 3) == x**2 + 2*x + 1
+    assert ((x + 1)**3).nseries(x, 0, 3) == 1 + 3*x + 3*x**2 + O(x**3)
+
+    assert (1/(1 + x)).nseries(x, 0, 4) == 1 - x + x**2 - x**3 + O(x**4, x)
+    assert (x + 3/(1 + 2*x)).nseries(x, 0, 4) == 3 - 5*x + 12*x**2 - 24*x**3 + O(x**4, x)
+
+    assert ((1/x + 1)**3).nseries(x, 0, 3) == 1 + 3/x + 3/x**2 + x**(-3)
+    assert (1/(1 + 1/x)).nseries(x, 0, 4) == x - x**2 + x**3 - O(x**4, x)
+    assert (1/(1 + 1/x**2)).nseries(x, 0, 6) == x**2 - x**4 + O(x**6, x)
+
+
+def test_bug2():  # 1/log(0)*log(0) problem
+    w = Symbol("w")
+    e = (w**(-1) + w**(
+        -log(3)*log(2)**(-1)))**(-1)*(3*w**(-log(3)*log(2)**(-1)) + 2*w**(-1))
+    e = e.expand()
+    assert e.nseries(w, 0, 4).subs(w, 0) == 3
+
+
+def test_exp():
+    e = (1 + x)**(1/x)
+    assert e.nseries(x, n=3) == exp(1) - x*exp(1)/2 + 11*exp(1)*x**2/24 + O(x**3)
+
+
+def test_exp2():
+    w = Symbol("w")
+    e = w**(1 - log(x)/(log(2) + log(x)))
+    logw = Symbol("logw")
+    assert e.nseries(
+        w, 0, 1, logx=logw) == exp(logw*log(2)/(log(x) + log(2)))
+
+
+def test_bug3():
+    e = (2/x + 3/x**2)/(1/x + 1/x**2)
+    assert e.nseries(x, n=3) == 3 - x + x**2 + O(x**3)
+
+
+def test_generalexponent():
+    p = 2
+    e = (2/x + 3/x**p)/(1/x + 1/x**p)
+    assert e.nseries(x, 0, 3) == 3 - x + x**2 + O(x**3)
+    p = S.Half
+    e = (2/x + 3/x**p)/(1/x + 1/x**p)
+    assert e.nseries(x, 0, 2) == 2 - x + sqrt(x) + x**(S(3)/2) + O(x**2)
+
+    e = 1 + sqrt(x)
+    assert e.nseries(x, 0, 4) == 1 + sqrt(x)
+
+# more complicated example
+
+
+def test_genexp_x():
+    e = 1/(1 + sqrt(x))
+    assert e.nseries(x, 0, 2) == \
+        1 + x - sqrt(x) - sqrt(x)**3 + O(x**2, x)
+
+# more complicated example
+
+
+def test_genexp_x2():
+    p = Rational(3, 2)
+    e = (2/x + 3/x**p)/(1/x + 1/x**p)
+    assert e.nseries(x, 0, 3) == 3 + x + x**2 - sqrt(x) - x**(S(3)/2) - x**(S(5)/2) + O(x**3)
+
+
+def test_seriesbug2():
+    w = Symbol("w")
+    #simple case (1):
+    e = ((2*w)/w)**(1 + w)
+    assert e.nseries(w, 0, 1) == 2 + O(w, w)
+    assert e.nseries(w, 0, 1).subs(w, 0) == 2
+
+
+def test_seriesbug2b():
+    w = Symbol("w")
+    #test sin
+    e = sin(2*w)/w
+    assert e.nseries(w, 0, 3) == 2 - 4*w**2/3 + O(w**3)
+
+
+def test_seriesbug2d():
+    w = Symbol("w", real=True)
+    e = log(sin(2*w)/w)
+    assert e.series(w, n=5) == log(2) - 2*w**2/3 - 4*w**4/45 + O(w**5)
+
+
+def test_seriesbug2c():
+    w = Symbol("w", real=True)
+    #more complicated case, but sin(x)~x, so the result is the same as in (1)
+    e = (sin(2*w)/w)**(1 + w)
+    assert e.series(w, 0, 1) == 2 + O(w)
+    assert e.series(w, 0, 3) == 2 + 2*w*log(2) + \
+        w**2*(Rational(-4, 3) + log(2)**2) + O(w**3)
+    assert e.series(w, 0, 2).subs(w, 0) == 2
+
+
+def test_expbug4():
+    x = Symbol("x", real=True)
+    assert (log(
+        sin(2*x)/x)*(1 + x)).series(x, 0, 2) == log(2) + x*log(2) + O(x**2, x)
+    assert exp(
+        log(sin(2*x)/x)*(1 + x)).series(x, 0, 2) == 2 + 2*x*log(2) + O(x**2)
+
+    assert exp(log(2) + O(x)).nseries(x, 0, 2) == 2 + O(x)
+    assert ((2 + O(x))**(1 + x)).nseries(x, 0, 2) == 2 + O(x)
+
+
+def test_logbug4():
+    assert log(2 + O(x)).nseries(x, 0, 2) == log(2) + O(x, x)
+
+
+def test_expbug5():
+    assert exp(log(1 + x)/x).nseries(x, n=3) == exp(1) + -exp(1)*x/2 + 11*exp(1)*x**2/24 + O(x**3)
+
+    assert exp(O(x)).nseries(x, 0, 2) == 1 + O(x)
+
+
+def test_sinsinbug():
+    assert sin(sin(x)).nseries(x, 0, 8) == x - x**3/3 + x**5/10 - 8*x**7/315 + O(x**8)
+
+
+def test_issue_3258():
+    a = x/(exp(x) - 1)
+    assert a.nseries(x, 0, 5) == 1 - x/2 - x**4/720 + x**2/12 + O(x**5)
+
+
+def test_issue_3204():
+    x = Symbol("x", nonnegative=True)
+    f = sin(x**3)**Rational(1, 3)
+    assert f.nseries(x, 0, 17) == x - x**7/18 - x**13/3240 + O(x**17)
+
+
+def test_issue_3224():
+    f = sqrt(1 - sqrt(y))
+    assert f.nseries(y, 0, 2) == 1 - sqrt(y)/2 - y/8 - sqrt(y)**3/16 + O(y**2)
+
+
+def test_issue_3463():
+    w, i = symbols('w,i')
+    r = log(5)/log(3)
+    p = w**(-1 + r)
+    e = 1/x*(-log(w**(1 + r)) + log(w + w**r))
+    e_ser = -r*log(w)/x + p/x - p**2/(2*x) + O(w)
+    assert e.nseries(w, n=1) == e_ser
+
+
+def test_sin():
+    assert sin(8*x).nseries(x, n=4) == 8*x - 256*x**3/3 + O(x**4)
+    assert sin(x + y).nseries(x, n=1) == sin(y) + O(x)
+    assert sin(x + y).nseries(x, n=2) == sin(y) + cos(y)*x + O(x**2)
+    assert sin(x + y).nseries(x, n=5) == sin(y) + cos(y)*x - sin(y)*x**2/2 - \
+        cos(y)*x**3/6 + sin(y)*x**4/24 + O(x**5)
+
+
+def test_issue_3515():
+    e = sin(8*x)/x
+    assert e.nseries(x, n=6) == 8 - 256*x**2/3 + 4096*x**4/15 + O(x**6)
+
+
+def test_issue_3505():
+    e = sin(x)**(-4)*(sqrt(cos(x))*sin(x)**2 -
+        cos(x)**Rational(1, 3)*sin(x)**2)
+    assert e.nseries(x, n=9) == Rational(-1, 12) - 7*x**2/288 - \
+        43*x**4/10368 - 1123*x**6/2488320 + 377*x**8/29859840 + O(x**9)
+
+
+def test_issue_3501():
+    a = Symbol("a")
+    e = x**(-2)*(x*sin(a + x) - x*sin(a))
+    assert e.nseries(x, n=6) == cos(a) - sin(a)*x/2 - cos(a)*x**2/6 + \
+        x**3*sin(a)/24 + x**4*cos(a)/120 - x**5*sin(a)/720 + O(x**6)
+    e = x**(-2)*(x*cos(a + x) - x*cos(a))
+    assert e.nseries(x, n=6) == -sin(a) - cos(a)*x/2 + sin(a)*x**2/6 + \
+        cos(a)*x**3/24 - x**4*sin(a)/120 - x**5*cos(a)/720 + O(x**6)
+
+
+def test_issue_3502():
+    e = sin(5*x)/sin(2*x)
+    assert e.nseries(x, n=2) == Rational(5, 2) + O(x**2)
+    assert e.nseries(x, n=6) == \
+        Rational(5, 2) - 35*x**2/4 + 329*x**4/48 + O(x**6)
+
+
+def test_issue_3503():
+    e = sin(2 + x)/(2 + x)
+    assert e.nseries(x, n=2) == sin(2)/2 + x*cos(2)/2 - x*sin(2)/4 + O(x**2)
+
+
+def test_issue_3506():
+    e = (x + sin(3*x))**(-2)*(x*(x + sin(3*x)) - (x + sin(3*x))*sin(2*x))
+    assert e.nseries(x, n=7) == \
+        Rational(-1, 4) + 5*x**2/96 + 91*x**4/768 + 11117*x**6/129024 + O(x**7)
+
+
+def test_issue_3508():
+    x = Symbol("x", real=True)
+    assert log(sin(x)).series(x, n=5) == log(x) - x**2/6 - x**4/180 + O(x**5)
+    e = -log(x) + x*(-log(x) + log(sin(2*x))) + log(sin(2*x))
+    assert e.series(x, n=5) == \
+        log(2) + log(2)*x - 2*x**2/3 - 2*x**3/3 - 4*x**4/45 + O(x**5)
+
+
+def test_issue_3507():
+    e = x**(-4)*(x**2 - x**2*sqrt(cos(x)))
+    assert e.nseries(x, n=9) == \
+        Rational(1, 4) + x**2/96 + 19*x**4/5760 + 559*x**6/645120 + 29161*x**8/116121600 + O(x**9)
+
+
+def test_issue_3639():
+    assert sin(cos(x)).nseries(x, n=5) == \
+        sin(1) - x**2*cos(1)/2 - x**4*sin(1)/8 + x**4*cos(1)/24 + O(x**5)
+
+
+def test_hyperbolic():
+    assert sinh(x).nseries(x, n=6) == x + x**3/6 + x**5/120 + O(x**6)
+    assert cosh(x).nseries(x, n=5) == 1 + x**2/2 + x**4/24 + O(x**5)
+    assert tanh(x).nseries(x, n=6) == x - x**3/3 + 2*x**5/15 + O(x**6)
+    assert coth(x).nseries(x, n=6) == \
+        1/x - x**3/45 + x/3 + 2*x**5/945 + O(x**6)
+    assert asinh(x).nseries(x, n=6) == x - x**3/6 + 3*x**5/40 + O(x**6)
+    assert acosh(x).nseries(x, n=6) == \
+        pi*I/2 - I*x - 3*I*x**5/40 - I*x**3/6 + O(x**6)
+    assert atanh(x).nseries(x, n=6) == x + x**3/3 + x**5/5 + O(x**6)
+    assert acoth(x).nseries(x, n=6) == -I*pi/2 + x + x**3/3 + x**5/5 + O(x**6)
+
+
+def test_series2():
+    w = Symbol("w", real=True)
+    x = Symbol("x", real=True)
+    e = w**(-2)*(w*exp(1/x - w) - w*exp(1/x))
+    assert e.nseries(w, n=4) == -exp(1/x) + w*exp(1/x)/2 - w**2*exp(1/x)/6 + w**3*exp(1/x)/24 + O(w**4)
+
+
+def test_series3():
+    w = Symbol("w", real=True)
+    e = w**(-6)*(w**3*tan(w) - w**3*sin(w))
+    assert e.nseries(w, n=8) == Integer(1)/2 + w**2/8 + 13*w**4/240 + 529*w**6/24192 + O(w**8)
+
+
+def test_bug4():
+    w = Symbol("w")
+    e = x/(w**4 + x**2*w**4 + 2*x*w**4)*w**4
+    assert e.nseries(w, n=2).removeO().expand() in [x/(1 + 2*x + x**2),
+        1/(1 + x/2 + 1/x/2)/2, 1/x/(1 + 2/x + x**(-2))]
+
+
+def test_bug5():
+    w = Symbol("w")
+    l = Symbol('l')
+    e = (-log(w) + log(1 + w*log(x)))**(-2)*w**(-2)*((-log(w) +
+        log(1 + x*w))*(-log(w) + log(1 + w*log(x)))*w - x*(-log(w) +
+        log(1 + w*log(x)))*w)
+    assert e.nseries(w, n=0, logx=l) == x/w/l + 1/w + O(1, w)
+    assert e.nseries(w, n=1, logx=l) == x/w/l + 1/w - x/l + 1/l*log(x) \
+        + x*log(x)/l**2 + O(w)
+
+
+def test_issue_4115():
+    assert (sin(x)/(1 - cos(x))).nseries(x, n=1) == 2/x + O(x)
+    assert (sin(x)**2/(1 - cos(x))).nseries(x, n=1) == 2 + O(x)
+
+
+def test_pole():
+    raises(PoleError, lambda: sin(1/x).series(x, 0, 5))
+    raises(PoleError, lambda: sin(1 + 1/x).series(x, 0, 5))
+    raises(PoleError, lambda: (x*sin(1/x)).series(x, 0, 5))
+
+
+def test_expsinbug():
+    assert exp(sin(x)).series(x, 0, 0) == O(1, x)
+    assert exp(sin(x)).series(x, 0, 1) == 1 + O(x)
+    assert exp(sin(x)).series(x, 0, 2) == 1 + x + O(x**2)
+    assert exp(sin(x)).series(x, 0, 3) == 1 + x + x**2/2 + O(x**3)
+    assert exp(sin(x)).series(x, 0, 4) == 1 + x + x**2/2 + O(x**4)
+    assert exp(sin(x)).series(x, 0, 5) == 1 + x + x**2/2 - x**4/8 + O(x**5)
+
+
+def test_floor():
+    x = Symbol('x')
+    assert floor(x).series(x) == 0
+    assert floor(-x).series(x) == -1
+    assert floor(sin(x)).series(x) == 0
+    assert floor(sin(-x)).series(x) == -1
+    assert floor(x**3).series(x) == 0
+    assert floor(-x**3).series(x) == -1
+    assert floor(cos(x)).series(x) == 0
+    assert floor(cos(-x)).series(x) == 0
+    assert floor(5 + sin(x)).series(x) == 5
+    assert floor(5 + sin(-x)).series(x) == 4
+
+    assert floor(x).series(x, 2) == 2
+    assert floor(-x).series(x, 2) == -3
+
+    x = Symbol('x', negative=True)
+    assert floor(x + 1.5).series(x) == 1
+
+
+def test_frac():
+    assert frac(x).series(x, cdir=1) == x
+    assert frac(x).series(x, cdir=-1) == 1 + x
+    assert frac(2*x + 1).series(x, cdir=1) == 2*x
+    assert frac(2*x + 1).series(x, cdir=-1) == 1 + 2*x
+    assert frac(x**2).series(x, cdir=1) == x**2
+    assert frac(x**2).series(x, cdir=-1) == x**2
+    assert frac(sin(x) + 5).series(x, cdir=1) == x - x**3/6 + x**5/120 + O(x**6)
+    assert frac(sin(x) + 5).series(x, cdir=-1) == 1 + x - x**3/6 + x**5/120 + O(x**6)
+    assert frac(sin(x) + S.Half).series(x) == S.Half + x - x**3/6 + x**5/120 + O(x**6)
+    assert frac(x**8).series(x, cdir=1) == O(x**6)
+    assert frac(1/x).series(x) == AccumBounds(0, 1) + O(x**6)
+
+
+def test_ceiling():
+    assert ceiling(x).series(x) == 1
+    assert ceiling(-x).series(x) == 0
+    assert ceiling(sin(x)).series(x) == 1
+    assert ceiling(sin(-x)).series(x) == 0
+    assert ceiling(1 - cos(x)).series(x) == 1
+    assert ceiling(1 - cos(-x)).series(x) == 1
+    assert ceiling(x).series(x, 2) == 3
+    assert ceiling(-x).series(x, 2) == -2
+
+
+def test_abs():
+    a = Symbol('a')
+    assert abs(x).nseries(x, n=4) == x
+    assert abs(-x).nseries(x, n=4) == x
+    assert abs(x + 1).nseries(x, n=4) == x + 1
+    assert abs(sin(x)).nseries(x, n=4) == x - Rational(1, 6)*x**3 + O(x**4)
+    assert abs(sin(-x)).nseries(x, n=4) == x - Rational(1, 6)*x**3 + O(x**4)
+    assert abs(x - a).nseries(x, 1) == -a*sign(1 - a) + (x - 1)*sign(1 - a) + sign(1 - a)
+
+
+def test_dir():
+    assert abs(x).series(x, 0, dir="+") == x
+    assert abs(x).series(x, 0, dir="-") == -x
+    assert floor(x + 2).series(x, 0, dir='+') == 2
+    assert floor(x + 2).series(x, 0, dir='-') == 1
+    assert floor(x + 2.2).series(x, 0, dir='-') == 2
+    assert ceiling(x + 2.2).series(x, 0, dir='-') == 3
+    assert sin(x + y).series(x, 0, dir='-') == sin(x + y).series(x, 0, dir='+')
+
+
+def test_cdir():
+    assert abs(x).series(x, 0, cdir=1) == x
+    assert abs(x).series(x, 0, cdir=-1) == -x
+    assert floor(x + 2).series(x, 0, cdir=1) == 2
+    assert floor(x + 2).series(x, 0, cdir=-1) == 1
+    assert floor(x + 2.2).series(x, 0, cdir=1) == 2
+    assert ceiling(x + 2.2).series(x, 0, cdir=-1) == 3
+    assert sin(x + y).series(x, 0, cdir=-1) == sin(x + y).series(x, 0, cdir=1)
+
+
+def test_issue_3504():
+    a = Symbol("a")
+    e = asin(a*x)/x
+    assert e.series(x, 4, n=2).removeO() == \
+        (x - 4)*(a/(4*sqrt(-16*a**2 + 1)) - asin(4*a)/16) + asin(4*a)/4
+
+
+def test_issue_4441():
+    a, b = symbols('a,b')
+    f = 1/(1 + a*x)
+    assert f.series(x, 0, 5) == 1 - a*x + a**2*x**2 - a**3*x**3 + \
+        a**4*x**4 + O(x**5)
+    f = 1/(1 + (a + b)*x)
+    assert f.series(x, 0, 3) == 1 + x*(-a - b)\
+        + x**2*(a + b)**2 + O(x**3)
+
+
+def test_issue_4329():
+    assert tan(x).series(x, pi/2, n=3).removeO() == \
+        -pi/6 + x/3 - 1/(x - pi/2)
+    assert cot(x).series(x, pi, n=3).removeO() == \
+        -x/3 + pi/3 + 1/(x - pi)
+    assert limit(tan(x)**tan(2*x), x, pi/4) == exp(-1)
+
+
+def test_issue_5183():
+    assert abs(x + x**2).series(n=1) == O(x)
+    assert abs(x + x**2).series(n=2) == x + O(x**2)
+    assert ((1 + x)**2).series(x, n=6) == x**2 + 2*x + 1
+    assert (1 + 1/x).series() == 1 + 1/x
+    assert Derivative(exp(x).series(), x).doit() == \
+        1 + x + x**2/2 + x**3/6 + x**4/24 + O(x**5)
+
+
+def test_issue_5654():
+    a = Symbol('a')
+    assert (1/(x**2+a**2)**2).nseries(x, x0=I*a, n=0) == \
+        -I/(4*a**3*(-I*a + x)) - 1/(4*a**2*(-I*a + x)**2) + O(1, (x, I*a))
+    assert (1/(x**2+a**2)**2).nseries(x, x0=I*a, n=1) == 3/(16*a**4) \
+        -I/(4*a**3*(-I*a + x)) - 1/(4*a**2*(-I*a + x)**2) + O(-I*a + x, (x, I*a))
+
+
+def test_issue_5925():
+    sx = sqrt(x + z).series(z, 0, 1)
+    sxy = sqrt(x + y + z).series(z, 0, 1)
+    s1, s2 = sx.subs(x, x + y), sxy
+    assert (s1 - s2).expand().removeO().simplify() == 0
+
+    sx = sqrt(x + z).series(z, 0, 1)
+    sxy = sqrt(x + y + z).series(z, 0, 1)
+    assert sxy.subs({x:1, y:2}) == sx.subs(x, 3)
+
+
+def test_exp_2():
+    assert exp(x**3).nseries(x, 0, 14) == 1 + x**3 + x**6/2 + x**9/6 + x**12/24 + O(x**14)
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_order.py b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_order.py
new file mode 100644
index 0000000000000000000000000000000000000000..dd4cd9938d6ebbc4d8d915e09ec6e9c02c6fe599
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_order.py
@@ -0,0 +1,477 @@
+from sympy.core.add import Add
+from sympy.core.function import (Function, expand)
+from sympy.core.numbers import (I, Rational, nan, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import (conjugate, transpose)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.integrals.integrals import Integral
+from sympy.series.order import O, Order
+from sympy.core.expr import unchanged
+from sympy.testing.pytest import raises
+from sympy.abc import w, x, y, z
+
+
+def test_caching_bug():
+    #needs to be a first test, so that all caches are clean
+    #cache it
+    O(w)
+    #and test that this won't raise an exception
+    O(w**(-1/x/log(3)*log(5)), w)
+
+
+def test_free_symbols():
+    assert Order(1).free_symbols == set()
+    assert Order(x).free_symbols == {x}
+    assert Order(1, x).free_symbols == {x}
+    assert Order(x*y).free_symbols == {x, y}
+    assert Order(x, x, y).free_symbols == {x, y}
+
+
+def test_simple_1():
+    o = Rational(0)
+    assert Order(2*x) == Order(x)
+    assert Order(x)*3 == Order(x)
+    assert -28*Order(x) == Order(x)
+    assert Order(Order(x)) == Order(x)
+    assert Order(Order(x), y) == Order(Order(x), x, y)
+    assert Order(-23) == Order(1)
+    assert Order(exp(x)) == Order(1, x)
+    assert Order(exp(1/x)).expr == exp(1/x)
+    assert Order(x*exp(1/x)).expr == x*exp(1/x)
+    assert Order(x**(o/3)).expr == x**(o/3)
+    assert Order(x**(o*Rational(5, 3))).expr == x**(o*Rational(5, 3))
+    assert Order(x**2 + x + y, x) == O(1, x)
+    assert Order(x**2 + x + y, y) == O(1, y)
+    raises(ValueError, lambda: Order(exp(x), x, x))
+    raises(TypeError, lambda: Order(x, 2 - x))
+
+
+def test_simple_2():
+    assert Order(2*x)*x == Order(x**2)
+    assert Order(2*x)/x == Order(1, x)
+    assert Order(2*x)*x*exp(1/x) == Order(x**2*exp(1/x))
+    assert (Order(2*x)*x*exp(1/x)/log(x)**3).expr == x**2*exp(1/x)*log(x)**-3
+
+
+def test_simple_3():
+    assert Order(x) + x == Order(x)
+    assert Order(x) + 2 == 2 + Order(x)
+    assert Order(x) + x**2 == Order(x)
+    assert Order(x) + 1/x == 1/x + Order(x)
+    assert Order(1/x) + 1/x**2 == 1/x**2 + Order(1/x)
+    assert Order(x) + exp(1/x) == Order(x) + exp(1/x)
+
+
+def test_simple_4():
+    assert Order(x)**2 == Order(x**2)
+
+
+def test_simple_5():
+    assert Order(x) + Order(x**2) == Order(x)
+    assert Order(x) + Order(x**-2) == Order(x**-2)
+    assert Order(x) + Order(1/x) == Order(1/x)
+
+
+def test_simple_6():
+    assert Order(x) - Order(x) == Order(x)
+    assert Order(x) + Order(1) == Order(1)
+    assert Order(x) + Order(x**2) == Order(x)
+    assert Order(1/x) + Order(1) == Order(1/x)
+    assert Order(x) + Order(exp(1/x)) == Order(exp(1/x))
+    assert Order(x**3) + Order(exp(2/x)) == Order(exp(2/x))
+    assert Order(x**-3) + Order(exp(2/x)) == Order(exp(2/x))
+
+
+def test_simple_7():
+    assert 1 + O(1) == O(1)
+    assert 2 + O(1) == O(1)
+    assert x + O(1) == O(1)
+    assert 1/x + O(1) == 1/x + O(1)
+
+
+def test_simple_8():
+    assert O(sqrt(-x)) == O(sqrt(x))
+    assert O(x**2*sqrt(x)) == O(x**Rational(5, 2))
+    assert O(x**3*sqrt(-(-x)**3)) == O(x**Rational(9, 2))
+    assert O(x**Rational(3, 2)*sqrt((-x)**3)) == O(x**3)
+    assert O(x*(-2*x)**(I/2)) == O(x*(-x)**(I/2))
+
+
+def test_as_expr_variables():
+    assert Order(x).as_expr_variables(None) == (x, ((x, 0),))
+    assert Order(x).as_expr_variables(((x, 0),)) == (x, ((x, 0),))
+    assert Order(y).as_expr_variables(((x, 0),)) == (y, ((x, 0), (y, 0)))
+    assert Order(y).as_expr_variables(((x, 0), (y, 0))) == (y, ((x, 0), (y, 0)))
+
+
+def test_contains_0():
+    assert Order(1, x).contains(Order(1, x))
+    assert Order(1, x).contains(Order(1))
+    assert Order(1).contains(Order(1, x)) is False
+
+
+def test_contains_1():
+    assert Order(x).contains(Order(x))
+    assert Order(x).contains(Order(x**2))
+    assert not Order(x**2).contains(Order(x))
+    assert not Order(x).contains(Order(1/x))
+    assert not Order(1/x).contains(Order(exp(1/x)))
+    assert not Order(x).contains(Order(exp(1/x)))
+    assert Order(1/x).contains(Order(x))
+    assert Order(exp(1/x)).contains(Order(x))
+    assert Order(exp(1/x)).contains(Order(1/x))
+    assert Order(exp(1/x)).contains(Order(exp(1/x)))
+    assert Order(exp(2/x)).contains(Order(exp(1/x)))
+    assert not Order(exp(1/x)).contains(Order(exp(2/x)))
+
+
+def test_contains_2():
+    assert Order(x).contains(Order(y)) is None
+    assert Order(x).contains(Order(y*x))
+    assert Order(y*x).contains(Order(x))
+    assert Order(y).contains(Order(x*y))
+    assert Order(x).contains(Order(y**2*x))
+
+
+def test_contains_3():
+    assert Order(x*y**2).contains(Order(x**2*y)) is None
+    assert Order(x**2*y).contains(Order(x*y**2)) is None
+
+
+def test_contains_4():
+    assert Order(sin(1/x**2)).contains(Order(cos(1/x**2))) is True
+    assert Order(cos(1/x**2)).contains(Order(sin(1/x**2))) is True
+
+
+def test_contains():
+    assert Order(1, x) not in Order(1)
+    assert Order(1) in Order(1, x)
+    raises(TypeError, lambda: Order(x*y**2) in Order(x**2*y))
+
+
+def test_add_1():
+    assert Order(x + x) == Order(x)
+    assert Order(3*x - 2*x**2) == Order(x)
+    assert Order(1 + x) == Order(1, x)
+    assert Order(1 + 1/x) == Order(1/x)
+    # TODO : A better output for Order(log(x) + 1/log(x))
+    # could be Order(log(x)). Currently Order for expressions
+    # where all arguments would involve a log term would fall
+    # in this category and outputs for these should be improved.
+    assert Order(log(x) + 1/log(x)) == Order((log(x)**2 + 1)/log(x))
+    assert Order(exp(1/x) + x) == Order(exp(1/x))
+    assert Order(exp(1/x) + 1/x**20) == Order(exp(1/x))
+
+
+def test_ln_args():
+    assert O(log(x)) + O(log(2*x)) == O(log(x))
+    assert O(log(x)) + O(log(x**3)) == O(log(x))
+    assert O(log(x*y)) + O(log(x) + log(y)) == O(log(x) + log(y), x, y)
+
+
+def test_multivar_0():
+    assert Order(x*y).expr == x*y
+    assert Order(x*y**2).expr == x*y**2
+    assert Order(x*y, x).expr == x
+    assert Order(x*y**2, y).expr == y**2
+    assert Order(x*y*z).expr == x*y*z
+    assert Order(x/y).expr == x/y
+    assert Order(x*exp(1/y)).expr == x*exp(1/y)
+    assert Order(exp(x)*exp(1/y)).expr == exp(x)*exp(1/y)
+
+
+def test_multivar_0a():
+    assert Order(exp(1/x)*exp(1/y)).expr == exp(1/x)*exp(1/y)
+
+
+def test_multivar_1():
+    assert Order(x + y).expr == x + y
+    assert Order(x + 2*y).expr == x + y
+    assert (Order(x + y) + x).expr == (x + y)
+    assert (Order(x + y) + x**2) == Order(x + y)
+    assert (Order(x + y) + 1/x) == 1/x + Order(x + y)
+    assert Order(x**2 + y*x).expr == x**2 + y*x
+
+
+def test_multivar_2():
+    assert Order(x**2*y + y**2*x, x, y).expr == x**2*y + y**2*x
+
+
+def test_multivar_mul_1():
+    assert Order(x + y)*x == Order(x**2 + y*x, x, y)
+
+
+def test_multivar_3():
+    assert (Order(x) + Order(y)).args in [
+        (Order(x), Order(y)),
+        (Order(y), Order(x))]
+    assert Order(x) + Order(y) + Order(x + y) == Order(x + y)
+    assert (Order(x**2*y) + Order(y**2*x)).args in [
+        (Order(x*y**2), Order(y*x**2)),
+        (Order(y*x**2), Order(x*y**2))]
+    assert (Order(x**2*y) + Order(y*x)) == Order(x*y)
+
+
+def test_issue_3468():
+    y = Symbol('y', negative=True)
+    z = Symbol('z', complex=True)
+
+    # check that Order does not modify assumptions about symbols
+    Order(x)
+    Order(y)
+    Order(z)
+
+    assert x.is_positive is None
+    assert y.is_positive is False
+    assert z.is_positive is None
+
+
+def test_leading_order():
+    assert (x + 1 + 1/x**5).extract_leading_order(x) == ((1/x**5, O(1/x**5)),)
+    assert (1 + 1/x).extract_leading_order(x) == ((1/x, O(1/x)),)
+    assert (1 + x).extract_leading_order(x) == ((1, O(1, x)),)
+    assert (1 + x**2).extract_leading_order(x) == ((1, O(1, x)),)
+    assert (2 + x**2).extract_leading_order(x) == ((2, O(1, x)),)
+    assert (x + x**2).extract_leading_order(x) == ((x, O(x)),)
+
+
+def test_leading_order2():
+    assert set((2 + pi + x**2).extract_leading_order(x)) == {(pi, O(1, x)),
+            (S(2), O(1, x))}
+    assert set((2*x + pi*x + x**2).extract_leading_order(x)) == {(2*x, O(x)),
+            (x*pi, O(x))}
+
+
+def test_order_leadterm():
+    assert O(x**2)._eval_as_leading_term(x) == O(x**2)
+
+
+def test_order_symbols():
+    e = x*y*sin(x)*Integral(x, (x, 1, 2))
+    assert O(e) == O(x**2*y, x, y)
+    assert O(e, x) == O(x**2)
+
+
+def test_nan():
+    assert O(nan) is nan
+    assert not O(x).contains(nan)
+
+
+def test_O1():
+    assert O(1, x) * x == O(x)
+    assert O(1, y) * x == O(1, y)
+
+
+def test_getn():
+    # other lines are tested incidentally by the suite
+    assert O(x).getn() == 1
+    assert O(x/log(x)).getn() == 1
+    assert O(x**2/log(x)**2).getn() == 2
+    assert O(x*log(x)).getn() == 1
+    raises(NotImplementedError, lambda: (O(x) + O(y)).getn())
+
+
+def test_diff():
+    assert O(x**2).diff(x) == O(x)
+
+
+def test_getO():
+    assert (x).getO() is None
+    assert (x).removeO() == x
+    assert (O(x)).getO() == O(x)
+    assert (O(x)).removeO() == 0
+    assert (z + O(x) + O(y)).getO() == O(x) + O(y)
+    assert (z + O(x) + O(y)).removeO() == z
+    raises(NotImplementedError, lambda: (O(x) + O(y)).getn())
+
+
+def test_leading_term():
+    from sympy.functions.special.gamma_functions import digamma
+    assert O(1/digamma(1/x)) == O(1/log(x))
+
+
+def test_eval():
+    assert Order(x).subs(Order(x), 1) == 1
+    assert Order(x).subs(x, y) == Order(y)
+    assert Order(x).subs(y, x) == Order(x)
+    assert Order(x).subs(x, x + y) == Order(x + y, (x, -y))
+    assert (O(1)**x).is_Pow
+
+
+def test_issue_4279():
+    a, b = symbols('a b')
+    assert O(a, a, b) + O(1, a, b) == O(1, a, b)
+    assert O(b, a, b) + O(1, a, b) == O(1, a, b)
+    assert O(a + b, a, b) + O(1, a, b) == O(1, a, b)
+    assert O(1, a, b) + O(a, a, b) == O(1, a, b)
+    assert O(1, a, b) + O(b, a, b) == O(1, a, b)
+    assert O(1, a, b) + O(a + b, a, b) == O(1, a, b)
+
+
+def test_issue_4855():
+    assert 1/O(1) != O(1)
+    assert 1/O(x) != O(1/x)
+    assert 1/O(x, (x, oo)) != O(1/x, (x, oo))
+
+    f = Function('f')
+    assert 1/O(f(x)) != O(1/x)
+
+
+def test_order_conjugate_transpose():
+    x = Symbol('x', real=True)
+    y = Symbol('y', imaginary=True)
+    assert conjugate(Order(x)) == Order(conjugate(x))
+    assert conjugate(Order(y)) == Order(conjugate(y))
+    assert conjugate(Order(x**2)) == Order(conjugate(x)**2)
+    assert conjugate(Order(y**2)) == Order(conjugate(y)**2)
+    assert transpose(Order(x)) == Order(transpose(x))
+    assert transpose(Order(y)) == Order(transpose(y))
+    assert transpose(Order(x**2)) == Order(transpose(x)**2)
+    assert transpose(Order(y**2)) == Order(transpose(y)**2)
+
+
+def test_order_noncommutative():
+    A = Symbol('A', commutative=False)
+    assert Order(A + A*x, x) == Order(1, x)
+    assert (A + A*x)*Order(x) == Order(x)
+    assert (A*x)*Order(x) == Order(x**2, x)
+    assert expand((1 + Order(x))*A*A*x) == A*A*x + Order(x**2, x)
+    assert expand((A*A + Order(x))*x) == A*A*x + Order(x**2, x)
+    assert expand((A + Order(x))*A*x) == A*A*x + Order(x**2, x)
+
+
+def test_issue_6753():
+    assert (1 + x**2)**10000*O(x) == O(x)
+
+
+def test_order_at_infinity():
+    assert Order(1 + x, (x, oo)) == Order(x, (x, oo))
+    assert Order(3*x, (x, oo)) == Order(x, (x, oo))
+    assert Order(x, (x, oo))*3 == Order(x, (x, oo))
+    assert -28*Order(x, (x, oo)) == Order(x, (x, oo))
+    assert Order(Order(x, (x, oo)), (x, oo)) == Order(x, (x, oo))
+    assert Order(Order(x, (x, oo)), (y, oo)) == Order(x, (x, oo), (y, oo))
+    assert Order(3, (x, oo)) == Order(1, (x, oo))
+    assert Order(x**2 + x + y, (x, oo)) == O(x**2, (x, oo))
+    assert Order(x**2 + x + y, (y, oo)) == O(y, (y, oo))
+
+    assert Order(2*x, (x, oo))*x == Order(x**2, (x, oo))
+    assert Order(2*x, (x, oo))/x == Order(1, (x, oo))
+    assert Order(2*x, (x, oo))*x*exp(1/x) == Order(x**2*exp(1/x), (x, oo))
+    assert Order(2*x, (x, oo))*x*exp(1/x)/log(x)**3 == Order(x**2*exp(1/x)*log(x)**-3, (x, oo))
+
+    assert Order(x, (x, oo)) + 1/x == 1/x + Order(x, (x, oo)) == Order(x, (x, oo))
+    assert Order(x, (x, oo)) + 1 == 1 + Order(x, (x, oo)) == Order(x, (x, oo))
+    assert Order(x, (x, oo)) + x == x + Order(x, (x, oo)) == Order(x, (x, oo))
+    assert Order(x, (x, oo)) + x**2 == x**2 + Order(x, (x, oo))
+    assert Order(1/x, (x, oo)) + 1/x**2 == 1/x**2 + Order(1/x, (x, oo)) == Order(1/x, (x, oo))
+    assert Order(x, (x, oo)) + exp(1/x) == exp(1/x) + Order(x, (x, oo))
+
+    assert Order(x, (x, oo))**2 == Order(x**2, (x, oo))
+
+    assert Order(x, (x, oo)) + Order(x**2, (x, oo)) == Order(x**2, (x, oo))
+    assert Order(x, (x, oo)) + Order(x**-2, (x, oo)) == Order(x, (x, oo))
+    assert Order(x, (x, oo)) + Order(1/x, (x, oo)) == Order(x, (x, oo))
+
+    assert Order(x, (x, oo)) - Order(x, (x, oo)) == Order(x, (x, oo))
+    assert Order(x, (x, oo)) + Order(1, (x, oo)) == Order(x, (x, oo))
+    assert Order(x, (x, oo)) + Order(x**2, (x, oo)) == Order(x**2, (x, oo))
+    assert Order(1/x, (x, oo)) + Order(1, (x, oo)) == Order(1, (x, oo))
+    assert Order(x, (x, oo)) + Order(exp(1/x), (x, oo)) == Order(x, (x, oo))
+    assert Order(x**3, (x, oo)) + Order(exp(2/x), (x, oo)) == Order(x**3, (x, oo))
+    assert Order(x**-3, (x, oo)) + Order(exp(2/x), (x, oo)) == Order(exp(2/x), (x, oo))
+
+    # issue 7207
+    assert Order(exp(x), (x, oo)).expr == Order(2*exp(x), (x, oo)).expr == exp(x)
+    assert Order(y**x, (x, oo)).expr == Order(2*y**x, (x, oo)).expr == exp(x*log(y))
+
+    # issue 19545
+    assert Order(1/x - 3/(3*x + 2), (x, oo)).expr == x**(-2)
+
+def test_mixing_order_at_zero_and_infinity():
+    assert (Order(x, (x, 0)) + Order(x, (x, oo))).is_Add
+    assert Order(x, (x, 0)) + Order(x, (x, oo)) == Order(x, (x, oo)) + Order(x, (x, 0))
+    assert Order(Order(x, (x, oo))) == Order(x, (x, oo))
+
+    # not supported (yet)
+    raises(NotImplementedError, lambda: Order(x, (x, 0))*Order(x, (x, oo)))
+    raises(NotImplementedError, lambda: Order(x, (x, oo))*Order(x, (x, 0)))
+    raises(NotImplementedError, lambda: Order(Order(x, (x, oo)), y))
+    raises(NotImplementedError, lambda: Order(Order(x), (x, oo)))
+
+
+def test_order_at_some_point():
+    assert Order(x, (x, 1)) == Order(1, (x, 1))
+    assert Order(2*x - 2, (x, 1)) == Order(x - 1, (x, 1))
+    assert Order(-x + 1, (x, 1)) == Order(x - 1, (x, 1))
+    assert Order(x - 1, (x, 1))**2 == Order((x - 1)**2, (x, 1))
+    assert Order(x - 2, (x, 2)) - O(x - 2, (x, 2)) == Order(x - 2, (x, 2))
+
+
+def test_order_subs_limits():
+    # issue 3333
+    assert (1 + Order(x)).subs(x, 1/x) == 1 + Order(1/x, (x, oo))
+    assert (1 + Order(x)).limit(x, 0) == 1
+    # issue 5769
+    assert ((x + Order(x**2))/x).limit(x, 0) == 1
+
+    assert Order(x**2).subs(x, y - 1) == Order((y - 1)**2, (y, 1))
+    assert Order(10*x**2, (x, 2)).subs(x, y - 1) == Order(1, (y, 3))
+
+
+def test_issue_9351():
+    assert exp(x).series(x, 10, 1) == exp(10) + Order(x - 10, (x, 10))
+
+
+def test_issue_9192():
+    assert O(1)*O(1) == O(1)
+    assert O(1)**O(1) == O(1)
+
+
+def test_issue_9910():
+    assert O(x*log(x) + sin(x), (x, oo)) == O(x*log(x), (x, oo))
+
+
+def test_performance_of_adding_order():
+    l = [x**i for i in range(1000)]
+    l.append(O(x**1001))
+    assert Add(*l).subs(x,1) == O(1)
+
+def test_issue_14622():
+    assert (x**(-4) + x**(-3) + x**(-1) + O(x**(-6), (x, oo))).as_numer_denom() == (
+        x**4 + x**5 + x**7 + O(x**2, (x, oo)), x**8)
+    assert (x**3 + O(x**2, (x, oo))).is_Add
+    assert O(x**2, (x, oo)).contains(x**3) is False
+    assert O(x, (x, oo)).contains(O(x, (x, 0))) is None
+    assert O(x, (x, 0)).contains(O(x, (x, oo))) is None
+    raises(NotImplementedError, lambda: O(x**3).contains(x**w))
+
+
+def test_issue_15539():
+    assert O(1/x**2 + 1/x**4, (x, -oo)) == O(1/x**2, (x, -oo))
+    assert O(1/x**4 + exp(x), (x, -oo)) == O(1/x**4, (x, -oo))
+    assert O(1/x**4 + exp(-x), (x, -oo)) == O(exp(-x), (x, -oo))
+    assert O(1/x, (x, oo)).subs(x, -x) == O(-1/x, (x, -oo))
+
+def test_issue_18606():
+    assert unchanged(Order, 0)
+
+
+def test_issue_22165():
+    assert O(log(x)).contains(2)
+
+
+def test_issue_23231():
+    # This test checks Order for expressions having
+    # arguments containing variables in exponents/powers.
+    assert O(x**x + 2**x, (x, oo)) == O(exp(x*log(x)), (x, oo))
+    assert O(x**x + x**2, (x, oo)) == O(exp(x*log(x)), (x, oo))
+    assert O(x**x + 1/x**2, (x, oo)) == O(exp(x*log(x)), (x, oo))
+    assert O(2**x + 3**x , (x, oo)) == O(exp(x*log(3)), (x, oo))
+
+
+def test_issue_9917():
+    assert O(x*sin(x) + 1, (x, oo)) == O(x, (x, oo))
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_residues.py b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_residues.py
new file mode 100644
index 0000000000000000000000000000000000000000..9f7d075a56500d008e3c8b46c1fda5db890fd76a
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_residues.py
@@ -0,0 +1,101 @@
+from sympy.core.function import Function
+from sympy.core.numbers import (I, Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.hyperbolic import tanh
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cot, sin, tan)
+from sympy.series.residues import residue
+from sympy.testing.pytest import XFAIL, raises
+from sympy.abc import x, z, a, s, k
+
+
+def test_basic1():
+    assert residue(1/x, x, 0) == 1
+    assert residue(-2/x, x, 0) == -2
+    assert residue(81/x, x, 0) == 81
+    assert residue(1/x**2, x, 0) == 0
+    assert residue(0, x, 0) == 0
+    assert residue(5, x, 0) == 0
+    assert residue(x, x, 0) == 0
+    assert residue(x**2, x, 0) == 0
+
+
+def test_basic2():
+    assert residue(1/x, x, 1) == 0
+    assert residue(-2/x, x, 1) == 0
+    assert residue(81/x, x, -1) == 0
+    assert residue(1/x**2, x, 1) == 0
+    assert residue(0, x, 1) == 0
+    assert residue(5, x, 1) == 0
+    assert residue(x, x, 1) == 0
+    assert residue(x**2, x, 5) == 0
+
+
+def test_f():
+    f = Function("f")
+    assert residue(f(x)/x**5, x, 0) == f(x).diff(x, 4).subs(x, 0)/24
+
+
+def test_functions():
+    assert residue(1/sin(x), x, 0) == 1
+    assert residue(2/sin(x), x, 0) == 2
+    assert residue(1/sin(x)**2, x, 0) == 0
+    assert residue(1/sin(x)**5, x, 0) == Rational(3, 8)
+
+
+def test_expressions():
+    assert residue(1/(x + 1), x, 0) == 0
+    assert residue(1/(x + 1), x, -1) == 1
+    assert residue(1/(x**2 + 1), x, -1) == 0
+    assert residue(1/(x**2 + 1), x, I) == -I/2
+    assert residue(1/(x**2 + 1), x, -I) == I/2
+    assert residue(1/(x**4 + 1), x, 0) == 0
+    assert residue(1/(x**4 + 1), x, exp(I*pi/4)).equals(-(Rational(1, 4) + I/4)/sqrt(2))
+    assert residue(1/(x**2 + a**2)**2, x, a*I) == -I/4/a**3
+
+
+@XFAIL
+def test_expressions_failing():
+    n = Symbol('n', integer=True, positive=True)
+    assert residue(exp(z)/(z - pi*I/4*a)**n, z, I*pi*a) == \
+        exp(I*pi*a/4)/factorial(n - 1)
+
+
+def test_NotImplemented():
+    raises(NotImplementedError, lambda: residue(exp(1/z), z, 0))
+
+
+def test_bug():
+    assert residue(2**(z)*(s + z)*(1 - s - z)/z**2, z, 0) == \
+        1 + s*log(2) - s**2*log(2) - 2*s
+
+
+def test_issue_5654():
+    assert residue(1/(x**2 + a**2)**2, x, a*I) == -I/(4*a**3)
+    assert residue(1/s*1/(z - exp(s)), s, 0) == 1/(z - 1)
+    assert residue((1 + k)/s*1/(z - exp(s)), s, 0) == k/(z - 1) + 1/(z - 1)
+
+
+def test_issue_6499():
+    assert residue(1/(exp(z) - 1), z, 0) == 1
+
+
+def test_issue_14037():
+    assert residue(sin(x**50)/x**51, x, 0) == 1
+
+
+def test_issue_21176():
+    f = x**2*cot(pi*x)/(x**4 + 1)
+    assert residue(f, x, -sqrt(2)/2 - sqrt(2)*I/2).cancel().together(deep=True)\
+        == sqrt(2)*(1 - I)/(8*tan(sqrt(2)*pi*(1 + I)/2))
+
+
+def test_issue_21177():
+    r = -sqrt(3)*tanh(sqrt(3)*pi/2)/3
+    a = residue(cot(pi*x)/((x - 1)*(x - 2) + 1), x, S(3)/2 - sqrt(3)*I/2)
+    b = residue(cot(pi*x)/(x**2 - 3*x + 3), x, S(3)/2 - sqrt(3)*I/2)
+    assert a == r
+    assert (b - a).cancel() == 0
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_sequences.py b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_sequences.py
new file mode 100644
index 0000000000000000000000000000000000000000..61e276ad67982f0a9877de3548d70238976d28a5
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_sequences.py
@@ -0,0 +1,312 @@
+from sympy.core.containers import Tuple
+from sympy.core.function import Function
+from sympy.core.numbers import oo, Rational
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols, Symbol
+from sympy.functions.combinatorial.numbers import tribonacci, fibonacci
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import cos, sin
+from sympy.series import EmptySequence
+from sympy.series.sequences import (SeqMul, SeqAdd, SeqPer, SeqFormula,
+    sequence)
+from sympy.sets.sets import Interval
+from sympy.tensor.indexed import Indexed, Idx
+from sympy.series.sequences import SeqExpr, SeqExprOp, RecursiveSeq
+from sympy.testing.pytest import raises, slow
+
+x, y, z = symbols('x y z')
+n, m = symbols('n m')
+
+
+def test_EmptySequence():
+    assert S.EmptySequence is EmptySequence
+
+    assert S.EmptySequence.interval is S.EmptySet
+    assert S.EmptySequence.length is S.Zero
+
+    assert list(S.EmptySequence) == []
+
+
+def test_SeqExpr():
+    #SeqExpr is a baseclass and does not take care of
+    #ensuring all arguments are Basics hence the use of
+    #Tuple(...) here.
+    s = SeqExpr(Tuple(1, n, y), Tuple(x, 0, 10))
+
+    assert isinstance(s, SeqExpr)
+    assert s.gen == (1, n, y)
+    assert s.interval == Interval(0, 10)
+    assert s.start == 0
+    assert s.stop == 10
+    assert s.length == 11
+    assert s.variables == (x,)
+
+    assert SeqExpr(Tuple(1, 2, 3), Tuple(x, 0, oo)).length is oo
+
+
+def test_SeqPer():
+    s = SeqPer((1, n, 3), (x, 0, 5))
+
+    assert isinstance(s, SeqPer)
+    assert s.periodical == Tuple(1, n, 3)
+    assert s.period == 3
+    assert s.coeff(3) == 1
+    assert s.free_symbols == {n}
+
+    assert list(s) == [1, n, 3, 1, n, 3]
+    assert s[:] == [1, n, 3, 1, n, 3]
+    assert SeqPer((1, n, 3), (x, -oo, 0))[0:6] == [1, n, 3, 1, n, 3]
+
+    raises(ValueError, lambda: SeqPer((1, 2, 3), (0, 1, 2)))
+    raises(ValueError, lambda: SeqPer((1, 2, 3), (x, -oo, oo)))
+    raises(ValueError, lambda: SeqPer(n**2, (0, oo)))
+
+    assert SeqPer((n, n**2, n**3), (m, 0, oo))[:6] == \
+        [n, n**2, n**3, n, n**2, n**3]
+    assert SeqPer((n, n**2, n**3), (n, 0, oo))[:6] == [0, 1, 8, 3, 16, 125]
+    assert SeqPer((n, m), (n, 0, oo))[:6] == [0, m, 2, m, 4, m]
+
+
+def test_SeqFormula():
+    s = SeqFormula(n**2, (n, 0, 5))
+
+    assert isinstance(s, SeqFormula)
+    assert s.formula == n**2
+    assert s.coeff(3) == 9
+
+    assert list(s) == [i**2 for i in range(6)]
+    assert s[:] == [i**2 for i in range(6)]
+    assert SeqFormula(n**2, (n, -oo, 0))[0:6] == [i**2 for i in range(6)]
+
+    assert SeqFormula(n**2, (0, oo)) == SeqFormula(n**2, (n, 0, oo))
+
+    assert SeqFormula(n**2, (0, m)).subs(m, x) == SeqFormula(n**2, (0, x))
+    assert SeqFormula(m*n**2, (n, 0, oo)).subs(m, x) == \
+        SeqFormula(x*n**2, (n, 0, oo))
+
+    raises(ValueError, lambda: SeqFormula(n**2, (0, 1, 2)))
+    raises(ValueError, lambda: SeqFormula(n**2, (n, -oo, oo)))
+    raises(ValueError, lambda: SeqFormula(m*n**2, (0, oo)))
+
+    seq = SeqFormula(x*(y**2 + z), (z, 1, 100))
+    assert seq.expand() == SeqFormula(x*y**2 + x*z, (z, 1, 100))
+    seq = SeqFormula(sin(x*(y**2 + z)),(z, 1, 100))
+    assert seq.expand(trig=True) == SeqFormula(sin(x*y**2)*cos(x*z) + sin(x*z)*cos(x*y**2), (z, 1, 100))
+    assert seq.expand() == SeqFormula(sin(x*y**2 + x*z), (z, 1, 100))
+    assert seq.expand(trig=False) == SeqFormula(sin(x*y**2 + x*z), (z, 1, 100))
+    seq = SeqFormula(exp(x*(y**2 + z)), (z, 1, 100))
+    assert seq.expand() == SeqFormula(exp(x*y**2)*exp(x*z), (z, 1, 100))
+    assert seq.expand(power_exp=False) == SeqFormula(exp(x*y**2 + x*z), (z, 1, 100))
+    assert seq.expand(mul=False, power_exp=False) == SeqFormula(exp(x*(y**2 + z)), (z, 1, 100))
+
+def test_sequence():
+    form = SeqFormula(n**2, (n, 0, 5))
+    per = SeqPer((1, 2, 3), (n, 0, 5))
+    inter = SeqFormula(n**2)
+
+    assert sequence(n**2, (n, 0, 5)) == form
+    assert sequence((1, 2, 3), (n, 0, 5)) == per
+    assert sequence(n**2) == inter
+
+
+def test_SeqExprOp():
+    form = SeqFormula(n**2, (n, 0, 10))
+    per = SeqPer((1, 2, 3), (m, 5, 10))
+
+    s = SeqExprOp(form, per)
+    assert s.gen == (n**2, (1, 2, 3))
+    assert s.interval == Interval(5, 10)
+    assert s.start == 5
+    assert s.stop == 10
+    assert s.length == 6
+    assert s.variables == (n, m)
+
+
+def test_SeqAdd():
+    per = SeqPer((1, 2, 3), (n, 0, oo))
+    form = SeqFormula(n**2)
+
+    per_bou = SeqPer((1, 2), (n, 1, 5))
+    form_bou = SeqFormula(n**2, (6, 10))
+    form_bou2 = SeqFormula(n**2, (1, 5))
+
+    assert SeqAdd() == S.EmptySequence
+    assert SeqAdd(S.EmptySequence) == S.EmptySequence
+    assert SeqAdd(per) == per
+    assert SeqAdd(per, S.EmptySequence) == per
+    assert SeqAdd(per_bou, form_bou) == S.EmptySequence
+
+    s = SeqAdd(per_bou, form_bou2, evaluate=False)
+    assert s.args == (form_bou2, per_bou)
+    assert s[:] == [2, 6, 10, 18, 26]
+    assert list(s) == [2, 6, 10, 18, 26]
+
+    assert isinstance(SeqAdd(per, per_bou, evaluate=False), SeqAdd)
+
+    s1 = SeqAdd(per, per_bou)
+    assert isinstance(s1, SeqPer)
+    assert s1 == SeqPer((2, 4, 4, 3, 3, 5), (n, 1, 5))
+    s2 = SeqAdd(form, form_bou)
+    assert isinstance(s2, SeqFormula)
+    assert s2 == SeqFormula(2*n**2, (6, 10))
+
+    assert SeqAdd(form, form_bou, per) == \
+        SeqAdd(per, SeqFormula(2*n**2, (6, 10)))
+    assert SeqAdd(form, SeqAdd(form_bou, per)) == \
+        SeqAdd(per, SeqFormula(2*n**2, (6, 10)))
+    assert SeqAdd(per, SeqAdd(form, form_bou), evaluate=False) == \
+        SeqAdd(per, SeqFormula(2*n**2, (6, 10)))
+
+    assert SeqAdd(SeqPer((1, 2), (n, 0, oo)), SeqPer((1, 2), (m, 0, oo))) == \
+        SeqPer((2, 4), (n, 0, oo))
+
+
+def test_SeqMul():
+    per = SeqPer((1, 2, 3), (n, 0, oo))
+    form = SeqFormula(n**2)
+
+    per_bou = SeqPer((1, 2), (n, 1, 5))
+    form_bou = SeqFormula(n**2, (n, 6, 10))
+    form_bou2 = SeqFormula(n**2, (1, 5))
+
+    assert SeqMul() == S.EmptySequence
+    assert SeqMul(S.EmptySequence) == S.EmptySequence
+    assert SeqMul(per) == per
+    assert SeqMul(per, S.EmptySequence) == S.EmptySequence
+    assert SeqMul(per_bou, form_bou) == S.EmptySequence
+
+    s = SeqMul(per_bou, form_bou2, evaluate=False)
+    assert s.args == (form_bou2, per_bou)
+    assert s[:] == [1, 8, 9, 32, 25]
+    assert list(s) == [1, 8, 9, 32, 25]
+
+    assert isinstance(SeqMul(per, per_bou, evaluate=False), SeqMul)
+
+    s1 = SeqMul(per, per_bou)
+    assert isinstance(s1, SeqPer)
+    assert s1 == SeqPer((1, 4, 3, 2, 2, 6), (n, 1, 5))
+    s2 = SeqMul(form, form_bou)
+    assert isinstance(s2, SeqFormula)
+    assert s2 == SeqFormula(n**4, (6, 10))
+
+    assert SeqMul(form, form_bou, per) == \
+        SeqMul(per, SeqFormula(n**4, (6, 10)))
+    assert SeqMul(form, SeqMul(form_bou, per)) == \
+        SeqMul(per, SeqFormula(n**4, (6, 10)))
+    assert SeqMul(per, SeqMul(form, form_bou2,
+                              evaluate=False), evaluate=False) == \
+        SeqMul(form, per, form_bou2, evaluate=False)
+
+    assert SeqMul(SeqPer((1, 2), (n, 0, oo)), SeqPer((1, 2), (n, 0, oo))) == \
+        SeqPer((1, 4), (n, 0, oo))
+
+
+def test_add():
+    per = SeqPer((1, 2), (n, 0, oo))
+    form = SeqFormula(n**2)
+
+    assert per + (SeqPer((2, 3))) == SeqPer((3, 5), (n, 0, oo))
+    assert form + SeqFormula(n**3) == SeqFormula(n**2 + n**3)
+
+    assert per + form == SeqAdd(per, form)
+
+    raises(TypeError, lambda: per + n)
+    raises(TypeError, lambda: n + per)
+
+
+def test_sub():
+    per = SeqPer((1, 2), (n, 0, oo))
+    form = SeqFormula(n**2)
+
+    assert per - (SeqPer((2, 3))) == SeqPer((-1, -1), (n, 0, oo))
+    assert form - (SeqFormula(n**3)) == SeqFormula(n**2 - n**3)
+
+    assert per - form == SeqAdd(per, -form)
+
+    raises(TypeError, lambda: per - n)
+    raises(TypeError, lambda: n - per)
+
+
+def test_mul__coeff_mul():
+    assert SeqPer((1, 2), (n, 0, oo)).coeff_mul(2) == SeqPer((2, 4), (n, 0, oo))
+    assert SeqFormula(n**2).coeff_mul(2) == SeqFormula(2*n**2)
+    assert S.EmptySequence.coeff_mul(100) == S.EmptySequence
+
+    assert SeqPer((1, 2), (n, 0, oo)) * (SeqPer((2, 3))) == \
+        SeqPer((2, 6), (n, 0, oo))
+    assert SeqFormula(n**2) * SeqFormula(n**3) == SeqFormula(n**5)
+
+    assert S.EmptySequence * SeqFormula(n**2) == S.EmptySequence
+    assert SeqFormula(n**2) * S.EmptySequence == S.EmptySequence
+
+    raises(TypeError, lambda: sequence(n**2) * n)
+    raises(TypeError, lambda: n * sequence(n**2))
+
+
+def test_neg():
+    assert -SeqPer((1, -2), (n, 0, oo)) == SeqPer((-1, 2), (n, 0, oo))
+    assert -SeqFormula(n**2) == SeqFormula(-n**2)
+
+
+def test_operations():
+    per = SeqPer((1, 2), (n, 0, oo))
+    per2 = SeqPer((2, 4), (n, 0, oo))
+    form = SeqFormula(n**2)
+    form2 = SeqFormula(n**3)
+
+    assert per + form + form2 == SeqAdd(per, form, form2)
+    assert per + form - form2 == SeqAdd(per, form, -form2)
+    assert per + form - S.EmptySequence == SeqAdd(per, form)
+    assert per + per2 + form == SeqAdd(SeqPer((3, 6), (n, 0, oo)), form)
+    assert S.EmptySequence - per == -per
+    assert form + form == SeqFormula(2*n**2)
+
+    assert per * form * form2 == SeqMul(per, form, form2)
+    assert form * form == SeqFormula(n**4)
+    assert form * -form == SeqFormula(-n**4)
+
+    assert form * (per + form2) == SeqMul(form, SeqAdd(per, form2))
+    assert form * (per + per) == SeqMul(form, per2)
+
+    assert form.coeff_mul(m) == SeqFormula(m*n**2, (n, 0, oo))
+    assert per.coeff_mul(m) == SeqPer((m, 2*m), (n, 0, oo))
+
+
+def test_Idx_limits():
+    i = symbols('i', cls=Idx)
+    r = Indexed('r', i)
+
+    assert SeqFormula(r, (i, 0, 5))[:] == [r.subs(i, j) for j in range(6)]
+    assert SeqPer((1, 2), (i, 0, 5))[:] == [1, 2, 1, 2, 1, 2]
+
+
+@slow
+def test_find_linear_recurrence():
+    assert sequence((0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55), \
+    (n, 0, 10)).find_linear_recurrence(11) == [1, 1]
+    assert sequence((1, 2, 4, 7, 28, 128, 582, 2745, 13021, 61699, 292521, \
+    1387138), (n, 0, 11)).find_linear_recurrence(12) == [5, -2, 6, -11]
+    assert sequence(x*n**3+y*n, (n, 0, oo)).find_linear_recurrence(10) \
+    == [4, -6, 4, -1]
+    assert sequence(x**n, (n,0,20)).find_linear_recurrence(21) == [x]
+    assert sequence((1,2,3)).find_linear_recurrence(10, 5) == [0, 0, 1]
+    assert sequence(((1 + sqrt(5))/2)**n + \
+    (-(1 + sqrt(5))/2)**(-n)).find_linear_recurrence(10) == [1, 1]
+    assert sequence(x*((1 + sqrt(5))/2)**n + y*(-(1 + sqrt(5))/2)**(-n), \
+    (n,0,oo)).find_linear_recurrence(10) == [1, 1]
+    assert sequence((1,2,3,4,6),(n, 0, 4)).find_linear_recurrence(5) == []
+    assert sequence((2,3,4,5,6,79),(n, 0, 5)).find_linear_recurrence(6,gfvar=x) \
+    == ([], None)
+    assert sequence((2,3,4,5,8,30),(n, 0, 5)).find_linear_recurrence(6,gfvar=x) \
+    == ([Rational(19, 2), -20, Rational(27, 2)], (-31*x**2 + 32*x - 4)/(27*x**3 - 40*x**2 + 19*x -2))
+    assert sequence(fibonacci(n)).find_linear_recurrence(30,gfvar=x) \
+    == ([1, 1], -x/(x**2 + x - 1))
+    assert sequence(tribonacci(n)).find_linear_recurrence(30,gfvar=x) \
+    ==  ([1, 1, 1], -x/(x**3 + x**2 + x - 1))
+
+def test_RecursiveSeq():
+    y = Function('y')
+    n = Symbol('n')
+    fib = RecursiveSeq(y(n - 1) + y(n - 2), y(n), n, [0, 1])
+    assert fib.coeff(3) == 2
diff --git a/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_series.py b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_series.py
new file mode 100644
index 0000000000000000000000000000000000000000..ec9d868ac8246ac17a0d42244248fbfdc5081df1
--- /dev/null
+++ b/llmeval-env/lib/python3.10/site-packages/sympy/series/tests/test_series.py
@@ -0,0 +1,386 @@
+from sympy.core.evalf import N
+from sympy.core.function import (Derivative, Function, PoleError, Subs)
+from sympy.core.numbers import (E, Float, Rational, oo, pi, I)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.exponential import (LambertW, exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (atan, cos, sin)
+from sympy.functions.special.gamma_functions import gamma
+from sympy.integrals.integrals import Integral, integrate
+from sympy.series.order import O
+from sympy.series.series import series
+from sympy.abc import x, y, n, k
+from sympy.testing.pytest import raises
+
+
+def test_sin():
+    e1 = sin(x).series(x, 0)
+    e2 = series(sin(x), x, 0)
+    assert e1 == e2
+
+
+def test_cos():
+    e1 = cos(x).series(x, 0)
+    e2 = series(cos(x), x, 0)
+    assert e1 == e2
+
+
+def test_exp():
+    e1 = exp(x).series(x, 0)
+    e2 = series(exp(x), x, 0)
+    assert e1 == e2
+
+
+def test_exp2():
+    e1 = exp(cos(x)).series(x, 0)
+    e2 = series(exp(cos(x)), x, 0)
+    assert e1 == e2
+
+
+def test_issue_5223():
+    assert series(1, x) == 1
+    assert next(S.Zero.lseries(x)) == 0
+    assert cos(x).series() == cos(x).series(x)
+    raises(ValueError, lambda: cos(x + y).series())
+    raises(ValueError, lambda: x.series(dir=""))
+
+    assert (cos(x).series(x, 1) -
+            cos(x + 1).series(x).subs(x, x - 1)).removeO() == 0
+    e = cos(x).series(x, 1, n=None)
+    assert [next(e) for i in range(2)] == [cos(1), -((x - 1)*sin(1))]
+    e = cos(x).series(x, 1, n=None, dir='-')
+    assert [next(e) for i in range(2)] == [cos(1), (1 - x)*sin(1)]
+    # the following test is exact so no need for x -> x - 1 replacement
+    assert abs(x).series(x, 1, dir='-') == x
+    assert exp(x).series(x, 1, dir='-', n=3).removeO() == \
+        E - E*(-x + 1) + E*(-x + 1)**2/2
+
+    D = Derivative
+    assert D(x**2 + x**3*y**2, x, 2, y, 1).series(x).doit() == 12*x*y
+    assert next(D(cos(x), x).lseries()) == D(1, x)
+    assert D(
+        exp(x), x).series(n=3) == D(1, x) + D(x, x) + D(x**2/2, x) + D(x**3/6, x) + O(x**3)
+
+    assert Integral(x, (x, 1, 3), (y, 1, x)).series(x) == -4 + 4*x
+
+    assert (1 + x + O(x**2)).getn() == 2
+    assert (1 + x).getn() is None
+
+    raises(PoleError, lambda: ((1/sin(x))**oo).series())
+    logx = Symbol('logx')
+    assert ((sin(x))**y).nseries(x, n=1, logx=logx) == \
+        exp(y*logx) + O(x*exp(y*logx), x)
+
+    assert sin(1/x).series(x, oo, n=5) == 1/x - 1/(6*x**3) + O(x**(-5), (x, oo))
+    assert abs(x).series(x, oo, n=5, dir='+') == x
+    assert abs(x).series(x, -oo, n=5, dir='-') == -x
+    assert abs(-x).series(x, oo, n=5, dir='+') == x
+    assert abs(-x).series(x, -oo, n=5, dir='-') == -x
+
+    assert exp(x*log(x)).series(n=3) == \
+        1 + x*log(x) + x**2*log(x)**2/2 + O(x**3*log(x)**3)
+    # XXX is this right? If not, fix "ngot > n" handling in expr.
+    p = Symbol('p', positive=True)
+    assert exp(sqrt(p)**3*log(p)).series(n=3) == \
+        1 + p**S('3/2')*log(p) + O(p**3*log(p)**3)
+
+    assert exp(sin(x)*log(x)).series(n=2) == 1 + x*log(x) + O(x**2*log(x)**2)
+
+
+def test_issue_6350():
+    expr = integrate(exp(k*(y**3 - 3*y)), (y, 0, oo), conds='none')
+    assert expr.series(k, 0, 3) == -(-1)**(S(2)/3)*sqrt(3)*gamma(S(1)/3)**2*gamma(S(2)/3)/(6*pi*k**(S(1)/3)) - \
+        sqrt(3)*k*gamma(-S(2)/3)*gamma(-S(1)/3)/(6*pi) - \
+        (-1)**(S(1)/3)*sqrt(3)*k**(S(1)/3)*gamma(-S(1)/3)*gamma(S(1)/3)*gamma(S(2)/3)/(6*pi) - \
+        (-1)**(S(2)/3)*sqrt(3)*k**(S(5)/3)*gamma(S(1)/3)**2*gamma(S(2)/3)/(4*pi) - \
+        (-1)**(S(1)/3)*sqrt(3)*k**(S(7)/3)*gamma(-S(1)/3)*gamma(S(1)/3)*gamma(S(2)/3)/(8*pi) + O(k**3)
+
+
+def test_issue_11313():
+    assert Integral(cos(x), x).series(x) == sin(x).series(x)
+    assert Derivative(sin(x), x).series(x, n=3).doit() == cos(x).series(x, n=3)
+
+    assert Derivative(x**3, x).as_leading_term(x) == 3*x**2
+    assert Derivative(x**3, y).as_leading_term(x) == 0
+    assert Derivative(sin(x), x).as_leading_term(x) == 1
+    assert Derivative(cos(x), x).as_leading_term(x) == -x
+
+    # This result is equivalent to zero, zero is not return because
+    # `Expr.series` doesn't currently detect an `x` in its `free_symbol`s.
+    assert Derivative(1, x).as_leading_term(x) == Derivative(1, x)
+
+    assert Derivative(exp(x), x).series(x).doit() == exp(x).series(x)
+    assert 1 + Integral(exp(x), x).series(x) == exp(x).series(x)
+
+    assert Derivative(log(x), x).series(x).doit() == (1/x).series(x)
+    assert Integral(log(x), x).series(x) == Integral(log(x), x).doit().series(x).removeO()
+
+
+def test_series_of_Subs():
+    from sympy.abc import z
+
+    subs1 = Subs(sin(x), x, y)
+    subs2 = Subs(sin(x) * cos(z), x, y)
+    subs3 = Subs(sin(x * z), (x, z), (y, x))
+
+    assert subs1.series(x) == subs1
+    subs1_series = (Subs(x, x, y) + Subs(-x**3/6, x, y) +
+        Subs(x**5/120, x, y) + O(y**6))
+    assert subs1.series() == subs1_series
+    assert subs1.series(y) == subs1_series
+    assert subs1.series(z) == subs1
+    assert subs2.series(z) == (Subs(z**4*sin(x)/24, x, y) +
+        Subs(-z**2*sin(x)/2, x, y) + Subs(sin(x), x, y) + O(z**6))
+    assert subs3.series(x).doit() == subs3.doit().series(x)
+    assert subs3.series(z).doit() == sin(x*y)
+
+    raises(ValueError, lambda: Subs(x + 2*y, y, z).series())
+    assert Subs(x + y, y, z).series(x).doit() == x + z
+
+
+def test_issue_3978():
+    f = Function('f')
+    assert f(x).series(x, 0, 3, dir='-') == \
+            f(0) + x*Subs(Derivative(f(x), x), x, 0) + \
+            x**2*Subs(Derivative(f(x), x, x), x, 0)/2 + O(x**3)
+    assert f(x).series(x, 0, 3) == \
+            f(0) + x*Subs(Derivative(f(x), x), x, 0) + \
+            x**2*Subs(Derivative(f(x), x, x), x, 0)/2 + O(x**3)
+    assert f(x**2).series(x, 0, 3) == \
+            f(0) + x**2*Subs(Derivative(f(x), x), x, 0) + O(x**3)
+    assert f(x**2+1).series(x, 0, 3) == \
+            f(1) + x**2*Subs(Derivative(f(x), x), x, 1) + O(x**3)
+
+    class TestF(Function):
+        pass
+
+    assert TestF(x).series(x, 0, 3) ==  TestF(0) + \
+            x*Subs(Derivative(TestF(x), x), x, 0) + \
+            x**2*Subs(Derivative(TestF(x), x, x), x, 0)/2 + O(x**3)
+
+from sympy.series.acceleration import richardson, shanks
+from sympy.concrete.summations import Sum
+from sympy.core.numbers import Integer
+
+
+def test_acceleration():
+    e = (1 + 1/n)**n
+    assert round(richardson(e, n, 10, 20).evalf(), 10) == round(E.evalf(), 10)
+
+    A = Sum(Integer(-1)**(k + 1) / k, (k, 1, n))
+    assert round(shanks(A, n, 25).evalf(), 4) == round(log(2).evalf(), 4)
+    assert round(shanks(A, n, 25, 5).evalf(), 10) == round(log(2).evalf(), 10)
+
+
+def test_issue_5852():
+    assert series(1/cos(x/log(x)), x, 0) == 1 + x**2/(2*log(x)**2) + \
+        5*x**4/(24*log(x)**4) + O(x**6)
+
+
+def test_issue_4583():
+    assert cos(1 + x + x**2).series(x, 0, 5) == cos(1) - x*sin(1) + \
+        x**2*(-sin(1) - cos(1)/2) + x**3*(-cos(1) + sin(1)/6) + \
+        x**4*(-11*cos(1)/24 + sin(1)/2) + O(x**5)
+
+
+def test_issue_6318():
+    eq = (1/x)**Rational(2, 3)
+    assert (eq + 1).as_leading_term(x) == eq
+
+
+def test_x_is_base_detection():
+    eq = (x**2)**Rational(2, 3)
+    assert eq.series() == x**Rational(4, 3)
+
+
+def test_issue_7203():
+    assert series(cos(x), x, pi, 3) == \
+        -1 + (x - pi)**2/2 + O((x - pi)**3, (x, pi))
+
+
+def test_exp_product_positive_factors():
+    a, b = symbols('a, b', positive=True)
+    x = a * b
+    assert series(exp(x), x, n=8) == 1 + a*b + a**2*b**2/2 + \
+        a**3*b**3/6 + a**4*b**4/24 + a**5*b**5/120 + a**6*b**6/720 + \
+        a**7*b**7/5040 + O(a**8*b**8, a, b)
+
+
+def test_issue_8805():
+    assert series(1, n=8) == 1
+
+
+def test_issue_9549():
+    y = (x**2 + x + 1) / (x**3 + x**2)
+    assert series(y, x, oo) == x**(-5) - 1/x**4 + x**(-3) + 1/x + O(x**(-6), (x, oo))
+
+
+def test_issue_10761():
+    assert series(1/(x**-2 + x**-3), x, 0) == x**3 - x**4 + x**5 + O(x**6)
+
+
+def test_issue_12578():
+    y = (1 - 1/(x/2 - 1/(2*x))**4)**(S(1)/8)
+    assert y.series(x, 0, n=17) == 1 - 2*x**4 - 8*x**6 - 34*x**8 - 152*x**10 - 714*x**12 - \
+        3472*x**14 - 17318*x**16 + O(x**17)
+
+
+def test_issue_12791():
+    beta = symbols('beta', positive=True)
+    theta, varphi = symbols('theta varphi', real=True)
+
+    expr = (-beta**2*varphi*sin(theta) + beta**2*cos(theta) + \
+        beta*varphi*sin(theta) - beta*cos(theta) - beta + 1)/(beta*cos(theta) - 1)**2
+
+    sol = 0.5/(0.5*cos(theta) - 1.0)**2 - 0.25*cos(theta)/(0.5*cos(theta)\
+        - 1.0)**2 + (beta - 0.5)*(-0.25*varphi*sin(2*theta) - 1.5*cos(theta)\
+        + 0.25*cos(2*theta) + 1.25)/(0.5*cos(theta) - 1.0)**3\
+        + 0.25*varphi*sin(theta)/(0.5*cos(theta) - 1.0)**2 + O((beta - S.Half)**2, (beta, S.Half))
+
+    assert expr.series(beta, 0.5, 2).trigsimp() == sol
+
+
+def test_issue_14384():
+    x, a = symbols('x a')
+    assert series(x**a, x) == x**a
+    assert series(x**(-2*a), x) == x**(-2*a)
+    assert series(exp(a*log(x)), x) == exp(a*log(x))
+    assert series(x**I, x) == x**I
+    assert series(x**(I + 1), x) == x**(1 + I)
+    assert series(exp(I*log(x)), x) == exp(I*log(x))
+
+
+def test_issue_14885():
+    assert series(x**Rational(-3, 2)*exp(x), x, 0) == (x**Rational(-3, 2) + 1/sqrt(x) +
+        sqrt(x)/2 + x**Rational(3, 2)/6 + x**Rational(5, 2)/24 + x**Rational(7, 2)/120 +
+        x**Rational(9, 2)/720 + x**Rational(11, 2)/5040 + O(x**6))
+
+
+def test_issue_15539():
+    assert series(atan(x), x, -oo) == (-1/(5*x**5) + 1/(3*x**3) - 1/x - pi/2
+        + O(x**(-6), (x, -oo)))
+    assert series(atan(x), x, oo) == (-1/(5*x**5) + 1/(3*x**3) - 1/x + pi/2
+        + O(x**(-6), (x, oo)))
+
+
+def test_issue_7259():
+    assert series(LambertW(x), x) == x - x**2 + 3*x**3/2 - 8*x**4/3 + 125*x**5/24 + O(x**6)
+    assert series(LambertW(x**2), x, n=8) == x**2 - x**4 + 3*x**6/2 + O(x**8)
+    assert series(LambertW(sin(x)), x, n=4) == x - x**2 + 4*x**3/3 + O(x**4)
+
+def test_issue_11884():
+    assert cos(x).series(x, 1, n=1) == cos(1) + O(x - 1, (x, 1))
+
+
+def test_issue_18008():
+    y = x*(1 + x*(1 - x))/((1 + x*(1 - x)) - (1 - x)*(1 - x))
+    assert y.series(x, oo, n=4) == -9/(32*x**3) - 3/(16*x**2) - 1/(8*x) + S(1)/4 + x/2 + \
+        O(x**(-4), (x, oo))
+
+
+def test_issue_18842():
+    f = log(x/(1 - x))
+    assert f.series(x, 0.491, n=1).removeO().nsimplify() ==  \
+        -S(180019443780011)/5000000000000000
+
+
+def test_issue_19534():
+    dt = symbols('dt', real=True)
+    expr = 16*dt*(0.125*dt*(2.0*dt + 1.0) + 0.875*dt + 1.0)/45 + \
+            49*dt*(-0.049335189898860408029*dt*(2.0*dt + 1.0) + \
+            0.29601113939316244817*dt*(0.125*dt*(2.0*dt + 1.0) + 0.875*dt + 1.0) - \
+            0.12564355335492979587*dt*(0.074074074074074074074*dt*(2.0*dt + 1.0) + \
+            0.2962962962962962963*dt*(0.125*dt*(2.0*dt + 1.0) + 0.875*dt + 1.0) + \
+            0.96296296296296296296*dt + 1.0) + 0.051640768506639183825*dt + \
+            dt*(1/2 - sqrt(21)/14) + 1.0)/180 + 49*dt*(-0.23637909581542530626*dt*(2.0*dt + 1.0) - \
+            0.74817562366625959291*dt*(0.125*dt*(2.0*dt + 1.0) + 0.875*dt + 1.0) + \
+            0.88085458023927036857*dt*(0.074074074074074074074*dt*(2.0*dt + 1.0) + \
+            0.2962962962962962963*dt*(0.125*dt*(2.0*dt + 1.0) + 0.875*dt + 1.0) + \
+            0.96296296296296296296*dt + 1.0) + \
+            2.1165151389911680013*dt*(-0.049335189898860408029*dt*(2.0*dt + 1.0) + \
+            0.29601113939316244817*dt*(0.125*dt*(2.0*dt + 1.0) + 0.875*dt + 1.0) - \
+            0.12564355335492979587*dt*(0.074074074074074074074*dt*(2.0*dt + 1.0) + \
+            0.2962962962962962963*dt*(0.125*dt*(2.0*dt + 1.0) + 0.875*dt + 1.0) + \
+            0.96296296296296296296*dt + 1.0) + 0.22431393315265061193*dt + 1.0) - \
+            1.1854881643947648988*dt + dt*(sqrt(21)/14 + 1/2) + 1.0)/180 + \
+            dt*(0.66666666666666666667*dt*(2.0*dt + 1.0) + \
+            6.0173399699313066769*dt*(0.125*dt*(2.0*dt + 1.0) + 0.875*dt + 1.0) - \
+            4.1117044797036320069*dt*(0.074074074074074074074*dt*(2.0*dt + 1.0) + \
+            0.2962962962962962963*dt*(0.125*dt*(2.0*dt + 1.0) + 0.875*dt + 1.0) + \
+            0.96296296296296296296*dt + 1.0) - \
+            7.0189140975801991157*dt*(-0.049335189898860408029*dt*(2.0*dt + 1.0) + \
+            0.29601113939316244817*dt*(0.125*dt*(2.0*dt + 1.0) + 0.875*dt + 1.0) - \
+            0.12564355335492979587*dt*(0.074074074074074074074*dt*(2.0*dt + 1.0) + \
+            0.2962962962962962963*dt*(0.125*dt*(2.0*dt + 1.0) + 0.875*dt + 1.0) + \
+            0.96296296296296296296*dt + 1.0) + 0.22431393315265061193*dt + 1.0) + \
+            0.94010945196161777522*dt*(-0.23637909581542530626*dt*(2.0*dt + 1.0) - \
+            0.74817562366625959291*dt*(0.125*dt*(2.0*dt + 1.0) + 0.875*dt + 1.0) + \
+            0.88085458023927036857*dt*(0.074074074074074074074*dt*(2.0*dt + 1.0) + \
+            0.2962962962962962963*dt*(0.125*dt*(2.0*dt + 1.0) + 0.875*dt + 1.0) + \
+            0.96296296296296296296*dt + 1.0) + \
+            2.1165151389911680013*dt*(-0.049335189898860408029*dt*(2.0*dt + 1.0) + \
+            0.29601113939316244817*dt*(0.125*dt*(2.0*dt + 1.0) + 0.875*dt + 1.0) - \
+            0.12564355335492979587*dt*(0.074074074074074074074*dt*(2.0*dt + 1.0) + \
+            0.2962962962962962963*dt*(0.125*dt*(2.0*dt + 1.0) + 0.875*dt + 1.0) + \
+            0.96296296296296296296*dt + 1.0) + 0.22431393315265061193*dt + 1.0) - \
+            0.35816132904077632692*dt + 1.0) + 5.5065024887242400038*dt + 1.0)/20 + dt/20 + 1
+
+    assert N(expr.series(dt, 0, 8), 20) == (
+            - Float('0.00092592592592592596126289', precision=70) * dt**7
+            + Float('0.0027777777777777783174695', precision=70) * dt**6
+            + Float('0.016666666666666656027029', precision=70) * dt**5
+            + Float('0.083333333333333300951828', precision=70) * dt**4
+            + Float('0.33333333333333337034077', precision=70) * dt**3
+            + Float('1.0', precision=70) * dt**2
+            + Float('1.0', precision=70) * dt
+            + Float('1.0', precision=70)
+        )
+
+
+def test_issue_11407():
+    a, b, c, x = symbols('a b c x')
+    assert series(sqrt(a + b + c*x), x, 0, 1) == sqrt(a + b) + O(x)
+    assert series(sqrt(a + b + c + c*x), x, 0, 1) == sqrt(a + b + c) + O(x)
+
+
+def test_issue_14037():
+    assert (sin(x**50)/x**51).series(x, n=0) == 1/x + O(1, x)
+
+
+def test_issue_20551():
+    expr = (exp(x)/x).series(x, n=None)
+    terms = [ next(expr) for i in range(3) ]
+    assert terms == [1/x, 1, x/2]
+
+
+def test_issue_20697():
+    p_0, p_1, p_2, p_3, b_0, b_1, b_2 = symbols('p_0 p_1 p_2 p_3 b_0 b_1 b_2')
+    Q = (p_0 + (p_1 + (p_2 + p_3/y)/y)/y)/(1 + ((p_3/(b_0*y) + (b_0*p_2\
+        - b_1*p_3)/b_0**2)/y + (b_0**2*p_1 - b_0*b_1*p_2 - p_3*(b_0*b_2\
+        - b_1**2))/b_0**3)/y)
+    assert Q.series(y, n=3).ratsimp() == b_2*y**2 + b_1*y + b_0 + O(y**3)
+
+
+def test_issue_21245():
+    fi = (1 + sqrt(5))/2
+    assert (1/(1 - x - x**2)).series(x, 1/fi, 1).factor() == \
+        (-4812 - 2152*sqrt(5) + 1686*x + 754*sqrt(5)*x\
+        + O((x - 2/(1 + sqrt(5)))**2, (x, 2/(1 + sqrt(5)))))/((1 + sqrt(5))\
+        *(20 + 9*sqrt(5))**2*(x + sqrt(5)*x - 2))
+
+
+def test_issue_21938():
+    expr = sin(1/x + exp(-x)) - sin(1/x)
+    assert expr.series(x, oo) == (1/(24*x**4) - 1/(2*x**2) + 1 + O(x**(-6), (x, oo)))*exp(-x)
+
+
+def test_issue_23432():
+    expr = 1/sqrt(1 - x**2)
+    result = expr.series(x, 0.5)
+    assert result.is_Add and len(result.args) == 7
+
+
+def test_issue_23727():
+    res = series(sqrt(1 - x**2), x, 0.1)
+    assert res.is_Add == True