Add files using upload-large-folder tool

.gitattributes

@@ -439,3 +439,6 @@ tuning-competition-baseline/.venv/lib/python3.11/site-packages/nvidia/cudnn/lib/
 .venv/lib/python3.11/site-packages/transformers/models/whisper/__pycache__/modeling_whisper.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.11/site-packages/transformers/utils/__pycache__/dummy_tf_objects.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.11/site-packages/transformers/utils/__pycache__/dummy_pt_objects.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/sympy/simplify/__pycache__/hyperexpand.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/sympy/crypto/__pycache__/crypto.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/sympy/simplify/tests/__pycache__/test_simplify.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text

.venv/lib/python3.11/site-packages/sympy/core/benchmarks/bench_assumptions.py

@@ -0,0 +1,12 @@
+from sympy.core import Symbol, Integer
+
+x = Symbol('x')
+i3 = Integer(3)
+
+
+def timeit_x_is_integer():
+    x.is_integer
+
+
+def timeit_Integer_is_irrational():
+    i3.is_irrational

.venv/lib/python3.11/site-packages/sympy/core/benchmarks/bench_basic.py

@@ -0,0 +1,15 @@
+from sympy.core import symbols, S
+
+x, y = symbols('x,y')
+
+
+def timeit_Symbol_meth_lookup():
+    x.diff  # no call, just method lookup
+
+
+def timeit_S_lookup():
+    S.Exp1
+
+
+def timeit_Symbol_eq_xy():
+    x == y

.venv/lib/python3.11/site-packages/sympy/core/benchmarks/bench_expand.py

@@ -0,0 +1,23 @@
+from sympy.core import symbols, I
+
+x, y, z = symbols('x,y,z')
+
+p = 3*x**2*y*z**7 + 7*x*y*z**2 + 4*x + x*y**4
+e = (x + y + z + 1)**32
+
+
+def timeit_expand_nothing_todo():
+    p.expand()
+
+
+def bench_expand_32():
+    """(x+y+z+1)**32  -> expand"""
+    e.expand()
+
+
+def timeit_expand_complex_number_1():
+    ((2 + 3*I)**1000).expand(complex=True)
+
+
+def timeit_expand_complex_number_2():
+    ((2 + 3*I/4)**1000).expand(complex=True)

.venv/lib/python3.11/site-packages/sympy/core/benchmarks/bench_numbers.py

@@ -0,0 +1,92 @@
+from sympy.core.numbers import Integer, Rational, pi, oo
+from sympy.core.intfunc import integer_nthroot, igcd
+from sympy.core.singleton import S
+
+i3 = Integer(3)
+i4 = Integer(4)
+r34 = Rational(3, 4)
+q45 = Rational(4, 5)
+
+
+def timeit_Integer_create():
+    Integer(2)
+
+
+def timeit_Integer_int():
+    int(i3)
+
+
+def timeit_neg_one():
+    -S.One
+
+
+def timeit_Integer_neg():
+    -i3
+
+
+def timeit_Integer_abs():
+    abs(i3)
+
+
+def timeit_Integer_sub():
+    i3 - i3
+
+
+def timeit_abs_pi():
+    abs(pi)
+
+
+def timeit_neg_oo():
+    -oo
+
+
+def timeit_Integer_add_i1():
+    i3 + 1
+
+
+def timeit_Integer_add_ij():
+    i3 + i4
+
+
+def timeit_Integer_add_Rational():
+    i3 + r34
+
+
+def timeit_Integer_mul_i4():
+    i3*4
+
+
+def timeit_Integer_mul_ij():
+    i3*i4
+
+
+def timeit_Integer_mul_Rational():
+    i3*r34
+
+
+def timeit_Integer_eq_i3():
+    i3 == 3
+
+
+def timeit_Integer_ed_Rational():
+    i3 == r34
+
+
+def timeit_integer_nthroot():
+    integer_nthroot(100, 2)
+
+
+def timeit_number_igcd_23_17():
+    igcd(23, 17)
+
+
+def timeit_number_igcd_60_3600():
+    igcd(60, 3600)
+
+
+def timeit_Rational_add_r1():
+    r34 + 1
+
+
+def timeit_Rational_add_rq():
+    r34 + q45

.venv/lib/python3.11/site-packages/sympy/core/tests/test_arit.py

@@ -0,0 +1,2472 @@
+from sympy.core.add import Add
+from sympy.core.basic import Basic
+from sympy.core.mod import Mod
+from sympy.core.mul import Mul
+from sympy.core.numbers import (Float, I, Integer, Rational, comp, nan,
+    oo, pi, zoo)
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.complexes import (im, re, sign)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.integers import floor
+from sympy.functions.elementary.miscellaneous import (Max, sqrt)
+from sympy.functions.elementary.trigonometric import (atan, cos, sin)
+from sympy.polys.polytools import Poly
+from sympy.sets.sets import FiniteSet
+
+from sympy.core.parameters import distribute, evaluate
+from sympy.core.expr import unchanged
+from sympy.utilities.iterables import permutations
+from sympy.testing.pytest import XFAIL, raises, warns
+from sympy.utilities.exceptions import SymPyDeprecationWarning
+from sympy.core.random import verify_numerically
+from sympy.functions.elementary.trigonometric import asin
+
+from itertools import product
+
+a, c, x, y, z = symbols('a,c,x,y,z')
+b = Symbol("b", positive=True)
+
+
+def same_and_same_prec(a, b):
+    # stricter matching for Floats
+    return a == b and a._prec == b._prec
+
+
+def test_bug1():
+    assert re(x) != x
+    x.series(x, 0, 1)
+    assert re(x) != x
+
+
+def test_Symbol():
+    e = a*b
+    assert e == a*b
+    assert a*b*b == a*b**2
+    assert a*b*b + c == c + a*b**2
+    assert a*b*b - c == -c + a*b**2
+
+    x = Symbol('x', complex=True, real=False)
+    assert x.is_imaginary is None  # could be I or 1 + I
+    x = Symbol('x', complex=True, imaginary=False)
+    assert x.is_real is None  # could be 1 or 1 + I
+    x = Symbol('x', real=True)
+    assert x.is_complex
+    x = Symbol('x', imaginary=True)
+    assert x.is_complex
+    x = Symbol('x', real=False, imaginary=False)
+    assert x.is_complex is None  # might be a non-number
+
+
+def test_arit0():
+    p = Rational(5)
+    e = a*b
+    assert e == a*b
+    e = a*b + b*a
+    assert e == 2*a*b
+    e = a*b + b*a + a*b + p*b*a
+    assert e == 8*a*b
+    e = a*b + b*a + a*b + p*b*a + a
+    assert e == a + 8*a*b
+    e = a + a
+    assert e == 2*a
+    e = a + b + a
+    assert e == b + 2*a
+    e = a + b*b + a + b*b
+    assert e == 2*a + 2*b**2
+    e = a + Rational(2) + b*b + a + b*b + p
+    assert e == 7 + 2*a + 2*b**2
+    e = (a + b*b + a + b*b)*p
+    assert e == 5*(2*a + 2*b**2)
+    e = (a*b*c + c*b*a + b*a*c)*p
+    assert e == 15*a*b*c
+    e = (a*b*c + c*b*a + b*a*c)*p - Rational(15)*a*b*c
+    assert e == Rational(0)
+    e = Rational(50)*(a - a)
+    assert e == Rational(0)
+    e = b*a - b - a*b + b
+    assert e == Rational(0)
+    e = a*b + c**p
+    assert e == a*b + c**5
+    e = a/b
+    assert e == a*b**(-1)
+    e = a*2*2
+    assert e == 4*a
+    e = 2 + a*2/2
+    assert e == 2 + a
+    e = 2 - a - 2
+    assert e == -a
+    e = 2*a*2
+    assert e == 4*a
+    e = 2/a/2
+    assert e == a**(-1)
+    e = 2**a**2
+    assert e == 2**(a**2)
+    e = -(1 + a)
+    assert e == -1 - a
+    e = S.Half*(1 + a)
+    assert e == S.Half + a/2
+
+
+def test_div():
+    e = a/b
+    assert e == a*b**(-1)
+    e = a/b + c/2
+    assert e == a*b**(-1) + Rational(1)/2*c
+    e = (1 - b)/(b - 1)
+    assert e == (1 + -b)*((-1) + b)**(-1)
+
+
+def test_pow_arit():
+    n1 = Rational(1)
+    n2 = Rational(2)
+    n5 = Rational(5)
+    e = a*a
+    assert e == a**2
+    e = a*a*a
+    assert e == a**3
+    e = a*a*a*a**Rational(6)
+    assert e == a**9
+    e = a*a*a*a**Rational(6) - a**Rational(9)
+    assert e == Rational(0)
+    e = a**(b - b)
+    assert e == Rational(1)
+    e = (a + Rational(1) - a)**b
+    assert e == Rational(1)
+
+    e = (a + b + c)**n2
+    assert e == (a + b + c)**2
+    assert e.expand() == 2*b*c + 2*a*c + 2*a*b + a**2 + c**2 + b**2
+
+    e = (a + b)**n2
+    assert e == (a + b)**2
+    assert e.expand() == 2*a*b + a**2 + b**2
+
+    e = (a + b)**(n1/n2)
+    assert e == sqrt(a + b)
+    assert e.expand() == sqrt(a + b)
+
+    n = n5**(n1/n2)
+    assert n == sqrt(5)
+    e = n*a*b - n*b*a
+    assert e == Rational(0)
+    e = n*a*b + n*b*a
+    assert e == 2*a*b*sqrt(5)
+    assert e.diff(a) == 2*b*sqrt(5)
+    assert e.diff(a) == 2*b*sqrt(5)
+    e = a/b**2
+    assert e == a*b**(-2)
+
+    assert sqrt(2*(1 + sqrt(2))) == (2*(1 + 2**S.Half))**S.Half
+
+    x = Symbol('x')
+    y = Symbol('y')
+
+    assert ((x*y)**3).expand() == y**3 * x**3
+    assert ((x*y)**-3).expand() == y**-3 * x**-3
+
+    assert (x**5*(3*x)**(3)).expand() == 27 * x**8
+    assert (x**5*(-3*x)**(3)).expand() == -27 * x**8
+    assert (x**5*(3*x)**(-3)).expand() == x**2 * Rational(1, 27)
+    assert (x**5*(-3*x)**(-3)).expand() == x**2 * Rational(-1, 27)
+
+    # expand_power_exp
+    _x = Symbol('x', zero=False)
+    _y = Symbol('y', zero=False)
+    assert (_x**(y**(x + exp(x + y)) + z)).expand(deep=False) == \
+        _x**z*_x**(y**(x + exp(x + y)))
+    assert (_x**(_y**(x + exp(x + y)) + z)).expand() == \
+        _x**z*_x**(_y**x*_y**(exp(x)*exp(y)))
+
+    n = Symbol('n', even=False)
+    k = Symbol('k', even=True)
+    o = Symbol('o', odd=True)
+
+    assert unchanged(Pow, -1, x)
+    assert unchanged(Pow, -1, n)
+    assert (-2)**k == 2**k
+    assert (-1)**k == 1
+    assert (-1)**o == -1
+
+
+def test_pow2():
+    # x**(2*y) is always (x**y)**2 but is only (x**2)**y if
+    #                                  x.is_positive or y.is_integer
+    # let x = 1 to see why the following are not true.
+    assert (-x)**Rational(2, 3) != x**Rational(2, 3)
+    assert (-x)**Rational(5, 7) != -x**Rational(5, 7)
+    assert ((-x)**2)**Rational(1, 3) != ((-x)**Rational(1, 3))**2
+    assert sqrt(x**2) != x
+
+
+def test_pow3():
+    assert sqrt(2)**3 == 2 * sqrt(2)
+    assert sqrt(2)**3 == sqrt(8)
+
+
+def test_mod_pow():
+    for s, t, u, v in [(4, 13, 497, 445), (4, -3, 497, 365),
+            (3.2, 2.1, 1.9, 0.1031015682350942), (S(3)/2, 5, S(5)/6, S(3)/32)]:
+        assert pow(S(s), t, u) == v
+        assert pow(S(s), S(t), u) == v
+        assert pow(S(s), t, S(u)) == v
+        assert pow(S(s), S(t), S(u)) == v
+    assert pow(S(2), S(10000000000), S(3)) == 1
+    assert pow(x, y, z) == x**y%z
+    raises(TypeError, lambda: pow(S(4), "13", 497))
+    raises(TypeError, lambda: pow(S(4), 13, "497"))
+
+
+def test_pow_E():
+    assert 2**(y/log(2)) == S.Exp1**y
+    assert 2**(y/log(2)/3) == S.Exp1**(y/3)
+    assert 3**(1/log(-3)) != S.Exp1
+    assert (3 + 2*I)**(1/(log(-3 - 2*I) + I*pi)) == S.Exp1
+    assert (4 + 2*I)**(1/(log(-4 - 2*I) + I*pi)) == S.Exp1
+    assert (3 + 2*I)**(1/(log(-3 - 2*I, 3)/2 + I*pi/log(3)/2)) == 9
+    assert (3 + 2*I)**(1/(log(3 + 2*I, 3)/2)) == 9
+    # every time tests are run they will affirm with a different random
+    # value that this identity holds
+    while 1:
+        b = x._random()
+        r, i = b.as_real_imag()
+        if i:
+            break
+    assert verify_numerically(b**(1/(log(-b) + sign(i)*I*pi).n()), S.Exp1)
+
+
+def test_pow_issue_3516():
+    assert 4**Rational(1, 4) == sqrt(2)
+
+
+def test_pow_im():
+    for m in (-2, -1, 2):
+        for d in (3, 4, 5):
+            b = m*I
+            for i in range(1, 4*d + 1):
+                e = Rational(i, d)
+                assert (b**e - b.n()**e.n()).n(2, chop=1e-10) == 0
+
+    e = Rational(7, 3)
+    assert (2*x*I)**e == 4*2**Rational(1, 3)*(I*x)**e  # same as Wolfram Alpha
+    im = symbols('im', imaginary=True)
+    assert (2*im*I)**e == 4*2**Rational(1, 3)*(I*im)**e
+
+    args = [I, I, I, I, 2]
+    e = Rational(1, 3)
+    ans = 2**e
+    assert Mul(*args, evaluate=False)**e == ans
+    assert Mul(*args)**e == ans
+    args = [I, I, I, 2]
+    e = Rational(1, 3)
+    ans = 2**e*(-I)**e
+    assert Mul(*args, evaluate=False)**e == ans
+    assert Mul(*args)**e == ans
+    args.append(-3)
+    ans = (6*I)**e
+    assert Mul(*args, evaluate=False)**e == ans
+    assert Mul(*args)**e == ans
+    args.append(-1)
+    ans = (-6*I)**e
+    assert Mul(*args, evaluate=False)**e == ans
+    assert Mul(*args)**e == ans
+
+    args = [I, I, 2]
+    e = Rational(1, 3)
+    ans = (-2)**e
+    assert Mul(*args, evaluate=False)**e == ans
+    assert Mul(*args)**e == ans
+    args.append(-3)
+    ans = (6)**e
+    assert Mul(*args, evaluate=False)**e == ans
+    assert Mul(*args)**e == ans
+    args.append(-1)
+    ans = (-6)**e
+    assert Mul(*args, evaluate=False)**e == ans
+    assert Mul(*args)**e == ans
+    assert Mul(Pow(-1, Rational(3, 2), evaluate=False), I, I) == I
+    assert Mul(I*Pow(I, S.Half, evaluate=False)) == sqrt(I)*I
+
+
+def test_real_mul():
+    assert Float(0) * pi * x == 0
+    assert set((Float(1) * pi * x).args) == {Float(1), pi, x}
+
+
+def test_ncmul():
+    A = Symbol("A", commutative=False)
+    B = Symbol("B", commutative=False)
+    C = Symbol("C", commutative=False)
+    assert A*B != B*A
+    assert A*B*C != C*B*A
+    assert A*b*B*3*C == 3*b*A*B*C
+    assert A*b*B*3*C != 3*b*B*A*C
+    assert A*b*B*3*C == 3*A*B*C*b
+
+    assert A + B == B + A
+    assert (A + B)*C != C*(A + B)
+
+    assert C*(A + B)*C != C*C*(A + B)
+
+    assert A*A == A**2
+    assert (A + B)*(A + B) == (A + B)**2
+
+    assert A**-1 * A == 1
+    assert A/A == 1
+    assert A/(A**2) == 1/A
+
+    assert A/(1 + A) == A/(1 + A)
+
+    assert set((A + B + 2*(A + B)).args) == \
+        {A, B, 2*(A + B)}
+
+
+def test_mul_add_identity():
+    m = Mul(1, 2)
+    assert isinstance(m, Rational) and m.p == 2 and m.q == 1
+    m = Mul(1, 2, evaluate=False)
+    assert isinstance(m, Mul) and m.args == (1, 2)
+    m = Mul(0, 1)
+    assert m is S.Zero
+    m = Mul(0, 1, evaluate=False)
+    assert isinstance(m, Mul) and m.args == (0, 1)
+    m = Add(0, 1)
+    assert m is S.One
+    m = Add(0, 1, evaluate=False)
+    assert isinstance(m, Add) and m.args == (0, 1)
+
+
+def test_ncpow():
+    x = Symbol('x', commutative=False)
+    y = Symbol('y', commutative=False)
+    z = Symbol('z', commutative=False)
+    a = Symbol('a')
+    b = Symbol('b')
+    c = Symbol('c')
+
+    assert (x**2)*(y**2) != (y**2)*(x**2)
+    assert (x**-2)*y != y*(x**2)
+    assert 2**x*2**y != 2**(x + y)
+    assert 2**x*2**y*2**z != 2**(x + y + z)
+    assert 2**x*2**(2*x) == 2**(3*x)
+    assert 2**x*2**(2*x)*2**x == 2**(4*x)
+    assert exp(x)*exp(y) != exp(y)*exp(x)
+    assert exp(x)*exp(y)*exp(z) != exp(y)*exp(x)*exp(z)
+    assert exp(x)*exp(y)*exp(z) != exp(x + y + z)
+    assert x**a*x**b != x**(a + b)
+    assert x**a*x**b*x**c != x**(a + b + c)
+    assert x**3*x**4 == x**7
+    assert x**3*x**4*x**2 == x**9
+    assert x**a*x**(4*a) == x**(5*a)
+    assert x**a*x**(4*a)*x**a == x**(6*a)
+
+
+def test_powerbug():
+    x = Symbol("x")
+    assert x**1 != (-x)**1
+    assert x**2 == (-x)**2
+    assert x**3 != (-x)**3
+    assert x**4 == (-x)**4
+    assert x**5 != (-x)**5
+    assert x**6 == (-x)**6
+
+    assert x**128 == (-x)**128
+    assert x**129 != (-x)**129
+
+    assert (2*x)**2 == (-2*x)**2
+
+
+def test_Mul_doesnt_expand_exp():
+    x = Symbol('x')
+    y = Symbol('y')
+    assert unchanged(Mul, exp(x), exp(y))
+    assert unchanged(Mul, 2**x, 2**y)
+    assert x**2*x**3 == x**5
+    assert 2**x*3**x == 6**x
+    assert x**(y)*x**(2*y) == x**(3*y)
+    assert sqrt(2)*sqrt(2) == 2
+    assert 2**x*2**(2*x) == 2**(3*x)
+    assert sqrt(2)*2**Rational(1, 4)*5**Rational(3, 4) == 10**Rational(3, 4)
+    assert (x**(-log(5)/log(3))*x)/(x*x**( - log(5)/log(3))) == sympify(1)
+
+
+def test_Mul_is_integer():
+    k = Symbol('k', integer=True)
+    n = Symbol('n', integer=True)
+    nr = Symbol('nr', rational=False)
+    ir = Symbol('ir', irrational=True)
+    nz = Symbol('nz', integer=True, zero=False)
+    e = Symbol('e', even=True)
+    o = Symbol('o', odd=True)
+    i2 = Symbol('2', prime=True, even=True)
+
+    assert (k/3).is_integer is None
+    assert (nz/3).is_integer is None
+    assert (nr/3).is_integer is False
+    assert (ir/3).is_integer is False
+    assert (x*k*n).is_integer is None
+    assert (e/2).is_integer is True
+    assert (e**2/2).is_integer is True
+    assert (2/k).is_integer is None
+    assert (2/k**2).is_integer is None
+    assert ((-1)**k*n).is_integer is True
+    assert (3*k*e/2).is_integer is True
+    assert (2*k*e/3).is_integer is None
+    assert (e/o).is_integer is None
+    assert (o/e).is_integer is False
+    assert (o/i2).is_integer is False
+    assert Mul(k, 1/k, evaluate=False).is_integer is None
+    assert Mul(2., S.Half, evaluate=False).is_integer is None
+    assert (2*sqrt(k)).is_integer is None
+    assert (2*k**n).is_integer is None
+
+    s = 2**2**2**Pow(2, 1000, evaluate=False)
+    m = Mul(s, s, evaluate=False)
+    assert m.is_integer
+
+    # broken in 1.6 and before, see #20161
+    xq = Symbol('xq', rational=True)
+    yq = Symbol('yq', rational=True)
+    assert (xq*yq).is_integer is None
+    e_20161 = Mul(-1,Mul(1,Pow(2,-1,evaluate=False),evaluate=False),evaluate=False)
+    assert e_20161.is_integer is not True # expand(e_20161) -> -1/2, but no need to see that in the assumption without evaluation
+
+
+def test_Add_Mul_is_integer():
+    x = Symbol('x')
+
+    k = Symbol('k', integer=True)
+    n = Symbol('n', integer=True)
+    nk = Symbol('nk', integer=False)
+    nr = Symbol('nr', rational=False)
+    nz = Symbol('nz', integer=True, zero=False)
+
+    assert (-nk).is_integer is None
+    assert (-nr).is_integer is False
+    assert (2*k).is_integer is True
+    assert (-k).is_integer is True
+
+    assert (k + nk).is_integer is False
+    assert (k + n).is_integer is True
+    assert (k + x).is_integer is None
+    assert (k + n*x).is_integer is None
+    assert (k + n/3).is_integer is None
+    assert (k + nz/3).is_integer is None
+    assert (k + nr/3).is_integer is False
+
+    assert ((1 + sqrt(3))*(-sqrt(3) + 1)).is_integer is not False
+    assert (1 + (1 + sqrt(3))*(-sqrt(3) + 1)).is_integer is not False
+
+
+def test_Add_Mul_is_finite():
+    x = Symbol('x', extended_real=True, finite=False)
+
+    assert sin(x).is_finite is True
+    assert (x*sin(x)).is_finite is None
+    assert (x*atan(x)).is_finite is False
+    assert (1024*sin(x)).is_finite is True
+    assert (sin(x)*exp(x)).is_finite is None
+    assert (sin(x)*cos(x)).is_finite is True
+    assert (x*sin(x)*exp(x)).is_finite is None
+
+    assert (sin(x) - 67).is_finite is True
+    assert (sin(x) + exp(x)).is_finite is not True
+    assert (1 + x).is_finite is False
+    assert (1 + x**2 + (1 + x)*(1 - x)).is_finite is None
+    assert (sqrt(2)*(1 + x)).is_finite is False
+    assert (sqrt(2)*(1 + x)*(1 - x)).is_finite is False
+
+
+def test_Mul_is_even_odd():
+    x = Symbol('x', integer=True)
+    y = Symbol('y', integer=True)
+
+    k = Symbol('k', odd=True)
+    n = Symbol('n', odd=True)
+    m = Symbol('m', even=True)
+
+    assert (2*x).is_even is True
+    assert (2*x).is_odd is False
+
+    assert (3*x).is_even is None
+    assert (3*x).is_odd is None
+
+    assert (k/3).is_integer is None
+    assert (k/3).is_even is None
+    assert (k/3).is_odd is None
+
+    assert (2*n).is_even is True
+    assert (2*n).is_odd is False
+
+    assert (2*m).is_even is True
+    assert (2*m).is_odd is False
+
+    assert (-n).is_even is False
+    assert (-n).is_odd is True
+
+    assert (k*n).is_even is False
+    assert (k*n).is_odd is True
+
+    assert (k*m).is_even is True
+    assert (k*m).is_odd is False
+
+    assert (k*n*m).is_even is True
+    assert (k*n*m).is_odd is False
+
+    assert (k*m*x).is_even is True
+    assert (k*m*x).is_odd is False
+
+    # issue 6791:
+    assert (x/2).is_integer is None
+    assert (k/2).is_integer is False
+    assert (m/2).is_integer is True
+
+    assert (x*y).is_even is None
+    assert (x*x).is_even is None
+    assert (x*(x + k)).is_even is True
+    assert (x*(x + m)).is_even is None
+
+    assert (x*y).is_odd is None
+    assert (x*x).is_odd is None
+    assert (x*(x + k)).is_odd is False
+    assert (x*(x + m)).is_odd is None
+
+    # issue 8648
+    assert (m**2/2).is_even
+    assert (m**2/3).is_even is False
+    assert (2/m**2).is_odd is False
+    assert (2/m).is_odd is None
+
+
+@XFAIL
+def test_evenness_in_ternary_integer_product_with_odd():
+    # Tests that oddness inference is independent of term ordering.
+    # Term ordering at the point of testing depends on SymPy's symbol order, so
+    # we try to force a different order by modifying symbol names.
+    x = Symbol('x', integer=True)
+    y = Symbol('y', integer=True)
+    k = Symbol('k', odd=True)
+    assert (x*y*(y + k)).is_even is True
+    assert (y*x*(x + k)).is_even is True
+
+
+def test_evenness_in_ternary_integer_product_with_even():
+    x = Symbol('x', integer=True)
+    y = Symbol('y', integer=True)
+    m = Symbol('m', even=True)
+    assert (x*y*(y + m)).is_even is None
+
+
+@XFAIL
+def test_oddness_in_ternary_integer_product_with_odd():
+    # Tests that oddness inference is independent of term ordering.
+    # Term ordering at the point of testing depends on SymPy's symbol order, so
+    # we try to force a different order by modifying symbol names.
+    x = Symbol('x', integer=True)
+    y = Symbol('y', integer=True)
+    k = Symbol('k', odd=True)
+    assert (x*y*(y + k)).is_odd is False
+    assert (y*x*(x + k)).is_odd is False
+
+
+def test_oddness_in_ternary_integer_product_with_even():
+    x = Symbol('x', integer=True)
+    y = Symbol('y', integer=True)
+    m = Symbol('m', even=True)
+    assert (x*y*(y + m)).is_odd is None
+
+
+def test_Mul_is_rational():
+    x = Symbol('x')
+    n = Symbol('n', integer=True)
+    m = Symbol('m', integer=True, nonzero=True)
+
+    assert (n/m).is_rational is True
+    assert (x/pi).is_rational is None
+    assert (x/n).is_rational is None
+    assert (m/pi).is_rational is False
+
+    r = Symbol('r', rational=True)
+    assert (pi*r).is_rational is None
+
+    # issue 8008
+    z = Symbol('z', zero=True)
+    i = Symbol('i', imaginary=True)
+    assert (z*i).is_rational is True
+    bi = Symbol('i', imaginary=True, finite=True)
+    assert (z*bi).is_zero is True
+
+
+def test_Add_is_rational():
+    x = Symbol('x')
+    n = Symbol('n', rational=True)
+    m = Symbol('m', rational=True)
+
+    assert (n + m).is_rational is True
+    assert (x + pi).is_rational is None
+    assert (x + n).is_rational is None
+    assert (n + pi).is_rational is False
+
+
+def test_Add_is_even_odd():
+    x = Symbol('x', integer=True)
+
+    k = Symbol('k', odd=True)
+    n = Symbol('n', odd=True)
+    m = Symbol('m', even=True)
+
+    assert (k + 7).is_even is True
+    assert (k + 7).is_odd is False
+
+    assert (-k + 7).is_even is True
+    assert (-k + 7).is_odd is False
+
+    assert (k - 12).is_even is False
+    assert (k - 12).is_odd is True
+
+    assert (-k - 12).is_even is False
+    assert (-k - 12).is_odd is True
+
+    assert (k + n).is_even is True
+    assert (k + n).is_odd is False
+
+    assert (k + m).is_even is False
+    assert (k + m).is_odd is True
+
+    assert (k + n + m).is_even is True
+    assert (k + n + m).is_odd is False
+
+    assert (k + n + x + m).is_even is None
+    assert (k + n + x + m).is_odd is None
+
+
+def test_Mul_is_negative_positive():
+    x = Symbol('x', real=True)
+    y = Symbol('y', extended_real=False, complex=True)
+    z = Symbol('z', zero=True)
+
+    e = 2*z
+    assert e.is_Mul and e.is_positive is False and e.is_negative is False
+
+    neg = Symbol('neg', negative=True)
+    pos = Symbol('pos', positive=True)
+    nneg = Symbol('nneg', nonnegative=True)
+    npos = Symbol('npos', nonpositive=True)
+
+    assert neg.is_negative is True
+    assert (-neg).is_negative is False
+    assert (2*neg).is_negative is True
+
+    assert (2*pos)._eval_is_extended_negative() is False
+    assert (2*pos).is_negative is False
+
+    assert pos.is_negative is False
+    assert (-pos).is_negative is True
+    assert (2*pos).is_negative is False
+
+    assert (pos*neg).is_negative is True
+    assert (2*pos*neg).is_negative is True
+    assert (-pos*neg).is_negative is False
+    assert (pos*neg*y).is_negative is False     # y.is_real=F;  !real -> !neg
+
+    assert nneg.is_negative is False
+    assert (-nneg).is_negative is None
+    assert (2*nneg).is_negative is False
+
+    assert npos.is_negative is None
+    assert (-npos).is_negative is False
+    assert (2*npos).is_negative is None
+
+    assert (nneg*npos).is_negative is None
+
+    assert (neg*nneg).is_negative is None
+    assert (neg*npos).is_negative is False
+
+    assert (pos*nneg).is_negative is False
+    assert (pos*npos).is_negative is None
+
+    assert (npos*neg*nneg).is_negative is False
+    assert (npos*pos*nneg).is_negative is None
+
+    assert (-npos*neg*nneg).is_negative is None
+    assert (-npos*pos*nneg).is_negative is False
+
+    assert (17*npos*neg*nneg).is_negative is False
+    assert (17*npos*pos*nneg).is_negative is None
+
+    assert (neg*npos*pos*nneg).is_negative is False
+
+    assert (x*neg).is_negative is None
+    assert (nneg*npos*pos*x*neg).is_negative is None
+
+    assert neg.is_positive is False
+    assert (-neg).is_positive is True
+    assert (2*neg).is_positive is False
+
+    assert pos.is_positive is True
+    assert (-pos).is_positive is False
+    assert (2*pos).is_positive is True
+
+    assert (pos*neg).is_positive is False
+    assert (2*pos*neg).is_positive is False
+    assert (-pos*neg).is_positive is True
+    assert (-pos*neg*y).is_positive is False    # y.is_real=F;  !real -> !neg
+
+    assert nneg.is_positive is None
+    assert (-nneg).is_positive is False
+    assert (2*nneg).is_positive is None
+
+    assert npos.is_positive is False
+    assert (-npos).is_positive is None
+    assert (2*npos).is_positive is False
+
+    assert (nneg*npos).is_positive is False
+
+    assert (neg*nneg).is_positive is False
+    assert (neg*npos).is_positive is None
+
+    assert (pos*nneg).is_positive is None
+    assert (pos*npos).is_positive is False
+
+    assert (npos*neg*nneg).is_positive is None
+    assert (npos*pos*nneg).is_positive is False
+
+    assert (-npos*neg*nneg).is_positive is False
+    assert (-npos*pos*nneg).is_positive is None
+
+    assert (17*npos*neg*nneg).is_positive is None
+    assert (17*npos*pos*nneg).is_positive is False
+
+    assert (neg*npos*pos*nneg).is_positive is None
+
+    assert (x*neg).is_positive is None
+    assert (nneg*npos*pos*x*neg).is_positive is None
+
+
+def test_Mul_is_negative_positive_2():
+    a = Symbol('a', nonnegative=True)
+    b = Symbol('b', nonnegative=True)
+    c = Symbol('c', nonpositive=True)
+    d = Symbol('d', nonpositive=True)
+
+    assert (a*b).is_nonnegative is True
+    assert (a*b).is_negative is False
+    assert (a*b).is_zero is None
+    assert (a*b).is_positive is None
+
+    assert (c*d).is_nonnegative is True
+    assert (c*d).is_negative is False
+    assert (c*d).is_zero is None
+    assert (c*d).is_positive is None
+
+    assert (a*c).is_nonpositive is True
+    assert (a*c).is_positive is False
+    assert (a*c).is_zero is None
+    assert (a*c).is_negative is None
+
+
+def test_Mul_is_nonpositive_nonnegative():
+    x = Symbol('x', real=True)
+
+    k = Symbol('k', negative=True)
+    n = Symbol('n', positive=True)
+    u = Symbol('u', nonnegative=True)
+    v = Symbol('v', nonpositive=True)
+
+    assert k.is_nonpositive is True
+    assert (-k).is_nonpositive is False
+    assert (2*k).is_nonpositive is True
+
+    assert n.is_nonpositive is False
+    assert (-n).is_nonpositive is True
+    assert (2*n).is_nonpositive is False
+
+    assert (n*k).is_nonpositive is True
+    assert (2*n*k).is_nonpositive is True
+    assert (-n*k).is_nonpositive is False
+
+    assert u.is_nonpositive is None
+    assert (-u).is_nonpositive is True
+    assert (2*u).is_nonpositive is None
+
+    assert v.is_nonpositive is True
+    assert (-v).is_nonpositive is None
+    assert (2*v).is_nonpositive is True
+
+    assert (u*v).is_nonpositive is True
+
+    assert (k*u).is_nonpositive is True
+    assert (k*v).is_nonpositive is None
+
+    assert (n*u).is_nonpositive is None
+    assert (n*v).is_nonpositive is True
+
+    assert (v*k*u).is_nonpositive is None
+    assert (v*n*u).is_nonpositive is True
+
+    assert (-v*k*u).is_nonpositive is True
+    assert (-v*n*u).is_nonpositive is None
+
+    assert (17*v*k*u).is_nonpositive is None
+    assert (17*v*n*u).is_nonpositive is True
+
+    assert (k*v*n*u).is_nonpositive is None
+
+    assert (x*k).is_nonpositive is None
+    assert (u*v*n*x*k).is_nonpositive is None
+
+    assert k.is_nonnegative is False
+    assert (-k).is_nonnegative is True
+    assert (2*k).is_nonnegative is False
+
+    assert n.is_nonnegative is True
+    assert (-n).is_nonnegative is False
+    assert (2*n).is_nonnegative is True
+
+    assert (n*k).is_nonnegative is False
+    assert (2*n*k).is_nonnegative is False
+    assert (-n*k).is_nonnegative is True
+
+    assert u.is_nonnegative is True
+    assert (-u).is_nonnegative is None
+    assert (2*u).is_nonnegative is True
+
+    assert v.is_nonnegative is None
+    assert (-v).is_nonnegative is True
+    assert (2*v).is_nonnegative is None
+
+    assert (u*v).is_nonnegative is None
+
+    assert (k*u).is_nonnegative is None
+    assert (k*v).is_nonnegative is True
+
+    assert (n*u).is_nonnegative is True
+    assert (n*v).is_nonnegative is None
+
+    assert (v*k*u).is_nonnegative is True
+    assert (v*n*u).is_nonnegative is None
+
+    assert (-v*k*u).is_nonnegative is None
+    assert (-v*n*u).is_nonnegative is True
+
+    assert (17*v*k*u).is_nonnegative is True
+    assert (17*v*n*u).is_nonnegative is None
+
+    assert (k*v*n*u).is_nonnegative is True
+
+    assert (x*k).is_nonnegative is None
+    assert (u*v*n*x*k).is_nonnegative is None
+
+
+def test_Add_is_negative_positive():
+    x = Symbol('x', real=True)
+
+    k = Symbol('k', negative=True)
+    n = Symbol('n', positive=True)
+    u = Symbol('u', nonnegative=True)
+    v = Symbol('v', nonpositive=True)
+
+    assert (k - 2).is_negative is True
+    assert (k + 17).is_negative is None
+    assert (-k - 5).is_negative is None
+    assert (-k + 123).is_negative is False
+
+    assert (k - n).is_negative is True
+    assert (k + n).is_negative is None
+    assert (-k - n).is_negative is None
+    assert (-k + n).is_negative is False
+
+    assert (k - n - 2).is_negative is True
+    assert (k + n + 17).is_negative is None
+    assert (-k - n - 5).is_negative is None
+    assert (-k + n + 123).is_negative is False
+
+    assert (-2*k + 123*n + 17).is_negative is False
+
+    assert (k + u).is_negative is None
+    assert (k + v).is_negative is True
+    assert (n + u).is_negative is False
+    assert (n + v).is_negative is None
+
+    assert (u - v).is_negative is False
+    assert (u + v).is_negative is None
+    assert (-u - v).is_negative is None
+    assert (-u + v).is_negative is None
+
+    assert (u - v + n + 2).is_negative is False
+    assert (u + v + n + 2).is_negative is None
+    assert (-u - v + n + 2).is_negative is None
+    assert (-u + v + n + 2).is_negative is None
+
+    assert (k + x).is_negative is None
+    assert (k + x - n).is_negative is None
+
+    assert (k - 2).is_positive is False
+    assert (k + 17).is_positive is None
+    assert (-k - 5).is_positive is None
+    assert (-k + 123).is_positive is True
+
+    assert (k - n).is_positive is False
+    assert (k + n).is_positive is None
+    assert (-k - n).is_positive is None
+    assert (-k + n).is_positive is True
+
+    assert (k - n - 2).is_positive is False
+    assert (k + n + 17).is_positive is None
+    assert (-k - n - 5).is_positive is None
+    assert (-k + n + 123).is_positive is True
+
+    assert (-2*k + 123*n + 17).is_positive is True
+
+    assert (k + u).is_positive is None
+    assert (k + v).is_positive is False
+    assert (n + u).is_positive is True
+    assert (n + v).is_positive is None
+
+    assert (u - v).is_positive is None
+    assert (u + v).is_positive is None
+    assert (-u - v).is_positive is None
+    assert (-u + v).is_positive is False
+
+    assert (u - v - n - 2).is_positive is None
+    assert (u + v - n - 2).is_positive is None
+    assert (-u - v - n - 2).is_positive is None
+    assert (-u + v - n - 2).is_positive is False
+
+    assert (n + x).is_positive is None
+    assert (n + x - k).is_positive is None
+
+    z = (-3 - sqrt(5) + (-sqrt(10)/2 - sqrt(2)/2)**2)
+    assert z.is_zero
+    z = sqrt(1 + sqrt(3)) + sqrt(3 + 3*sqrt(3)) - sqrt(10 + 6*sqrt(3))
+    assert z.is_zero
+
+
+def test_Add_is_nonpositive_nonnegative():
+    x = Symbol('x', real=True)
+
+    k = Symbol('k', negative=True)
+    n = Symbol('n', positive=True)
+    u = Symbol('u', nonnegative=True)
+    v = Symbol('v', nonpositive=True)
+
+    assert (u - 2).is_nonpositive is None
+    assert (u + 17).is_nonpositive is False
+    assert (-u - 5).is_nonpositive is True
+    assert (-u + 123).is_nonpositive is None
+
+    assert (u - v).is_nonpositive is None
+    assert (u + v).is_nonpositive is None
+    assert (-u - v).is_nonpositive is None
+    assert (-u + v).is_nonpositive is True
+
+    assert (u - v - 2).is_nonpositive is None
+    assert (u + v + 17).is_nonpositive is None
+    assert (-u - v - 5).is_nonpositive is None
+    assert (-u + v - 123).is_nonpositive is True
+
+    assert (-2*u + 123*v - 17).is_nonpositive is True
+
+    assert (k + u).is_nonpositive is None
+    assert (k + v).is_nonpositive is True
+    assert (n + u).is_nonpositive is False
+    assert (n + v).is_nonpositive is None
+
+    assert (k - n).is_nonpositive is True
+    assert (k + n).is_nonpositive is None
+    assert (-k - n).is_nonpositive is None
+    assert (-k + n).is_nonpositive is False
+
+    assert (k - n + u + 2).is_nonpositive is None
+    assert (k + n + u + 2).is_nonpositive is None
+    assert (-k - n + u + 2).is_nonpositive is None
+    assert (-k + n + u + 2).is_nonpositive is False
+
+    assert (u + x).is_nonpositive is None
+    assert (v - x - n).is_nonpositive is None
+
+    assert (u - 2).is_nonnegative is None
+    assert (u + 17).is_nonnegative is True
+    assert (-u - 5).is_nonnegative is False
+    assert (-u + 123).is_nonnegative is None
+
+    assert (u - v).is_nonnegative is True
+    assert (u + v).is_nonnegative is None
+    assert (-u - v).is_nonnegative is None
+    assert (-u + v).is_nonnegative is None
+
+    assert (u - v + 2).is_nonnegative is True
+    assert (u + v + 17).is_nonnegative is None
+    assert (-u - v - 5).is_nonnegative is None
+    assert (-u + v - 123).is_nonnegative is False
+
+    assert (2*u - 123*v + 17).is_nonnegative is True
+
+    assert (k + u).is_nonnegative is None
+    assert (k + v).is_nonnegative is False
+    assert (n + u).is_nonnegative is True
+    assert (n + v).is_nonnegative is None
+
+    assert (k - n).is_nonnegative is False
+    assert (k + n).is_nonnegative is None
+    assert (-k - n).is_nonnegative is None
+    assert (-k + n).is_nonnegative is True
+
+    assert (k - n - u - 2).is_nonnegative is False
+    assert (k + n - u - 2).is_nonnegative is None
+    assert (-k - n - u - 2).is_nonnegative is None
+    assert (-k + n - u - 2).is_nonnegative is None
+
+    assert (u - x).is_nonnegative is None
+    assert (v + x + n).is_nonnegative is None
+
+
+def test_Pow_is_integer():
+    x = Symbol('x')
+
+    k = Symbol('k', integer=True)
+    n = Symbol('n', integer=True, nonnegative=True)
+    m = Symbol('m', integer=True, positive=True)
+
+    assert (k**2).is_integer is True
+    assert (k**(-2)).is_integer is None
+    assert ((m + 1)**(-2)).is_integer is False
+    assert (m**(-1)).is_integer is None  # issue 8580
+
+    assert (2**k).is_integer is None
+    assert (2**(-k)).is_integer is None
+
+    assert (2**n).is_integer is True
+    assert (2**(-n)).is_integer is None
+
+    assert (2**m).is_integer is True
+    assert (2**(-m)).is_integer is False
+
+    assert (x**2).is_integer is None
+    assert (2**x).is_integer is None
+
+    assert (k**n).is_integer is True
+    assert (k**(-n)).is_integer is None
+
+    assert (k**x).is_integer is None
+    assert (x**k).is_integer is None
+
+    assert (k**(n*m)).is_integer is True
+    assert (k**(-n*m)).is_integer is None
+
+    assert sqrt(3).is_integer is False
+    assert sqrt(.3).is_integer is False
+    assert Pow(3, 2, evaluate=False).is_integer is True
+    assert Pow(3, 0, evaluate=False).is_integer is True
+    assert Pow(3, -2, evaluate=False).is_integer is False
+    assert Pow(S.Half, 3, evaluate=False).is_integer is False
+    # decided by re-evaluating
+    assert Pow(3, S.Half, evaluate=False).is_integer is False
+    assert Pow(3, S.Half, evaluate=False).is_integer is False
+    assert Pow(4, S.Half, evaluate=False).is_integer is True
+    assert Pow(S.Half, -2, evaluate=False).is_integer is True
+
+    assert ((-1)**k).is_integer
+
+    # issue 8641
+    x = Symbol('x', real=True, integer=False)
+    assert (x**2).is_integer is None
+
+    # issue 10458
+    x = Symbol('x', positive=True)
+    assert (1/(x + 1)).is_integer is False
+    assert (1/(-x - 1)).is_integer is False
+    assert (-1/(x + 1)).is_integer is False
+    # issue 23287
+    assert (x**2/2).is_integer is None
+
+    # issue 8648-like
+    k = Symbol('k', even=True)
+    assert (k**3/2).is_integer
+    assert (k**3/8).is_integer
+    assert (k**3/16).is_integer is None
+    assert (2/k).is_integer is None
+    assert (2/k**2).is_integer is False
+    o = Symbol('o', odd=True)
+    assert (k/o).is_integer is None
+    o = Symbol('o', odd=True, prime=True)
+    assert (k/o).is_integer is False
+
+
+def test_Pow_is_real():
+    x = Symbol('x', real=True)
+    y = Symbol('y', positive=True)
+
+    assert (x**2).is_real is True
+    assert (x**3).is_real is True
+    assert (x**x).is_real is None
+    assert (y**x).is_real is True
+
+    assert (x**Rational(1, 3)).is_real is None
+    assert (y**Rational(1, 3)).is_real is True
+
+    assert sqrt(-1 - sqrt(2)).is_real is False
+
+    i = Symbol('i', imaginary=True)
+    assert (i**i).is_real is None
+    assert (I**i).is_extended_real is True
+    assert ((-I)**i).is_extended_real is True
+    assert (2**i).is_real is None  # (2**(pi/log(2) * I)) is real, 2**I is not
+    assert (2**I).is_real is False
+    assert (2**-I).is_real is False
+    assert (i**2).is_extended_real is True
+    assert (i**3).is_extended_real is False
+    assert (i**x).is_real is None  # could be (-I)**(2/3)
+    e = Symbol('e', even=True)
+    o = Symbol('o', odd=True)
+    k = Symbol('k', integer=True)
+    assert (i**e).is_extended_real is True
+    assert (i**o).is_extended_real is False
+    assert (i**k).is_real is None
+    assert (i**(4*k)).is_extended_real is True
+
+    x = Symbol("x", nonnegative=True)
+    y = Symbol("y", nonnegative=True)
+    assert im(x**y).expand(complex=True) is S.Zero
+    assert (x**y).is_real is True
+    i = Symbol('i', imaginary=True)
+    assert (exp(i)**I).is_extended_real is True
+    assert log(exp(i)).is_imaginary is None  # i could be 2*pi*I
+    c = Symbol('c', complex=True)
+    assert log(c).is_real is None  # c could be 0 or 2, too
+    assert log(exp(c)).is_real is None  # log(0), log(E), ...
+    n = Symbol('n', negative=False)
+    assert log(n).is_real is None
+    n = Symbol('n', nonnegative=True)
+    assert log(n).is_real is None
+
+    assert sqrt(-I).is_real is False  # issue 7843
+
+    i = Symbol('i', integer=True)
+    assert (1/(i-1)).is_real is None
+    assert (1/(i-1)).is_extended_real is None
+
+    # test issue 20715
+    from sympy.core.parameters import evaluate
+    x = S(-1)
+    with evaluate(False):
+        assert x.is_negative is True
+
+    f = Pow(x, -1)
+    with evaluate(False):
+        assert f.is_imaginary is False
+
+
+def test_real_Pow():
+    k = Symbol('k', integer=True, nonzero=True)
+    assert (k**(I*pi/log(k))).is_real
+
+
+def test_Pow_is_finite():
+    xe = Symbol('xe', extended_real=True)
+    xr = Symbol('xr', real=True)
+    p = Symbol('p', positive=True)
+    n = Symbol('n', negative=True)
+    i = Symbol('i', integer=True)
+
+    assert (xe**2).is_finite is None  # xe could be oo
+    assert (xr**2).is_finite is True
+
+    assert (xe**xe).is_finite is None
+    assert (xr**xe).is_finite is None
+    assert (xe**xr).is_finite is None
+    # FIXME: The line below should be True rather than None
+    # assert (xr**xr).is_finite is True
+    assert (xr**xr).is_finite is None
+
+    assert (p**xe).is_finite is None
+    assert (p**xr).is_finite is True
+
+    assert (n**xe).is_finite is None
+    assert (n**xr).is_finite is True
+
+    assert (sin(xe)**2).is_finite is True
+    assert (sin(xr)**2).is_finite is True
+
+    assert (sin(xe)**xe).is_finite is None  # xe, xr could be -pi
+    assert (sin(xr)**xr).is_finite is None
+
+    # FIXME: Should the line below be True rather than None?
+    assert (sin(xe)**exp(xe)).is_finite is None
+    assert (sin(xr)**exp(xr)).is_finite is True
+
+    assert (1/sin(xe)).is_finite is None  # if zero, no, otherwise yes
+    assert (1/sin(xr)).is_finite is None
+
+    assert (1/exp(xe)).is_finite is None  # xe could be -oo
+    assert (1/exp(xr)).is_finite is True
+
+    assert (1/S.Pi).is_finite is True
+
+    assert (1/(i-1)).is_finite is None
+
+
+def test_Pow_is_even_odd():
+    x = Symbol('x')
+
+    k = Symbol('k', even=True)
+    n = Symbol('n', odd=True)
+    m = Symbol('m', integer=True, nonnegative=True)
+    p = Symbol('p', integer=True, positive=True)
+
+    assert ((-1)**n).is_odd
+    assert ((-1)**k).is_odd
+    assert ((-1)**(m - p)).is_odd
+
+    assert (k**2).is_even is True
+    assert (n**2).is_even is False
+    assert (2**k).is_even is None
+    assert (x**2).is_even is None
+
+    assert (k**m).is_even is None
+    assert (n**m).is_even is False
+
+    assert (k**p).is_even is True
+    assert (n**p).is_even is False
+
+    assert (m**k).is_even is None
+    assert (p**k).is_even is None
+
+    assert (m**n).is_even is None
+    assert (p**n).is_even is None
+
+    assert (k**x).is_even is None
+    assert (n**x).is_even is None
+
+    assert (k**2).is_odd is False
+    assert (n**2).is_odd is True
+    assert (3**k).is_odd is None
+
+    assert (k**m).is_odd is None
+    assert (n**m).is_odd is True
+
+    assert (k**p).is_odd is False
+    assert (n**p).is_odd is True
+
+    assert (m**k).is_odd is None
+    assert (p**k).is_odd is None
+
+    assert (m**n).is_odd is None
+    assert (p**n).is_odd is None
+
+    assert (k**x).is_odd is None
+    assert (n**x).is_odd is None
+
+
+def test_Pow_is_negative_positive():
+    r = Symbol('r', real=True)
+
+    k = Symbol('k', integer=True, positive=True)
+    n = Symbol('n', even=True)
+    m = Symbol('m', odd=True)
+
+    x = Symbol('x')
+
+    assert (2**r).is_positive is True
+    assert ((-2)**r).is_positive is None
+    assert ((-2)**n).is_positive is True
+    assert ((-2)**m).is_positive is False
+
+    assert (k**2).is_positive is True
+    assert (k**(-2)).is_positive is True
+
+    assert (k**r).is_positive is True
+    assert ((-k)**r).is_positive is None
+    assert ((-k)**n).is_positive is True
+    assert ((-k)**m).is_positive is False
+
+    assert (2**r).is_negative is False
+    assert ((-2)**r).is_negative is None
+    assert ((-2)**n).is_negative is False
+    assert ((-2)**m).is_negative is True
+
+    assert (k**2).is_negative is False
+    assert (k**(-2)).is_negative is False
+
+    assert (k**r).is_negative is False
+    assert ((-k)**r).is_negative is None
+    assert ((-k)**n).is_negative is False
+    assert ((-k)**m).is_negative is True
+
+    assert (2**x).is_positive is None
+    assert (2**x).is_negative is None
+
+
+def test_Pow_is_zero():
+    z = Symbol('z', zero=True)
+    e = z**2
+    assert e.is_zero
+    assert e.is_positive is False
+    assert e.is_negative is False
+
+    assert Pow(0, 0, evaluate=False).is_zero is False
+    assert Pow(0, 3, evaluate=False).is_zero
+    assert Pow(0, oo, evaluate=False).is_zero
+    assert Pow(0, -3, evaluate=False).is_zero is False
+    assert Pow(0, -oo, evaluate=False).is_zero is False
+    assert Pow(2, 2, evaluate=False).is_zero is False
+
+    a = Symbol('a', zero=False)
+    assert Pow(a, 3).is_zero is False  # issue 7965
+
+    assert Pow(2, oo, evaluate=False).is_zero is False
+    assert Pow(2, -oo, evaluate=False).is_zero
+    assert Pow(S.Half, oo, evaluate=False).is_zero
+    assert Pow(S.Half, -oo, evaluate=False).is_zero is False
+
+    # All combinations of real/complex base/exponent
+    h = S.Half
+    T = True
+    F = False
+    N = None
+
+    pow_iszero = [
+        ['**',  0,  h,  1,  2, -h, -1,-2,-2*I,-I/2,I/2,1+I,oo,-oo,zoo],
+        [   0,  F,  T,  T,  T,  F,  F,  F,  F,  F,  F,  N,  T,  F,  N],
+        [   h,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  T,  F,  N],
+        [   1,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  N],
+        [   2,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  T,  N],
+        [  -h,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  T,  F,  N],
+        [  -1,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  N],
+        [  -2,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  T,  N],
+        [-2*I,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  T,  N],
+        [-I/2,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  T,  F,  N],
+        [ I/2,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  T,  F,  N],
+        [ 1+I,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  T,  N],
+        [  oo,  F,  F,  F,  F,  T,  T,  T,  F,  F,  F,  F,  F,  T,  N],
+        [ -oo,  F,  F,  F,  F,  T,  T,  T,  F,  F,  F,  F,  F,  T,  N],
+        [ zoo,  F,  F,  F,  F,  T,  T,  T,  N,  N,  N,  N,  F,  T,  N]
+    ]
+
+    def test_table(table):
+        n = len(table[0])
+        for row in range(1, n):
+            base = table[row][0]
+            for col in range(1, n):
+                exp = table[0][col]
+                is_zero = table[row][col]
+                # The actual test here:
+                assert Pow(base, exp, evaluate=False).is_zero is is_zero
+
+    test_table(pow_iszero)
+
+    # A zero symbol...
+    zo, zo2 = symbols('zo, zo2', zero=True)
+
+    # All combinations of finite symbols
+    zf, zf2 = symbols('zf, zf2', finite=True)
+    wf, wf2 = symbols('wf, wf2', nonzero=True)
+    xf, xf2 = symbols('xf, xf2', real=True)
+    yf, yf2 = symbols('yf, yf2', nonzero=True)
+    af, af2 = symbols('af, af2', positive=True)
+    bf, bf2 = symbols('bf, bf2', nonnegative=True)
+    cf, cf2 = symbols('cf, cf2', negative=True)
+    df, df2 = symbols('df, df2', nonpositive=True)
+
+    # Without finiteness:
+    zi, zi2 = symbols('zi, zi2')
+    wi, wi2 = symbols('wi, wi2', zero=False)
+    xi, xi2 = symbols('xi, xi2', extended_real=True)
+    yi, yi2 = symbols('yi, yi2', zero=False, extended_real=True)
+    ai, ai2 = symbols('ai, ai2', extended_positive=True)
+    bi, bi2 = symbols('bi, bi2', extended_nonnegative=True)
+    ci, ci2 = symbols('ci, ci2', extended_negative=True)
+    di, di2 = symbols('di, di2', extended_nonpositive=True)
+
+    pow_iszero_sym = [
+        ['**',zo,wf,yf,af,cf,zf,xf,bf,df,zi,wi,xi,yi,ai,bi,ci,di],
+        [ zo2, F, N, N, T, F, N, N, N, F, N, N, N, N, T, N, F, F],
+        [ wf2, F, F, F, F, F, F, F, F, F, N, N, N, N, N, N, N, N],
+        [ yf2, F, F, F, F, F, F, F, F, F, N, N, N, N, N, N, N, N],
+        [ af2, F, F, F, F, F, F, F, F, F, N, N, N, N, N, N, N, N],
+        [ cf2, F, F, F, F, F, F, F, F, F, N, N, N, N, N, N, N, N],
+        [ zf2, N, N, N, N, F, N, N, N, N, N, N, N, N, N, N, N, N],
+        [ xf2, N, N, N, N, F, N, N, N, N, N, N, N, N, N, N, N, N],
+        [ bf2, N, N, N, N, F, N, N, N, N, N, N, N, N, N, N, N, N],
+        [ df2, N, N, N, N, F, N, N, N, N, N, N, N, N, N, N, N, N],
+        [ zi2, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N],
+        [ wi2, F, N, N, F, N, N, N, F, N, N, N, N, N, N, N, N, N],
+        [ xi2, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N],
+        [ yi2, F, N, N, F, N, N, N, F, N, N, N, N, N, N, N, N, N],
+        [ ai2, F, N, N, F, N, N, N, F, N, N, N, N, N, N, N, N, N],
+        [ bi2, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N],
+        [ ci2, F, N, N, F, N, N, N, F, N, N, N, N, N, N, N, N, N],
+        [ di2, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N]
+    ]
+
+    test_table(pow_iszero_sym)
+
+    # In some cases (x**x).is_zero is different from (x**y).is_zero even if y
+    # has the same assumptions as x.
+    assert (zo ** zo).is_zero is False
+    assert (wf ** wf).is_zero is False
+    assert (yf ** yf).is_zero is False
+    assert (af ** af).is_zero is False
+    assert (cf ** cf).is_zero is False
+    assert (zf ** zf).is_zero is None
+    assert (xf ** xf).is_zero is None
+    assert (bf ** bf).is_zero is False # None in table
+    assert (df ** df).is_zero is None
+    assert (zi ** zi).is_zero is None
+    assert (wi ** wi).is_zero is None
+    assert (xi ** xi).is_zero is None
+    assert (yi ** yi).is_zero is None
+    assert (ai ** ai).is_zero is False # None in table
+    assert (bi ** bi).is_zero is False # None in table
+    assert (ci ** ci).is_zero is None
+    assert (di ** di).is_zero is None
+
+
+def test_Pow_is_nonpositive_nonnegative():
+    x = Symbol('x', real=True)
+
+    k = Symbol('k', integer=True, nonnegative=True)
+    l = Symbol('l', integer=True, positive=True)
+    n = Symbol('n', even=True)
+    m = Symbol('m', odd=True)
+
+    assert (x**(4*k)).is_nonnegative is True
+    assert (2**x).is_nonnegative is True
+    assert ((-2)**x).is_nonnegative is None
+    assert ((-2)**n).is_nonnegative is True
+    assert ((-2)**m).is_nonnegative is False
+
+    assert (k**2).is_nonnegative is True
+    assert (k**(-2)).is_nonnegative is None
+    assert (k**k).is_nonnegative is True
+
+    assert (k**x).is_nonnegative is None    # NOTE (0**x).is_real = U
+    assert (l**x).is_nonnegative is True
+    assert (l**x).is_positive is True
+    assert ((-k)**x).is_nonnegative is None
+
+    assert ((-k)**m).is_nonnegative is None
+
+    assert (2**x).is_nonpositive is False
+    assert ((-2)**x).is_nonpositive is None
+    assert ((-2)**n).is_nonpositive is False
+    assert ((-2)**m).is_nonpositive is True
+
+    assert (k**2).is_nonpositive is None
+    assert (k**(-2)).is_nonpositive is None
+
+    assert (k**x).is_nonpositive is None
+    assert ((-k)**x).is_nonpositive is None
+    assert ((-k)**n).is_nonpositive is None
+
+
+    assert (x**2).is_nonnegative is True
+    i = symbols('i', imaginary=True)
+    assert (i**2).is_nonpositive is True
+    assert (i**4).is_nonpositive is False
+    assert (i**3).is_nonpositive is False
+    assert (I**i).is_nonnegative is True
+    assert (exp(I)**i).is_nonnegative is True
+
+    assert ((-l)**n).is_nonnegative is True
+    assert ((-l)**m).is_nonpositive is True
+    assert ((-k)**n).is_nonnegative is None
+    assert ((-k)**m).is_nonpositive is None
+
+
+def test_Mul_is_imaginary_real():
+    r = Symbol('r', real=True)
+    p = Symbol('p', positive=True)
+    i1 = Symbol('i1', imaginary=True)
+    i2 = Symbol('i2', imaginary=True)
+    x = Symbol('x')
+
+    assert I.is_imaginary is True
+    assert I.is_real is False
+    assert (-I).is_imaginary is True
+    assert (-I).is_real is False
+    assert (3*I).is_imaginary is True
+    assert (3*I).is_real is False
+    assert (I*I).is_imaginary is False
+    assert (I*I).is_real is True
+
+    e = (p + p*I)
+    j = Symbol('j', integer=True, zero=False)
+    assert (e**j).is_real is None
+    assert (e**(2*j)).is_real is None
+    assert (e**j).is_imaginary is None
+    assert (e**(2*j)).is_imaginary is None
+
+    assert (e**-1).is_imaginary is False
+    assert (e**2).is_imaginary
+    assert (e**3).is_imaginary is False
+    assert (e**4).is_imaginary is False
+    assert (e**5).is_imaginary is False
+    assert (e**-1).is_real is False
+    assert (e**2).is_real is False
+    assert (e**3).is_real is False
+    assert (e**4).is_real is True
+    assert (e**5).is_real is False
+    assert (e**3).is_complex
+
+    assert (r*i1).is_imaginary is None
+    assert (r*i1).is_real is None
+
+    assert (x*i1).is_imaginary is None
+    assert (x*i1).is_real is None
+
+    assert (i1*i2).is_imaginary is False
+    assert (i1*i2).is_real is True
+
+    assert (r*i1*i2).is_imaginary is False
+    assert (r*i1*i2).is_real is True
+
+    # Github's issue 5874:
+    nr = Symbol('nr', real=False, complex=True)  # e.g. I or 1 + I
+    a = Symbol('a', real=True, nonzero=True)
+    b = Symbol('b', real=True)
+    assert (i1*nr).is_real is None
+    assert (a*nr).is_real is False
+    assert (b*nr).is_real is None
+
+    ni = Symbol('ni', imaginary=False, complex=True)  # e.g. 2 or 1 + I
+    a = Symbol('a', real=True, nonzero=True)
+    b = Symbol('b', real=True)
+    assert (i1*ni).is_real is False
+    assert (a*ni).is_real is None
+    assert (b*ni).is_real is None
+
+
+def test_Mul_hermitian_antihermitian():
+    xz, yz = symbols('xz, yz', zero=True, antihermitian=True)
+    xf, yf = symbols('xf, yf', hermitian=False, antihermitian=False, finite=True)
+    xh, yh = symbols('xh, yh', hermitian=True, antihermitian=False, nonzero=True)
+    xa, ya = symbols('xa, ya', hermitian=False, antihermitian=True, zero=False, finite=True)
+    assert (xz*xh).is_hermitian is True
+    assert (xz*xh).is_antihermitian is True
+    assert (xz*xa).is_hermitian is True
+    assert (xz*xa).is_antihermitian is True
+    assert (xf*yf).is_hermitian is None
+    assert (xf*yf).is_antihermitian is None
+    assert (xh*yh).is_hermitian is True
+    assert (xh*yh).is_antihermitian is False
+    assert (xh*ya).is_hermitian is False
+    assert (xh*ya).is_antihermitian is True
+    assert (xa*ya).is_hermitian is True
+    assert (xa*ya).is_antihermitian is False
+
+    a = Symbol('a', hermitian=True, zero=False)
+    b = Symbol('b', hermitian=True)
+    c = Symbol('c', hermitian=False)
+    d = Symbol('d', antihermitian=True)
+    e1 = Mul(a, b, c, evaluate=False)
+    e2 = Mul(b, a, c, evaluate=False)
+    e3 = Mul(a, b, c, d, evaluate=False)
+    e4 = Mul(b, a, c, d, evaluate=False)
+    e5 = Mul(a, c, evaluate=False)
+    e6 = Mul(a, c, d, evaluate=False)
+    assert e1.is_hermitian is None
+    assert e2.is_hermitian is None
+    assert e1.is_antihermitian is None
+    assert e2.is_antihermitian is None
+    assert e3.is_antihermitian is None
+    assert e4.is_antihermitian is None
+    assert e5.is_antihermitian is None
+    assert e6.is_antihermitian is None
+
+
+def test_Add_is_comparable():
+    assert (x + y).is_comparable is False
+    assert (x + 1).is_comparable is False
+    assert (Rational(1, 3) - sqrt(8)).is_comparable is True
+
+
+def test_Mul_is_comparable():
+    assert (x*y).is_comparable is False
+    assert (x*2).is_comparable is False
+    assert (sqrt(2)*Rational(1, 3)).is_comparable is True
+
+
+def test_Pow_is_comparable():
+    assert (x**y).is_comparable is False
+    assert (x**2).is_comparable is False
+    assert (sqrt(Rational(1, 3))).is_comparable is True
+
+
+def test_Add_is_positive_2():
+    e = Rational(1, 3) - sqrt(8)
+    assert e.is_positive is False
+    assert e.is_negative is True
+
+    e = pi - 1
+    assert e.is_positive is True
+    assert e.is_negative is False
+
+
+def test_Add_is_irrational():
+    i = Symbol('i', irrational=True)
+
+    assert i.is_irrational is True
+    assert i.is_rational is False
+
+    assert (i + 1).is_irrational is True
+    assert (i + 1).is_rational is False
+
+
+def test_Mul_is_irrational():
+    expr = Mul(1, 2, 3, evaluate=False)
+    assert expr.is_irrational is False
+    expr = Mul(1, I, I, evaluate=False)
+    assert expr.is_rational is None # I * I = -1 but *no evaluation allowed*
+    # sqrt(2) * I * I = -sqrt(2) is irrational but
+    # this can't be determined without evaluating the
+    # expression and the eval_is routines shouldn't do that
+    expr = Mul(sqrt(2), I, I, evaluate=False)
+    assert expr.is_irrational is None
+
+
+def test_issue_3531():
+    # https://github.com/sympy/sympy/issues/3531
+    # https://github.com/sympy/sympy/pull/18116
+    class MightyNumeric(tuple):
+        def __rtruediv__(self, other):
+            return "something"
+
+    assert sympify(1)/MightyNumeric((1, 2)) == "something"
+
+
+def test_issue_3531b():
+    class Foo:
+        def __init__(self):
+            self.field = 1.0
+
+        def __mul__(self, other):
+            self.field = self.field * other
+
+        def __rmul__(self, other):
+            self.field = other * self.field
+    f = Foo()
+    x = Symbol("x")
+    assert f*x == x*f
+
+
+def test_bug3():
+    a = Symbol("a")
+    b = Symbol("b", positive=True)
+    e = 2*a + b
+    f = b + 2*a
+    assert e == f
+
+
+def test_suppressed_evaluation():
+    a = Add(0, 3, 2, evaluate=False)
+    b = Mul(1, 3, 2, evaluate=False)
+    c = Pow(3, 2, evaluate=False)
+    assert a != 6
+    assert a.func is Add
+    assert a.args == (0, 3, 2)
+    assert b != 6
+    assert b.func is Mul
+    assert b.args == (1, 3, 2)
+    assert c != 9
+    assert c.func is Pow
+    assert c.args == (3, 2)
+
+
+def test_AssocOp_doit():
+    a = Add(x,x, evaluate=False)
+    b = Mul(y,y, evaluate=False)
+    c = Add(b,b, evaluate=False)
+    d = Mul(a,a, evaluate=False)
+    assert c.doit(deep=False).func == Mul
+    assert c.doit(deep=False).args == (2,y,y)
+    assert c.doit().func == Mul
+    assert c.doit().args == (2, Pow(y,2))
+    assert d.doit(deep=False).func == Pow
+    assert d.doit(deep=False).args == (a, 2*S.One)
+    assert d.doit().func == Mul
+    assert d.doit().args == (4*S.One, Pow(x,2))
+
+
+def test_Add_Mul_Expr_args():
+    nonexpr = [Basic(), Poly(x, x), FiniteSet(x)]
+    for typ in [Add, Mul]:
+        for obj in nonexpr:
+            # The cache can mess with the stacklevel check
+            with warns(SymPyDeprecationWarning, test_stacklevel=False):
+                typ(obj, 1)
+
+
+def test_Add_as_coeff_mul():
+    # issue 5524.  These should all be (1, self)
+    assert (x + 1).as_coeff_mul() == (1, (x + 1,))
+    assert (x + 2).as_coeff_mul() == (1, (x + 2,))
+    assert (x + 3).as_coeff_mul() == (1, (x + 3,))
+
+    assert (x - 1).as_coeff_mul() == (1, (x - 1,))
+    assert (x - 2).as_coeff_mul() == (1, (x - 2,))
+    assert (x - 3).as_coeff_mul() == (1, (x - 3,))
+
+    n = Symbol('n', integer=True)
+    assert (n + 1).as_coeff_mul() == (1, (n + 1,))
+    assert (n + 2).as_coeff_mul() == (1, (n + 2,))
+    assert (n + 3).as_coeff_mul() == (1, (n + 3,))
+
+    assert (n - 1).as_coeff_mul() == (1, (n - 1,))
+    assert (n - 2).as_coeff_mul() == (1, (n - 2,))
+    assert (n - 3).as_coeff_mul() == (1, (n - 3,))
+
+
+def test_Pow_as_coeff_mul_doesnt_expand():
+    assert exp(x + y).as_coeff_mul() == (1, (exp(x + y),))
+    assert exp(x + exp(x + y)) != exp(x + exp(x)*exp(y))
+
+def test_issue_24751():
+    expr = Add(-2, -3, evaluate=False)
+    expr1 = Add(-1, expr, evaluate=False)
+    assert int(expr1) == int((-3 - 2) - 1)
+
+
+def test_issue_3514_18626():
+    assert sqrt(S.Half) * sqrt(6) == 2 * sqrt(3)/2
+    assert S.Half*sqrt(6)*sqrt(2) == sqrt(3)
+    assert sqrt(6)/2*sqrt(2) == sqrt(3)
+    assert sqrt(6)*sqrt(2)/2 == sqrt(3)
+    assert sqrt(8)**Rational(2, 3) == 2
+
+
+def test_make_args():
+    assert Add.make_args(x) == (x,)
+    assert Mul.make_args(x) == (x,)
+
+    assert Add.make_args(x*y*z) == (x*y*z,)
+    assert Mul.make_args(x*y*z) == (x*y*z).args
+
+    assert Add.make_args(x + y + z) == (x + y + z).args
+    assert Mul.make_args(x + y + z) == (x + y + z,)
+
+    assert Add.make_args((x + y)**z) == ((x + y)**z,)
+    assert Mul.make_args((x + y)**z) == ((x + y)**z,)
+
+
+def test_issue_5126():
+    assert (-2)**x*(-3)**x != 6**x
+    i = Symbol('i', integer=1)
+    assert (-2)**i*(-3)**i == 6**i
+
+
+def test_Rational_as_content_primitive():
+    c, p = S.One, S.Zero
+    assert (c*p).as_content_primitive() == (c, p)
+    c, p = S.Half, S.One
+    assert (c*p).as_content_primitive() == (c, p)
+
+
+def test_Add_as_content_primitive():
+    assert (x + 2).as_content_primitive() == (1, x + 2)
+
+    assert (3*x + 2).as_content_primitive() == (1, 3*x + 2)
+    assert (3*x + 3).as_content_primitive() == (3, x + 1)
+    assert (3*x + 6).as_content_primitive() == (3, x + 2)
+
+    assert (3*x + 2*y).as_content_primitive() == (1, 3*x + 2*y)
+    assert (3*x + 3*y).as_content_primitive() == (3, x + y)
+    assert (3*x + 6*y).as_content_primitive() == (3, x + 2*y)
+
+    assert (3/x + 2*x*y*z**2).as_content_primitive() == (1, 3/x + 2*x*y*z**2)
+    assert (3/x + 3*x*y*z**2).as_content_primitive() == (3, 1/x + x*y*z**2)
+    assert (3/x + 6*x*y*z**2).as_content_primitive() == (3, 1/x + 2*x*y*z**2)
+
+    assert (2*x/3 + 4*y/9).as_content_primitive() == \
+        (Rational(2, 9), 3*x + 2*y)
+    assert (2*x/3 + 2.5*y).as_content_primitive() == \
+        (Rational(1, 3), 2*x + 7.5*y)
+
+    # the coefficient may sort to a position other than 0
+    p = 3 + x + y
+    assert (2*p).expand().as_content_primitive() == (2, p)
+    assert (2.0*p).expand().as_content_primitive() == (1, 2.*p)
+    p *= -1
+    assert (2*p).expand().as_content_primitive() == (2, p)
+
+
+def test_Mul_as_content_primitive():
+    assert (2*x).as_content_primitive() == (2, x)
+    assert (x*(2 + 2*x)).as_content_primitive() == (2, x*(1 + x))
+    assert (x*(2 + 2*y)*(3*x + 3)**2).as_content_primitive() == \
+        (18, x*(1 + y)*(x + 1)**2)
+    assert ((2 + 2*x)**2*(3 + 6*x) + S.Half).as_content_primitive() == \
+        (S.Half, 24*(x + 1)**2*(2*x + 1) + 1)
+
+
+def test_Pow_as_content_primitive():
+    assert (x**y).as_content_primitive() == (1, x**y)
+    assert ((2*x + 2)**y).as_content_primitive() == \
+        (1, (Mul(2, (x + 1), evaluate=False))**y)
+    assert ((2*x + 2)**3).as_content_primitive() == (8, (x + 1)**3)
+
+
+def test_issue_5460():
+    u = Mul(2, (1 + x), evaluate=False)
+    assert (2 + u).args == (2, u)
+
+
+def test_product_irrational():
+    assert (I*pi).is_irrational is False
+    # The following used to be deduced from the above bug:
+    assert (I*pi).is_positive is False
+
+
+def test_issue_5919():
+    assert (x/(y*(1 + y))).expand() == x/(y**2 + y)
+
+
+def test_Mod():
+    assert Mod(x, 1).func is Mod
+    assert pi % pi is S.Zero
+    assert Mod(5, 3) == 2
+    assert Mod(-5, 3) == 1
+    assert Mod(5, -3) == -1
+    assert Mod(-5, -3) == -2
+    assert type(Mod(3.2, 2, evaluate=False)) == Mod
+    assert 5 % x == Mod(5, x)
+    assert x % 5 == Mod(x, 5)
+    assert x % y == Mod(x, y)
+    assert (x % y).subs({x: 5, y: 3}) == 2
+    assert Mod(nan, 1) is nan
+    assert Mod(1, nan) is nan
+    assert Mod(nan, nan) is nan
+
+    assert Mod(0, x) == 0
+    with raises(ZeroDivisionError):
+        Mod(x, 0)
+
+    k = Symbol('k', integer=True)
+    m = Symbol('m', integer=True, positive=True)
+    assert (x**m % x).func is Mod
+    assert (k**(-m) % k).func is Mod
+    assert k**m % k == 0
+    assert (-2*k)**m % k == 0
+
+    # Float handling
+    point3 = Float(3.3) % 1
+    assert (x - 3.3) % 1 == Mod(1.*x + 1 - point3, 1)
+    assert Mod(-3.3, 1) == 1 - point3
+    assert Mod(0.7, 1) == Float(0.7)
+    e = Mod(1.3, 1)
+    assert comp(e, .3) and e.is_Float
+    e = Mod(1.3, .7)
+    assert comp(e, .6) and e.is_Float
+    e = Mod(1.3, Rational(7, 10))
+    assert comp(e, .6) and e.is_Float
+    e = Mod(Rational(13, 10), 0.7)
+    assert comp(e, .6) and e.is_Float
+    e = Mod(Rational(13, 10), Rational(7, 10))
+    assert comp(e, .6) and e.is_Rational
+
+    # check that sign is right
+    r2 = sqrt(2)
+    r3 = sqrt(3)
+    for i in [-r3, -r2, r2, r3]:
+        for j in [-r3, -r2, r2, r3]:
+            assert verify_numerically(i % j, i.n() % j.n())
+    for _x in range(4):
+        for _y in range(9):
+            reps = [(x, _x), (y, _y)]
+            assert Mod(3*x + y, 9).subs(reps) == (3*_x + _y) % 9
+
+    # denesting
+    t = Symbol('t', real=True)
+    assert Mod(Mod(x, t), t) == Mod(x, t)
+    assert Mod(-Mod(x, t), t) == Mod(-x, t)
+    assert Mod(Mod(x, 2*t), t) == Mod(x, t)
+    assert Mod(-Mod(x, 2*t), t) == Mod(-x, t)
+    assert Mod(Mod(x, t), 2*t) == Mod(x, t)
+    assert Mod(-Mod(x, t), -2*t) == -Mod(x, t)
+    for i in [-4, -2, 2, 4]:
+        for j in [-4, -2, 2, 4]:
+            for k in range(4):
+                assert Mod(Mod(x, i), j).subs({x: k}) == (k % i) % j
+                assert Mod(-Mod(x, i), j).subs({x: k}) == -(k % i) % j
+
+    # known difference
+    assert Mod(5*sqrt(2), sqrt(5)) == 5*sqrt(2) - 3*sqrt(5)
+    p = symbols('p', positive=True)
+    assert Mod(2, p + 3) == 2
+    assert Mod(-2, p + 3) == p + 1
+    assert Mod(2, -p - 3) == -p - 1
+    assert Mod(-2, -p - 3) == -2
+    assert Mod(p + 5, p + 3) == 2
+    assert Mod(-p - 5, p + 3) == p + 1
+    assert Mod(p + 5, -p - 3) == -p - 1
+    assert Mod(-p - 5, -p - 3) == -2
+    assert Mod(p + 1, p - 1).func is Mod
+
+    # handling sums
+    assert (x + 3) % 1 == Mod(x, 1)
+    assert (x + 3.0) % 1 == Mod(1.*x, 1)
+    assert (x - S(33)/10) % 1 == Mod(x + S(7)/10, 1)
+
+    a = Mod(.6*x + y, .3*y)
+    b = Mod(0.1*y + 0.6*x, 0.3*y)
+    # Test that a, b are equal, with 1e-14 accuracy in coefficients
+    eps = 1e-14
+    assert abs((a.args[0] - b.args[0]).subs({x: 1, y: 1})) < eps
+    assert abs((a.args[1] - b.args[1]).subs({x: 1, y: 1})) < eps
+
+    assert (x + 1) % x == 1 % x
+    assert (x + y) % x == y % x
+    assert (x + y + 2) % x == (y + 2) % x
+    assert (a + 3*x + 1) % (2*x) == Mod(a + x + 1, 2*x)
+    assert (12*x + 18*y) % (3*x) == 3*Mod(6*y, x)
+
+    # gcd extraction
+    assert (-3*x) % (-2*y) == -Mod(3*x, 2*y)
+    assert (.6*pi) % (.3*x*pi) == 0.3*pi*Mod(2, x)
+    assert (.6*pi) % (.31*x*pi) == pi*Mod(0.6, 0.31*x)
+    assert (6*pi) % (.3*x*pi) == 0.3*pi*Mod(20, x)
+    assert (6*pi) % (.31*x*pi) == pi*Mod(6, 0.31*x)
+    assert (6*pi) % (.42*x*pi) == pi*Mod(6, 0.42*x)
+    assert (12*x) % (2*y) == 2*Mod(6*x, y)
+    assert (12*x) % (3*5*y) == 3*Mod(4*x, 5*y)
+    assert (12*x) % (15*x*y) == 3*x*Mod(4, 5*y)
+    assert (-2*pi) % (3*pi) == pi
+    assert (2*x + 2) % (x + 1) == 0
+    assert (x*(x + 1)) % (x + 1) == (x + 1)*Mod(x, 1)
+    assert Mod(5.0*x, 0.1*y) == 0.1*Mod(50*x, y)
+    i = Symbol('i', integer=True)
+    assert (3*i*x) % (2*i*y) == i*Mod(3*x, 2*y)
+    assert Mod(4*i, 4) == 0
+
+    # issue 8677
+    n = Symbol('n', integer=True, positive=True)
+    assert factorial(n) % n == 0
+    assert factorial(n + 2) % n == 0
+    assert (factorial(n + 4) % (n + 5)).func is Mod
+
+    # Wilson's theorem
+    assert factorial(18042, evaluate=False) % 18043 == 18042
+    p = Symbol('n', prime=True)
+    assert factorial(p - 1) % p == p - 1
+    assert factorial(p - 1) % -p == -1
+    assert (factorial(3, evaluate=False) % 4).doit() == 2
+    n = Symbol('n', composite=True, odd=True)
+    assert factorial(n - 1) % n == 0
+
+    # symbolic with known parity
+    n = Symbol('n', even=True)
+    assert Mod(n, 2) == 0
+    n = Symbol('n', odd=True)
+    assert Mod(n, 2) == 1
+
+    # issue 10963
+    assert (x**6000%400).args[1] == 400
+
+    #issue 13543
+    assert Mod(Mod(x + 1, 2) + 1, 2) == Mod(x, 2)
+
+    x1 = Symbol('x1', integer=True)
+    assert Mod(Mod(x1 + 2, 4)*(x1 + 4), 4) == Mod(x1*(x1 + 2), 4)
+    assert Mod(Mod(x1 + 2, 4)*4, 4) == 0
+
+    # issue 15493
+    i, j = symbols('i j', integer=True, positive=True)
+    assert Mod(3*i, 2) == Mod(i, 2)
+    assert Mod(8*i/j, 4) == 4*Mod(2*i/j, 1)
+    assert Mod(8*i, 4) == 0
+
+    # rewrite
+    assert Mod(x, y).rewrite(floor) == x - y*floor(x/y)
+    assert ((x - Mod(x, y))/y).rewrite(floor) == floor(x/y)
+
+    # issue 21373
+    from sympy.functions.elementary.hyperbolic import sinh
+    from sympy.functions.elementary.piecewise import Piecewise
+
+    x_r, y_r = symbols('x_r y_r', real=True)
+    assert (Piecewise((x_r, y_r > x_r), (y_r, True)) / z) % 1
+    expr = exp(sinh(Piecewise((x_r, y_r > x_r), (y_r, True)) / z))
+    expr.subs({1: 1.0})
+    sinh(Piecewise((x_r, y_r > x_r), (y_r, True)) * z ** -1.0).is_zero
+
+    # issue 24215
+    from sympy.abc import phi
+    assert Mod(4.0*Mod(phi, 1) , 2) == 2.0*(Mod(2*(Mod(phi, 1)), 1))
+
+    xi = symbols('x', integer=True)
+    assert unchanged(Mod, xi, 2)
+    assert Mod(3*xi, 2) == Mod(xi, 2)
+    assert unchanged(Mod, 3*x, 2)
+
+
+def test_Mod_Pow():
+    # modular exponentiation
+    assert isinstance(Mod(Pow(2, 2, evaluate=False), 3), Integer)
+
+    assert Mod(Pow(4, 13, evaluate=False), 497) == Mod(Pow(4, 13), 497)
+    assert Mod(Pow(2, 10000000000, evaluate=False), 3) == 1
+    assert Mod(Pow(32131231232, 9**10**6, evaluate=False),10**12) == \
+        pow(32131231232,9**10**6,10**12)
+    assert Mod(Pow(33284959323, 123**999, evaluate=False),11**13) == \
+        pow(33284959323,123**999,11**13)
+    assert Mod(Pow(78789849597, 333**555, evaluate=False),12**9) == \
+        pow(78789849597,333**555,12**9)
+
+    # modular nested exponentiation
+    expr = Pow(2, 2, evaluate=False)
+    expr = Pow(2, expr, evaluate=False)
+    assert Mod(expr, 3**10) == 16
+    expr = Pow(2, expr, evaluate=False)
+    assert Mod(expr, 3**10) == 6487
+    expr = Pow(2, expr, evaluate=False)
+    assert Mod(expr, 3**10) == 32191
+    expr = Pow(2, expr, evaluate=False)
+    assert Mod(expr, 3**10) == 18016
+    expr = Pow(2, expr, evaluate=False)
+    assert Mod(expr, 3**10) == 5137
+
+    expr = Pow(2, 2, evaluate=False)
+    expr = Pow(expr, 2, evaluate=False)
+    assert Mod(expr, 3**10) == 16
+    expr = Pow(expr, 2, evaluate=False)
+    assert Mod(expr, 3**10) == 256
+    expr = Pow(expr, 2, evaluate=False)
+    assert Mod(expr, 3**10) == 6487
+    expr = Pow(expr, 2, evaluate=False)
+    assert Mod(expr, 3**10) == 38281
+    expr = Pow(expr, 2, evaluate=False)
+    assert Mod(expr, 3**10) == 15928
+
+    expr = Pow(2, 2, evaluate=False)
+    expr = Pow(expr, expr, evaluate=False)
+    assert Mod(expr, 3**10) == 256
+    expr = Pow(expr, expr, evaluate=False)
+    assert Mod(expr, 3**10) == 9229
+    expr = Pow(expr, expr, evaluate=False)
+    assert Mod(expr, 3**10) == 25708
+    expr = Pow(expr, expr, evaluate=False)
+    assert Mod(expr, 3**10) == 26608
+    expr = Pow(expr, expr, evaluate=False)
+    # XXX This used to fail in a nondeterministic way because of overflow
+    # error.
+    assert Mod(expr, 3**10) == 1966
+
+
+def test_Mod_is_integer():
+    p = Symbol('p', integer=True)
+    q1 = Symbol('q1', integer=True)
+    q2 = Symbol('q2', integer=True, nonzero=True)
+    assert Mod(x, y).is_integer is None
+    assert Mod(p, q1).is_integer is None
+    assert Mod(x, q2).is_integer is None
+    assert Mod(p, q2).is_integer
+
+
+def test_Mod_is_nonposneg():
+    n = Symbol('n', integer=True)
+    k = Symbol('k', integer=True, positive=True)
+    assert (n%3).is_nonnegative
+    assert Mod(n, -3).is_nonpositive
+    assert Mod(n, k).is_nonnegative
+    assert Mod(n, -k).is_nonpositive
+    assert Mod(k, n).is_nonnegative is None
+
+
+def test_issue_6001():
+    A = Symbol("A", commutative=False)
+    eq = A + A**2
+    # it doesn't matter whether it's True or False; they should
+    # just all be the same
+    assert (
+        eq.is_commutative ==
+        (eq + 1).is_commutative ==
+        (A + 1).is_commutative)
+
+    B = Symbol("B", commutative=False)
+    # Although commutative terms could cancel we return True
+    # meaning "there are non-commutative symbols; aftersubstitution
+    # that definition can change, e.g. (A*B).subs(B,A**-1) -> 1
+    assert (sqrt(2)*A).is_commutative is False
+    assert (sqrt(2)*A*B).is_commutative is False
+
+
+def test_polar():
+    from sympy.functions.elementary.complexes import polar_lift
+    p = Symbol('p', polar=True)
+    x = Symbol('x')
+    assert p.is_polar
+    assert x.is_polar is None
+    assert S.One.is_polar is None
+    assert (p**x).is_polar is True
+    assert (x**p).is_polar is None
+    assert ((2*p)**x).is_polar is True
+    assert (2*p).is_polar is True
+    assert (-2*p).is_polar is not True
+    assert (polar_lift(-2)*p).is_polar is True
+
+    q = Symbol('q', polar=True)
+    assert (p*q)**2 == p**2 * q**2
+    assert (2*q)**2 == 4 * q**2
+    assert ((p*q)**x).expand() == p**x * q**x
+
+
+def test_issue_6040():
+    a, b = Pow(1, 2, evaluate=False), S.One
+    assert a != b
+    assert b != a
+    assert not (a == b)
+    assert not (b == a)
+
+
+def test_issue_6082():
+    # Comparison is symmetric
+    assert Basic.compare(Max(x, 1), Max(x, 2)) == \
+      - Basic.compare(Max(x, 2), Max(x, 1))
+    # Equal expressions compare equal
+    assert Basic.compare(Max(x, 1), Max(x, 1)) == 0
+    # Basic subtypes (such as Max) compare different than standard types
+    assert Basic.compare(Max(1, x), frozenset((1, x))) != 0
+
+
+def test_issue_6077():
+    assert x**2.0/x == x**1.0
+    assert x/x**2.0 == x**-1.0
+    assert x*x**2.0 == x**3.0
+    assert x**1.5*x**2.5 == x**4.0
+
+    assert 2**(2.0*x)/2**x == 2**(1.0*x)
+    assert 2**x/2**(2.0*x) == 2**(-1.0*x)
+    assert 2**x*2**(2.0*x) == 2**(3.0*x)
+    assert 2**(1.5*x)*2**(2.5*x) == 2**(4.0*x)
+
+
+def test_mul_flatten_oo():
+    p = symbols('p', positive=True)
+    n, m = symbols('n,m', negative=True)
+    x_im = symbols('x_im', imaginary=True)
+    assert n*oo is -oo
+    assert n*m*oo is oo
+    assert p*oo is oo
+    assert x_im*oo != I*oo  # i could be +/- 3*I -> +/-oo
+
+
+def test_add_flatten():
+    # see https://github.com/sympy/sympy/issues/2633#issuecomment-29545524
+    a = oo + I*oo
+    b = oo - I*oo
+    assert a + b is nan
+    assert a - b is nan
+    # FIXME: This evaluates as:
+    #   >>> 1/a
+    #   0*(oo + oo*I)
+    # which should not simplify to 0. Should be fixed in Pow.eval
+    #assert (1/a).simplify() == (1/b).simplify() == 0
+
+    a = Pow(2, 3, evaluate=False)
+    assert a + a == 16
+
+
+def test_issue_5160_6087_6089_6090():
+    # issue 6087
+    assert ((-2*x*y**y)**3.2).n(2) == (2**3.2*(-x*y**y)**3.2).n(2)
+    # issue 6089
+    A, B, C = symbols('A,B,C', commutative=False)
+    assert (2.*B*C)**3 == 8.0*(B*C)**3
+    assert (-2.*B*C)**3 == -8.0*(B*C)**3
+    assert (-2*B*C)**2 == 4*(B*C)**2
+    # issue 5160
+    assert sqrt(-1.0*x) == 1.0*sqrt(-x)
+    assert sqrt(1.0*x) == 1.0*sqrt(x)
+    # issue 6090
+    assert (-2*x*y*A*B)**2 == 4*x**2*y**2*(A*B)**2
+
+
+def test_float_int_round():
+    assert int(float(sqrt(10))) == int(sqrt(10))
+    assert int(pi**1000) % 10 == 2
+    assert int(Float('1.123456789012345678901234567890e20', '')) == \
+        int(112345678901234567890)
+    assert int(Float('1.123456789012345678901234567890e25', '')) == \
+        int(11234567890123456789012345)
+    # decimal forces float so it's not an exact integer ending in 000000
+    assert int(Float('1.123456789012345678901234567890e35', '')) == \
+        112345678901234567890123456789000192
+    assert int(Float('123456789012345678901234567890e5', '')) == \
+        12345678901234567890123456789000000
+    assert Integer(Float('1.123456789012345678901234567890e20', '')) == \
+        112345678901234567890
+    assert Integer(Float('1.123456789012345678901234567890e25', '')) == \
+        11234567890123456789012345
+    # decimal forces float so it's not an exact integer ending in 000000
+    assert Integer(Float('1.123456789012345678901234567890e35', '')) == \
+        112345678901234567890123456789000192
+    assert Integer(Float('123456789012345678901234567890e5', '')) == \
+        12345678901234567890123456789000000
+    assert same_and_same_prec(Float('123000e-2',''), Float('1230.00', ''))
+    assert same_and_same_prec(Float('123000e2',''), Float('12300000', ''))
+
+    assert int(1 + Rational('.9999999999999999999999999')) == 1
+    assert int(pi/1e20) == 0
+    assert int(1 + pi/1e20) == 1
+    assert int(Add(1.2, -2, evaluate=False)) == int(1.2 - 2)
+    assert int(Add(1.2, +2, evaluate=False)) == int(1.2 + 2)
+    assert int(Add(1 + Float('.99999999999999999', ''), evaluate=False)) == 1
+    raises(TypeError, lambda: float(x))
+    raises(TypeError, lambda: float(sqrt(-1)))
+
+    assert int(12345678901234567890 + cos(1)**2 + sin(1)**2) == \
+        12345678901234567891
+
+
+def test_issue_6611a():
+    assert Mul.flatten([3**Rational(1, 3),
+        Pow(-Rational(1, 9), Rational(2, 3), evaluate=False)]) == \
+        ([Rational(1, 3), (-1)**Rational(2, 3)], [], None)
+
+
+def test_denest_add_mul():
+    # when working with evaluated expressions make sure they denest
+    eq = x + 1
+    eq = Add(eq, 2, evaluate=False)
+    eq = Add(eq, 2, evaluate=False)
+    assert Add(*eq.args) == x + 5
+    eq = x*2
+    eq = Mul(eq, 2, evaluate=False)
+    eq = Mul(eq, 2, evaluate=False)
+    assert Mul(*eq.args) == 8*x
+    # but don't let them denest unnecessarily
+    eq = Mul(-2, x - 2, evaluate=False)
+    assert 2*eq == Mul(-4, x - 2, evaluate=False)
+    assert -eq == Mul(2, x - 2, evaluate=False)
+
+
+def test_mul_coeff():
+    # It is important that all Numbers be removed from the seq;
+    # This can be tricky when powers combine to produce those numbers
+    p = exp(I*pi/3)
+    assert p**2*x*p*y*p*x*p**2 == x**2*y
+
+
+def test_mul_zero_detection():
+    nz = Dummy(real=True, zero=False)
+    r = Dummy(extended_real=True)
+    c = Dummy(real=False, complex=True)
+    c2 = Dummy(real=False, complex=True)
+    i = Dummy(imaginary=True)
+    e = nz*r*c
+    assert e.is_imaginary is None
+    assert e.is_extended_real is None
+    e = nz*c
+    assert e.is_imaginary is None
+    assert e.is_extended_real is False
+    e = nz*i*c
+    assert e.is_imaginary is False
+    assert e.is_extended_real is None
+    # check for more than one complex; it is important to use
+    # uniquely named Symbols to ensure that two factors appear
+    # e.g. if the symbols have the same name they just become
+    # a single factor, a power.
+    e = nz*i*c*c2
+    assert e.is_imaginary is None
+    assert e.is_extended_real is None
+
+    # _eval_is_extended_real and _eval_is_zero both employ trapping of the
+    # zero value so args should be tested in both directions and
+    # TO AVOID GETTING THE CACHED RESULT, Dummy MUST BE USED
+
+    # real is unknown
+    def test(z, b, e):
+        if z.is_zero and b.is_finite:
+            assert e.is_extended_real and e.is_zero
+        else:
+            assert e.is_extended_real is None
+            if b.is_finite:
+                if z.is_zero:
+                    assert e.is_zero
+                else:
+                    assert e.is_zero is None
+            elif b.is_finite is False:
+                if z.is_zero is None:
+                    assert e.is_zero is None
+                else:
+                    assert e.is_zero is False
+
+
+    for iz, ib in product(*[[True, False, None]]*2):
+        z = Dummy('z', nonzero=iz)
+        b = Dummy('f', finite=ib)
+        e = Mul(z, b, evaluate=False)
+        test(z, b, e)
+        z = Dummy('nz', nonzero=iz)
+        b = Dummy('f', finite=ib)
+        e = Mul(b, z, evaluate=False)
+        test(z, b, e)
+
+    # real is True
+    def test(z, b, e):
+        if z.is_zero and not b.is_finite:
+            assert e.is_extended_real is None
+        else:
+            assert e.is_extended_real is True
+
+    for iz, ib in product(*[[True, False, None]]*2):
+        z = Dummy('z', nonzero=iz, extended_real=True)
+        b = Dummy('b', finite=ib, extended_real=True)
+        e = Mul(z, b, evaluate=False)
+        test(z, b, e)
+        z = Dummy('z', nonzero=iz, extended_real=True)
+        b = Dummy('b', finite=ib, extended_real=True)
+        e = Mul(b, z, evaluate=False)
+        test(z, b, e)
+
+
+def test_Mul_with_zero_infinite():
+    zer = Dummy(zero=True)
+    inf = Dummy(finite=False)
+
+    e = Mul(zer, inf, evaluate=False)
+    assert e.is_extended_positive is None
+    assert e.is_hermitian is None
+
+    e = Mul(inf, zer, evaluate=False)
+    assert e.is_extended_positive is None
+    assert e.is_hermitian is None
+
+
+def test_Mul_does_not_cancel_infinities():
+    a, b = symbols('a b')
+    assert ((zoo + 3*a)/(3*a + zoo)) is nan
+    assert ((b - oo)/(b - oo)) is nan
+    # issue 13904
+    expr = (1/(a+b) + 1/(a-b))/(1/(a+b) - 1/(a-b))
+    assert expr.subs(b, a) is nan
+
+
+def test_Mul_does_not_distribute_infinity():
+    a, b = symbols('a b')
+    assert ((1 + I)*oo).is_Mul
+    assert ((a + b)*(-oo)).is_Mul
+    assert ((a + 1)*zoo).is_Mul
+    assert ((1 + I)*oo).is_finite is False
+    z = (1 + I)*oo
+    assert ((1 - I)*z).expand() is oo
+
+
+def test_issue_8247_8354():
+    from sympy.functions.elementary.trigonometric import tan
+    z = sqrt(1 + sqrt(3)) + sqrt(3 + 3*sqrt(3)) - sqrt(10 + 6*sqrt(3))
+    assert z.is_positive is False  # it's 0
+    z = S('''-2**(1/3)*(3*sqrt(93) + 29)**2 - 4*(3*sqrt(93) + 29)**(4/3) +
+        12*sqrt(93)*(3*sqrt(93) + 29)**(1/3) + 116*(3*sqrt(93) + 29)**(1/3) +
+        174*2**(1/3)*sqrt(93) + 1678*2**(1/3)''')
+    assert z.is_positive is False  # it's 0
+    z = 2*(-3*tan(19*pi/90) + sqrt(3))*cos(11*pi/90)*cos(19*pi/90) - \
+        sqrt(3)*(-3 + 4*cos(19*pi/90)**2)
+    assert z.is_positive is not True  # it's zero and it shouldn't hang
+    z = S('''9*(3*sqrt(93) + 29)**(2/3)*((3*sqrt(93) +
+        29)**(1/3)*(-2**(2/3)*(3*sqrt(93) + 29)**(1/3) - 2) - 2*2**(1/3))**3 +
+        72*(3*sqrt(93) + 29)**(2/3)*(81*sqrt(93) + 783) + (162*sqrt(93) +
+        1566)*((3*sqrt(93) + 29)**(1/3)*(-2**(2/3)*(3*sqrt(93) + 29)**(1/3) -
+        2) - 2*2**(1/3))**2''')
+    assert z.is_positive is False  # it's 0 (and a single _mexpand isn't enough)
+
+
+def test_Add_is_zero():
+    x, y = symbols('x y', zero=True)
+    assert (x + y).is_zero
+
+    # Issue 15873
+    e = -2*I + (1 + I)**2
+    assert e.is_zero is None
+
+
+def test_issue_14392():
+    assert (sin(zoo)**2).as_real_imag() == (nan, nan)
+
+
+def test_divmod():
+    assert divmod(x, y) == (x//y, x % y)
+    assert divmod(x, 3) == (x//3, x % 3)
+    assert divmod(3, x) == (3//x, 3 % x)
+
+
+def test__neg__():
+    assert -(x*y) == -x*y
+    assert -(-x*y) == x*y
+    assert -(1.*x) == -1.*x
+    assert -(-1.*x) == 1.*x
+    assert -(2.*x) == -2.*x
+    assert -(-2.*x) == 2.*x
+    with distribute(False):
+        eq = -(x + y)
+        assert eq.is_Mul and eq.args == (-1, x + y)
+    with evaluate(False):
+        eq = -(x + y)
+        assert eq.is_Mul and eq.args == (-1, x + y)
+
+
+def test_issue_18507():
+    assert Mul(zoo, zoo, 0) is nan
+
+
+def test_issue_17130():
+    e = Add(b, -b, I, -I, evaluate=False)
+    assert e.is_zero is None # ideally this would be True
+
+
+def test_issue_21034():
+    e = -I*log((re(asin(5)) + I*im(asin(5)))/sqrt(re(asin(5))**2 + im(asin(5))**2))/pi
+    assert e.round(2)
+
+
+def test_issue_22021():
+    from sympy.calculus.accumulationbounds import AccumBounds
+    # these objects are special cases in Mul
+    from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensor_heads
+    L = TensorIndexType("L")
+    i = tensor_indices("i", L)
+    A, B = tensor_heads("A B", [L])
+    e = A(i) + B(i)
+    assert -e == -1*e
+    e = zoo + x
+    assert -e == -1*e
+    a = AccumBounds(1, 2)
+    e = a + x
+    assert -e == -1*e
+    for args in permutations((zoo, a, x)):
+        e = Add(*args, evaluate=False)
+        assert -e == -1*e
+    assert 2*Add(1, x, x, evaluate=False) == 4*x + 2
+
+
+def test_issue_22244():
+    assert -(zoo*x) == zoo*x
+
+
+def test_issue_22453():
+    from sympy.utilities.iterables import cartes
+    e = Symbol('e', extended_positive=True)
+    for a, b in cartes(*[[oo, -oo, 3]]*2):
+        if a == b == 3:
+            continue
+        i = a + I*b
+        assert i**(1 + e) is S.ComplexInfinity
+        assert i**-e is S.Zero
+        assert unchanged(Pow, i, e)
+    assert 1/(oo + I*oo) is S.Zero
+    r, i = [Dummy(infinite=True, extended_real=True) for _ in range(2)]
+    assert 1/(r + I*i) is S.Zero
+    assert 1/(3 + I*i) is S.Zero
+    assert 1/(r + I*3) is S.Zero
+
+
+def test_issue_22613():
+    assert (0**(x - 2)).as_content_primitive() == (1, 0**(x - 2))
+    assert (0**(x + 2)).as_content_primitive() == (1, 0**(x + 2))
+
+
+def test_issue_25176():
+    assert sqrt(-4*3**(S(3)/4)*I/3) == 2*3**(S(7)/8)*sqrt(-I)/3

.venv/lib/python3.11/site-packages/sympy/core/tests/test_assumptions.py

@@ -0,0 +1,1335 @@
+from sympy.core.mod import Mod
+from sympy.core.numbers import (I, oo, pi)
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (asin, sin)
+from sympy.simplify.simplify import simplify
+from sympy.core import Symbol, S, Rational, Integer, Dummy, Wild, Pow
+from sympy.core.assumptions import (assumptions, check_assumptions,
+    failing_assumptions, common_assumptions, _generate_assumption_rules,
+    _load_pre_generated_assumption_rules)
+from sympy.core.facts import InconsistentAssumptions
+from sympy.core.random import seed
+from sympy.combinatorics import Permutation
+from sympy.combinatorics.perm_groups import PermutationGroup
+
+from sympy.testing.pytest import raises, XFAIL
+
+
+def test_symbol_unset():
+    x = Symbol('x', real=True, integer=True)
+    assert x.is_real is True
+    assert x.is_integer is True
+    assert x.is_imaginary is False
+    assert x.is_noninteger is False
+    assert x.is_number is False
+
+
+def test_zero():
+    z = Integer(0)
+    assert z.is_commutative is True
+    assert z.is_integer is True
+    assert z.is_rational is True
+    assert z.is_algebraic is True
+    assert z.is_transcendental is False
+    assert z.is_real is True
+    assert z.is_complex is True
+    assert z.is_noninteger is False
+    assert z.is_irrational is False
+    assert z.is_imaginary is False
+    assert z.is_positive is False
+    assert z.is_negative is False
+    assert z.is_nonpositive is True
+    assert z.is_nonnegative is True
+    assert z.is_even is True
+    assert z.is_odd is False
+    assert z.is_finite is True
+    assert z.is_infinite is False
+    assert z.is_comparable is True
+    assert z.is_prime is False
+    assert z.is_composite is False
+    assert z.is_number is True
+
+
+def test_one():
+    z = Integer(1)
+    assert z.is_commutative is True
+    assert z.is_integer is True
+    assert z.is_rational is True
+    assert z.is_algebraic is True
+    assert z.is_transcendental is False
+    assert z.is_real is True
+    assert z.is_complex is True
+    assert z.is_noninteger is False
+    assert z.is_irrational is False
+    assert z.is_imaginary is False
+    assert z.is_positive is True
+    assert z.is_negative is False
+    assert z.is_nonpositive is False
+    assert z.is_nonnegative is True
+    assert z.is_even is False
+    assert z.is_odd is True
+    assert z.is_finite is True
+    assert z.is_infinite is False
+    assert z.is_comparable is True
+    assert z.is_prime is False
+    assert z.is_number is True
+    assert z.is_composite is False  # issue 8807
+
+
+def test_negativeone():
+    z = Integer(-1)
+    assert z.is_commutative is True
+    assert z.is_integer is True
+    assert z.is_rational is True
+    assert z.is_algebraic is True
+    assert z.is_transcendental is False
+    assert z.is_real is True
+    assert z.is_complex is True
+    assert z.is_noninteger is False
+    assert z.is_irrational is False
+    assert z.is_imaginary is False
+    assert z.is_positive is False
+    assert z.is_negative is True
+    assert z.is_nonpositive is True
+    assert z.is_nonnegative is False
+    assert z.is_even is False
+    assert z.is_odd is True
+    assert z.is_finite is True
+    assert z.is_infinite is False
+    assert z.is_comparable is True
+    assert z.is_prime is False
+    assert z.is_composite is False
+    assert z.is_number is True
+
+
+def test_infinity():
+    oo = S.Infinity
+
+    assert oo.is_commutative is True
+    assert oo.is_integer is False
+    assert oo.is_rational is False
+    assert oo.is_algebraic is False
+    assert oo.is_transcendental is False
+    assert oo.is_extended_real is True
+    assert oo.is_real is False
+    assert oo.is_complex is False
+    assert oo.is_noninteger is True
+    assert oo.is_irrational is False
+    assert oo.is_imaginary is False
+    assert oo.is_nonzero is False
+    assert oo.is_positive is False
+    assert oo.is_negative is False
+    assert oo.is_nonpositive is False
+    assert oo.is_nonnegative is False
+    assert oo.is_extended_nonzero is True
+    assert oo.is_extended_positive is True
+    assert oo.is_extended_negative is False
+    assert oo.is_extended_nonpositive is False
+    assert oo.is_extended_nonnegative is True
+    assert oo.is_even is False
+    assert oo.is_odd is False
+    assert oo.is_finite is False
+    assert oo.is_infinite is True
+    assert oo.is_comparable is True
+    assert oo.is_prime is False
+    assert oo.is_composite is False
+    assert oo.is_number is True
+
+
+def test_neg_infinity():
+    mm = S.NegativeInfinity
+
+    assert mm.is_commutative is True
+    assert mm.is_integer is False
+    assert mm.is_rational is False
+    assert mm.is_algebraic is False
+    assert mm.is_transcendental is False
+    assert mm.is_extended_real is True
+    assert mm.is_real is False
+    assert mm.is_complex is False
+    assert mm.is_noninteger is True
+    assert mm.is_irrational is False
+    assert mm.is_imaginary is False
+    assert mm.is_nonzero is False
+    assert mm.is_positive is False
+    assert mm.is_negative is False
+    assert mm.is_nonpositive is False
+    assert mm.is_nonnegative is False
+    assert mm.is_extended_nonzero is True
+    assert mm.is_extended_positive is False
+    assert mm.is_extended_negative is True
+    assert mm.is_extended_nonpositive is True
+    assert mm.is_extended_nonnegative is False
+    assert mm.is_even is False
+    assert mm.is_odd is False
+    assert mm.is_finite is False
+    assert mm.is_infinite is True
+    assert mm.is_comparable is True
+    assert mm.is_prime is False
+    assert mm.is_composite is False
+    assert mm.is_number is True
+
+
+def test_zoo():
+    zoo = S.ComplexInfinity
+    assert zoo.is_complex is False
+    assert zoo.is_real is False
+    assert zoo.is_prime is False
+
+
+def test_nan():
+    nan = S.NaN
+
+    assert nan.is_commutative is True
+    assert nan.is_integer is None
+    assert nan.is_rational is None
+    assert nan.is_algebraic is None
+    assert nan.is_transcendental is None
+    assert nan.is_real is None
+    assert nan.is_complex is None
+    assert nan.is_noninteger is None
+    assert nan.is_irrational is None
+    assert nan.is_imaginary is None
+    assert nan.is_positive is None
+    assert nan.is_negative is None
+    assert nan.is_nonpositive is None
+    assert nan.is_nonnegative is None
+    assert nan.is_even is None
+    assert nan.is_odd is None
+    assert nan.is_finite is None
+    assert nan.is_infinite is None
+    assert nan.is_comparable is False
+    assert nan.is_prime is None
+    assert nan.is_composite is None
+    assert nan.is_number is True
+
+
+def test_pos_rational():
+    r = Rational(3, 4)
+    assert r.is_commutative is True
+    assert r.is_integer is False
+    assert r.is_rational is True
+    assert r.is_algebraic is True
+    assert r.is_transcendental is False
+    assert r.is_real is True
+    assert r.is_complex is True
+    assert r.is_noninteger is True
+    assert r.is_irrational is False
+    assert r.is_imaginary is False
+    assert r.is_positive is True
+    assert r.is_negative is False
+    assert r.is_nonpositive is False
+    assert r.is_nonnegative is True
+    assert r.is_even is False
+    assert r.is_odd is False
+    assert r.is_finite is True
+    assert r.is_infinite is False
+    assert r.is_comparable is True
+    assert r.is_prime is False
+    assert r.is_composite is False
+
+    r = Rational(1, 4)
+    assert r.is_nonpositive is False
+    assert r.is_positive is True
+    assert r.is_negative is False
+    assert r.is_nonnegative is True
+    r = Rational(5, 4)
+    assert r.is_negative is False
+    assert r.is_positive is True
+    assert r.is_nonpositive is False
+    assert r.is_nonnegative is True
+    r = Rational(5, 3)
+    assert r.is_nonnegative is True
+    assert r.is_positive is True
+    assert r.is_negative is False
+    assert r.is_nonpositive is False
+
+
+def test_neg_rational():
+    r = Rational(-3, 4)
+    assert r.is_positive is False
+    assert r.is_nonpositive is True
+    assert r.is_negative is True
+    assert r.is_nonnegative is False
+    r = Rational(-1, 4)
+    assert r.is_nonpositive is True
+    assert r.is_positive is False
+    assert r.is_negative is True
+    assert r.is_nonnegative is False
+    r = Rational(-5, 4)
+    assert r.is_negative is True
+    assert r.is_positive is False
+    assert r.is_nonpositive is True
+    assert r.is_nonnegative is False
+    r = Rational(-5, 3)
+    assert r.is_nonnegative is False
+    assert r.is_positive is False
+    assert r.is_negative is True
+    assert r.is_nonpositive is True
+
+
+def test_pi():
+    z = S.Pi
+    assert z.is_commutative is True
+    assert z.is_integer is False
+    assert z.is_rational is False
+    assert z.is_algebraic is False
+    assert z.is_transcendental is True
+    assert z.is_real is True
+    assert z.is_complex is True
+    assert z.is_noninteger is True
+    assert z.is_irrational is True
+    assert z.is_imaginary is False
+    assert z.is_positive is True
+    assert z.is_negative is False
+    assert z.is_nonpositive is False
+    assert z.is_nonnegative is True
+    assert z.is_even is False
+    assert z.is_odd is False
+    assert z.is_finite is True
+    assert z.is_infinite is False
+    assert z.is_comparable is True
+    assert z.is_prime is False
+    assert z.is_composite is False
+
+
+def test_E():
+    z = S.Exp1
+    assert z.is_commutative is True
+    assert z.is_integer is False
+    assert z.is_rational is False
+    assert z.is_algebraic is False
+    assert z.is_transcendental is True
+    assert z.is_real is True
+    assert z.is_complex is True
+    assert z.is_noninteger is True
+    assert z.is_irrational is True
+    assert z.is_imaginary is False
+    assert z.is_positive is True
+    assert z.is_negative is False
+    assert z.is_nonpositive is False
+    assert z.is_nonnegative is True
+    assert z.is_even is False
+    assert z.is_odd is False
+    assert z.is_finite is True
+    assert z.is_infinite is False
+    assert z.is_comparable is True
+    assert z.is_prime is False
+    assert z.is_composite is False
+
+
+def test_I():
+    z = S.ImaginaryUnit
+    assert z.is_commutative is True
+    assert z.is_integer is False
+    assert z.is_rational is False
+    assert z.is_algebraic is True
+    assert z.is_transcendental is False
+    assert z.is_real is False
+    assert z.is_complex is True
+    assert z.is_noninteger is False
+    assert z.is_irrational is False
+    assert z.is_imaginary is True
+    assert z.is_positive is False
+    assert z.is_negative is False
+    assert z.is_nonpositive is False
+    assert z.is_nonnegative is False
+    assert z.is_even is False
+    assert z.is_odd is False
+    assert z.is_finite is True
+    assert z.is_infinite is False
+    assert z.is_comparable is False
+    assert z.is_prime is False
+    assert z.is_composite is False
+
+
+def test_symbol_real_false():
+    # issue 3848
+    a = Symbol('a', real=False)
+
+    assert a.is_real is False
+    assert a.is_integer is False
+    assert a.is_zero is False
+
+    assert a.is_negative is False
+    assert a.is_positive is False
+    assert a.is_nonnegative is False
+    assert a.is_nonpositive is False
+    assert a.is_nonzero is False
+
+    assert a.is_extended_negative is None
+    assert a.is_extended_positive is None
+    assert a.is_extended_nonnegative is None
+    assert a.is_extended_nonpositive is None
+    assert a.is_extended_nonzero is None
+
+
+def test_symbol_extended_real_false():
+    # issue 3848
+    a = Symbol('a', extended_real=False)
+
+    assert a.is_real is False
+    assert a.is_integer is False
+    assert a.is_zero is False
+
+    assert a.is_negative is False
+    assert a.is_positive is False
+    assert a.is_nonnegative is False
+    assert a.is_nonpositive is False
+    assert a.is_nonzero is False
+
+    assert a.is_extended_negative is False
+    assert a.is_extended_positive is False
+    assert a.is_extended_nonnegative is False
+    assert a.is_extended_nonpositive is False
+    assert a.is_extended_nonzero is False
+
+
+def test_symbol_imaginary():
+    a = Symbol('a', imaginary=True)
+
+    assert a.is_real is False
+    assert a.is_integer is False
+    assert a.is_negative is False
+    assert a.is_positive is False
+    assert a.is_nonnegative is False
+    assert a.is_nonpositive is False
+    assert a.is_zero is False
+    assert a.is_nonzero is False  # since nonzero -> real
+
+
+def test_symbol_zero():
+    x = Symbol('x', zero=True)
+    assert x.is_positive is False
+    assert x.is_nonpositive
+    assert x.is_negative is False
+    assert x.is_nonnegative
+    assert x.is_zero is True
+    # TODO Change to x.is_nonzero is None
+    # See https://github.com/sympy/sympy/pull/9583
+    assert x.is_nonzero is False
+    assert x.is_finite is True
+
+
+def test_symbol_positive():
+    x = Symbol('x', positive=True)
+    assert x.is_positive is True
+    assert x.is_nonpositive is False
+    assert x.is_negative is False
+    assert x.is_nonnegative is True
+    assert x.is_zero is False
+    assert x.is_nonzero is True
+
+
+def test_neg_symbol_positive():
+    x = -Symbol('x', positive=True)
+    assert x.is_positive is False
+    assert x.is_nonpositive is True
+    assert x.is_negative is True
+    assert x.is_nonnegative is False
+    assert x.is_zero is False
+    assert x.is_nonzero is True
+
+
+def test_symbol_nonpositive():
+    x = Symbol('x', nonpositive=True)
+    assert x.is_positive is False
+    assert x.is_nonpositive is True
+    assert x.is_negative is None
+    assert x.is_nonnegative is None
+    assert x.is_zero is None
+    assert x.is_nonzero is None
+
+
+def test_neg_symbol_nonpositive():
+    x = -Symbol('x', nonpositive=True)
+    assert x.is_positive is None
+    assert x.is_nonpositive is None
+    assert x.is_negative is False
+    assert x.is_nonnegative is True
+    assert x.is_zero is None
+    assert x.is_nonzero is None
+
+
+def test_symbol_falsepositive():
+    x = Symbol('x', positive=False)
+    assert x.is_positive is False
+    assert x.is_nonpositive is None
+    assert x.is_negative is None
+    assert x.is_nonnegative is None
+    assert x.is_zero is None
+    assert x.is_nonzero is None
+
+
+def test_symbol_falsepositive_mul():
+    # To test pull request 9379
+    # Explicit handling of arg.is_positive=False was added to Mul._eval_is_positive
+    x = 2*Symbol('x', positive=False)
+    assert x.is_positive is False  # This was None before
+    assert x.is_nonpositive is None
+    assert x.is_negative is None
+    assert x.is_nonnegative is None
+    assert x.is_zero is None
+    assert x.is_nonzero is None
+
+
+@XFAIL
+def test_symbol_infinitereal_mul():
+    ix = Symbol('ix', infinite=True, extended_real=True)
+    assert (-ix).is_extended_positive is None
+
+
+def test_neg_symbol_falsepositive():
+    x = -Symbol('x', positive=False)
+    assert x.is_positive is None
+    assert x.is_nonpositive is None
+    assert x.is_negative is False
+    assert x.is_nonnegative is None
+    assert x.is_zero is None
+    assert x.is_nonzero is None
+
+
+def test_neg_symbol_falsenegative():
+    # To test pull request 9379
+    # Explicit handling of arg.is_negative=False was added to Mul._eval_is_positive
+    x = -Symbol('x', negative=False)
+    assert x.is_positive is False  # This was None before
+    assert x.is_nonpositive is None
+    assert x.is_negative is None
+    assert x.is_nonnegative is None
+    assert x.is_zero is None
+    assert x.is_nonzero is None
+
+
+def test_symbol_falsepositive_real():
+    x = Symbol('x', positive=False, real=True)
+    assert x.is_positive is False
+    assert x.is_nonpositive is True
+    assert x.is_negative is None
+    assert x.is_nonnegative is None
+    assert x.is_zero is None
+    assert x.is_nonzero is None
+
+
+def test_neg_symbol_falsepositive_real():
+    x = -Symbol('x', positive=False, real=True)
+    assert x.is_positive is None
+    assert x.is_nonpositive is None
+    assert x.is_negative is False
+    assert x.is_nonnegative is True
+    assert x.is_zero is None
+    assert x.is_nonzero is None
+
+
+def test_symbol_falsenonnegative():
+    x = Symbol('x', nonnegative=False)
+    assert x.is_positive is False
+    assert x.is_nonpositive is None
+    assert x.is_negative is None
+    assert x.is_nonnegative is False
+    assert x.is_zero is False
+    assert x.is_nonzero is None
+
+
+@XFAIL
+def test_neg_symbol_falsenonnegative():
+    x = -Symbol('x', nonnegative=False)
+    assert x.is_positive is None
+    assert x.is_nonpositive is False  # this currently returns None
+    assert x.is_negative is False  # this currently returns None
+    assert x.is_nonnegative is None
+    assert x.is_zero is False  # this currently returns None
+    assert x.is_nonzero is True  # this currently returns None
+
+
+def test_symbol_falsenonnegative_real():
+    x = Symbol('x', nonnegative=False, real=True)
+    assert x.is_positive is False
+    assert x.is_nonpositive is True
+    assert x.is_negative is True
+    assert x.is_nonnegative is False
+    assert x.is_zero is False
+    assert x.is_nonzero is True
+
+
+def test_neg_symbol_falsenonnegative_real():
+    x = -Symbol('x', nonnegative=False, real=True)
+    assert x.is_positive is True
+    assert x.is_nonpositive is False
+    assert x.is_negative is False
+    assert x.is_nonnegative is True
+    assert x.is_zero is False
+    assert x.is_nonzero is True
+
+
+def test_prime():
+    assert S.NegativeOne.is_prime is False
+    assert S(-2).is_prime is False
+    assert S(-4).is_prime is False
+    assert S.Zero.is_prime is False
+    assert S.One.is_prime is False
+    assert S(2).is_prime is True
+    assert S(17).is_prime is True
+    assert S(4).is_prime is False
+
+
+def test_composite():
+    assert S.NegativeOne.is_composite is False
+    assert S(-2).is_composite is False
+    assert S(-4).is_composite is False
+    assert S.Zero.is_composite is False
+    assert S(2).is_composite is False
+    assert S(17).is_composite is False
+    assert S(4).is_composite is True
+    x = Dummy(integer=True, positive=True, prime=False)
+    assert x.is_composite is None # x could be 1
+    assert (x + 1).is_composite is None
+    x = Dummy(positive=True, even=True, prime=False)
+    assert x.is_integer is True
+    assert x.is_composite is True
+
+
+def test_prime_symbol():
+    x = Symbol('x', prime=True)
+    assert x.is_prime is True
+    assert x.is_integer is True
+    assert x.is_positive is True
+    assert x.is_negative is False
+    assert x.is_nonpositive is False
+    assert x.is_nonnegative is True
+
+    x = Symbol('x', prime=False)
+    assert x.is_prime is False
+    assert x.is_integer is None
+    assert x.is_positive is None
+    assert x.is_negative is None
+    assert x.is_nonpositive is None
+    assert x.is_nonnegative is None
+
+
+def test_symbol_noncommutative():
+    x = Symbol('x', commutative=True)
+    assert x.is_complex is None
+
+    x = Symbol('x', commutative=False)
+    assert x.is_integer is False
+    assert x.is_rational is False
+    assert x.is_algebraic is False
+    assert x.is_irrational is False
+    assert x.is_real is False
+    assert x.is_complex is False
+
+
+def test_other_symbol():
+    x = Symbol('x', integer=True)
+    assert x.is_integer is True
+    assert x.is_real is True
+    assert x.is_finite is True
+
+    x = Symbol('x', integer=True, nonnegative=True)
+    assert x.is_integer is True
+    assert x.is_nonnegative is True
+    assert x.is_negative is False
+    assert x.is_positive is None
+    assert x.is_finite is True
+
+    x = Symbol('x', integer=True, nonpositive=True)
+    assert x.is_integer is True
+    assert x.is_nonpositive is True
+    assert x.is_positive is False
+    assert x.is_negative is None
+    assert x.is_finite is True
+
+    x = Symbol('x', odd=True)
+    assert x.is_odd is True
+    assert x.is_even is False
+    assert x.is_integer is True
+    assert x.is_finite is True
+
+    x = Symbol('x', odd=False)
+    assert x.is_odd is False
+    assert x.is_even is None
+    assert x.is_integer is None
+    assert x.is_finite is None
+
+    x = Symbol('x', even=True)
+    assert x.is_even is True
+    assert x.is_odd is False
+    assert x.is_integer is True
+    assert x.is_finite is True
+
+    x = Symbol('x', even=False)
+    assert x.is_even is False
+    assert x.is_odd is None
+    assert x.is_integer is None
+    assert x.is_finite is None
+
+    x = Symbol('x', integer=True, nonnegative=True)
+    assert x.is_integer is True
+    assert x.is_nonnegative is True
+    assert x.is_finite is True
+
+    x = Symbol('x', integer=True, nonpositive=True)
+    assert x.is_integer is True
+    assert x.is_nonpositive is True
+    assert x.is_finite is True
+
+    x = Symbol('x', rational=True)
+    assert x.is_real is True
+    assert x.is_finite is True
+
+    x = Symbol('x', rational=False)
+    assert x.is_real is None
+    assert x.is_finite is None
+
+    x = Symbol('x', irrational=True)
+    assert x.is_real is True
+    assert x.is_finite is True
+
+    x = Symbol('x', irrational=False)
+    assert x.is_real is None
+    assert x.is_finite is None
+
+    with raises(AttributeError):
+        x.is_real = False
+
+    x = Symbol('x', algebraic=True)
+    assert x.is_transcendental is False
+    x = Symbol('x', transcendental=True)
+    assert x.is_algebraic is False
+    assert x.is_rational is False
+    assert x.is_integer is False
+
+
+def test_evaluate_false():
+    # Previously this failed because the assumptions query would make new
+    # expressions and some of the evaluation logic would fail under
+    # evaluate(False).
+    from sympy.core.parameters import evaluate
+    from sympy.abc import x, h
+    f = 2**x**7
+    with evaluate(False):
+        fh = f.xreplace({x: x+h})
+        assert fh.exp.is_rational is None
+
+
+def test_issue_3825():
+    """catch: hash instability"""
+    x = Symbol("x")
+    y = Symbol("y")
+    a1 = x + y
+    a2 = y + x
+    a2.is_comparable
+
+    h1 = hash(a1)
+    h2 = hash(a2)
+    assert h1 == h2
+
+
+def test_issue_4822():
+    z = (-1)**Rational(1, 3)*(1 - I*sqrt(3))
+    assert z.is_real in [True, None]
+
+
+def test_hash_vs_typeinfo():
+    """seemingly different typeinfo, but in fact equal"""
+
+    # the following two are semantically equal
+    x1 = Symbol('x', even=True)
+    x2 = Symbol('x', integer=True, odd=False)
+
+    assert hash(x1) == hash(x2)
+    assert x1 == x2
+
+
+def test_hash_vs_typeinfo_2():
+    """different typeinfo should mean !eq"""
+    # the following two are semantically different
+    x = Symbol('x')
+    x1 = Symbol('x', even=True)
+
+    assert x != x1
+    assert hash(x) != hash(x1)  # This might fail with very low probability
+
+
+def test_hash_vs_eq():
+    """catch: different hash for equal objects"""
+    a = 1 + S.Pi    # important: do not fold it into a Number instance
+    ha = hash(a)  # it should be Add/Mul/... to trigger the bug
+
+    a.is_positive   # this uses .evalf() and deduces it is positive
+    assert a.is_positive is True
+
+    # be sure that hash stayed the same
+    assert ha == hash(a)
+
+    # now b should be the same expression
+    b = a.expand(trig=True)
+    hb = hash(b)
+
+    assert a == b
+    assert ha == hb
+
+
+def test_Add_is_pos_neg():
+    # these cover lines not covered by the rest of tests in core
+    n = Symbol('n', extended_negative=True, infinite=True)
+    nn = Symbol('n', extended_nonnegative=True, infinite=True)
+    np = Symbol('n', extended_nonpositive=True, infinite=True)
+    p = Symbol('p', extended_positive=True, infinite=True)
+    r = Dummy(extended_real=True, finite=False)
+    x = Symbol('x')
+    xf = Symbol('xf', finite=True)
+    assert (n + p).is_extended_positive is None
+    assert (n + x).is_extended_positive is None
+    assert (p + x).is_extended_positive is None
+    assert (n + p).is_extended_negative is None
+    assert (n + x).is_extended_negative is None
+    assert (p + x).is_extended_negative is None
+
+    assert (n + xf).is_extended_positive is False
+    assert (p + xf).is_extended_positive is True
+    assert (n + xf).is_extended_negative is True
+    assert (p + xf).is_extended_negative is False
+
+    assert (x - S.Infinity).is_extended_negative is None  # issue 7798
+    # issue 8046, 16.2
+    assert (p + nn).is_extended_positive
+    assert (n + np).is_extended_negative
+    assert (p + r).is_extended_positive is None
+
+
+def test_Add_is_imaginary():
+    nn = Dummy(nonnegative=True)
+    assert (I*nn + I).is_imaginary  # issue 8046, 17
+
+
+def test_Add_is_algebraic():
+    a = Symbol('a', algebraic=True)
+    b = Symbol('a', algebraic=True)
+    na = Symbol('na', algebraic=False)
+    nb = Symbol('nb', algebraic=False)
+    x = Symbol('x')
+    assert (a + b).is_algebraic
+    assert (na + nb).is_algebraic is None
+    assert (a + na).is_algebraic is False
+    assert (a + x).is_algebraic is None
+    assert (na + x).is_algebraic is None
+
+
+def test_Mul_is_algebraic():
+    a = Symbol('a', algebraic=True)
+    b = Symbol('b', algebraic=True)
+    na = Symbol('na', algebraic=False)
+    an = Symbol('an', algebraic=True, nonzero=True)
+    nb = Symbol('nb', algebraic=False)
+    x = Symbol('x')
+    assert (a*b).is_algebraic is True
+    assert (na*nb).is_algebraic is None
+    assert (a*na).is_algebraic is None
+    assert (an*na).is_algebraic is False
+    assert (a*x).is_algebraic is None
+    assert (na*x).is_algebraic is None
+
+
+def test_Pow_is_algebraic():
+    e = Symbol('e', algebraic=True)
+
+    assert Pow(1, e, evaluate=False).is_algebraic
+    assert Pow(0, e, evaluate=False).is_algebraic
+
+    a = Symbol('a', algebraic=True)
+    azf = Symbol('azf', algebraic=True, zero=False)
+    na = Symbol('na', algebraic=False)
+    ia = Symbol('ia', algebraic=True, irrational=True)
+    ib = Symbol('ib', algebraic=True, irrational=True)
+    r = Symbol('r', rational=True)
+    x = Symbol('x')
+    assert (a**2).is_algebraic is True
+    assert (a**r).is_algebraic is None
+    assert (azf**r).is_algebraic is True
+    assert (a**x).is_algebraic is None
+    assert (na**r).is_algebraic is None
+    assert (ia**r).is_algebraic is True
+    assert (ia**ib).is_algebraic is False
+
+    assert (a**e).is_algebraic is None
+
+    # Gelfond-Schneider constant:
+    assert Pow(2, sqrt(2), evaluate=False).is_algebraic is False
+
+    assert Pow(S.GoldenRatio, sqrt(3), evaluate=False).is_algebraic is False
+
+    # issue 8649
+    t = Symbol('t', real=True, transcendental=True)
+    n = Symbol('n', integer=True)
+    assert (t**n).is_algebraic is None
+    assert (t**n).is_integer is None
+
+    assert (pi**3).is_algebraic is False
+    r = Symbol('r', zero=True)
+    assert (pi**r).is_algebraic is True
+
+
+def test_Mul_is_prime_composite():
+    x = Symbol('x', positive=True, integer=True)
+    y = Symbol('y', positive=True, integer=True)
+    assert (x*y).is_prime is None
+    assert ( (x+1)*(y+1) ).is_prime is False
+    assert ( (x+1)*(y+1) ).is_composite is True
+
+    x = Symbol('x', positive=True)
+    assert ( (x+1)*(y+1) ).is_prime is None
+    assert ( (x+1)*(y+1) ).is_composite is None
+
+
+def test_Pow_is_pos_neg():
+    z = Symbol('z', real=True)
+    w = Symbol('w', nonpositive=True)
+
+    assert (S.NegativeOne**S(2)).is_positive is True
+    assert (S.One**z).is_positive is True
+    assert (S.NegativeOne**S(3)).is_positive is False
+    assert (S.Zero**S.Zero).is_positive is True  # 0**0 is 1
+    assert (w**S(3)).is_positive is False
+    assert (w**S(2)).is_positive is None
+    assert (I**2).is_positive is False
+    assert (I**4).is_positive is True
+
+    # tests emerging from #16332 issue
+    p = Symbol('p', zero=True)
+    q = Symbol('q', zero=False, real=True)
+    j = Symbol('j', zero=False, even=True)
+    x = Symbol('x', zero=True)
+    y = Symbol('y', zero=True)
+    assert (p**q).is_positive is False
+    assert (p**q).is_negative is False
+    assert (p**j).is_positive is False
+    assert (x**y).is_positive is True   # 0**0
+    assert (x**y).is_negative is False
+
+
+def test_Pow_is_prime_composite():
+    x = Symbol('x', positive=True, integer=True)
+    y = Symbol('y', positive=True, integer=True)
+    assert (x**y).is_prime is None
+    assert ( x**(y+1) ).is_prime is False
+    assert ( x**(y+1) ).is_composite is None
+    assert ( (x+1)**(y+1) ).is_composite is True
+    assert ( (-x-1)**(2*y) ).is_composite is True
+
+    x = Symbol('x', positive=True)
+    assert (x**y).is_prime is None
+
+
+def test_Mul_is_infinite():
+    x = Symbol('x')
+    f = Symbol('f', finite=True)
+    i = Symbol('i', infinite=True)
+    z = Dummy(zero=True)
+    nzf = Dummy(finite=True, zero=False)
+    from sympy.core.mul import Mul
+    assert (x*f).is_finite is None
+    assert (x*i).is_finite is None
+    assert (f*i).is_finite is None
+    assert (x*f*i).is_finite is None
+    assert (z*i).is_finite is None
+    assert (nzf*i).is_finite is False
+    assert (z*f).is_finite is True
+    assert Mul(0, f, evaluate=False).is_finite is True
+    assert Mul(0, i, evaluate=False).is_finite is None
+
+    assert (x*f).is_infinite is None
+    assert (x*i).is_infinite is None
+    assert (f*i).is_infinite is None
+    assert (x*f*i).is_infinite is None
+    assert (z*i).is_infinite is S.NaN.is_infinite
+    assert (nzf*i).is_infinite is True
+    assert (z*f).is_infinite is False
+    assert Mul(0, f, evaluate=False).is_infinite is False
+    assert Mul(0, i, evaluate=False).is_infinite is S.NaN.is_infinite
+
+
+def test_Add_is_infinite():
+    x = Symbol('x')
+    f = Symbol('f', finite=True)
+    i = Symbol('i', infinite=True)
+    i2 = Symbol('i2', infinite=True)
+    z = Dummy(zero=True)
+    nzf = Dummy(finite=True, zero=False)
+    from sympy.core.add import Add
+    assert (x+f).is_finite is None
+    assert (x+i).is_finite is None
+    assert (f+i).is_finite is False
+    assert (x+f+i).is_finite is None
+    assert (z+i).is_finite is False
+    assert (nzf+i).is_finite is False
+    assert (z+f).is_finite is True
+    assert (i+i2).is_finite is None
+    assert Add(0, f, evaluate=False).is_finite is True
+    assert Add(0, i, evaluate=False).is_finite is False
+
+    assert (x+f).is_infinite is None
+    assert (x+i).is_infinite is None
+    assert (f+i).is_infinite is True
+    assert (x+f+i).is_infinite is None
+    assert (z+i).is_infinite is True
+    assert (nzf+i).is_infinite is True
+    assert (z+f).is_infinite is False
+    assert (i+i2).is_infinite is None
+    assert Add(0, f, evaluate=False).is_infinite is False
+    assert Add(0, i, evaluate=False).is_infinite is True
+
+
+def test_special_is_rational():
+    i = Symbol('i', integer=True)
+    i2 = Symbol('i2', integer=True)
+    ni = Symbol('ni', integer=True, nonzero=True)
+    r = Symbol('r', rational=True)
+    rn = Symbol('r', rational=True, nonzero=True)
+    nr = Symbol('nr', irrational=True)
+    x = Symbol('x')
+    assert sqrt(3).is_rational is False
+    assert (3 + sqrt(3)).is_rational is False
+    assert (3*sqrt(3)).is_rational is False
+    assert exp(3).is_rational is False
+    assert exp(ni).is_rational is False
+    assert exp(rn).is_rational is False
+    assert exp(x).is_rational is None
+    assert exp(log(3), evaluate=False).is_rational is True
+    assert log(exp(3), evaluate=False).is_rational is True
+    assert log(3).is_rational is False
+    assert log(ni + 1).is_rational is False
+    assert log(rn + 1).is_rational is False
+    assert log(x).is_rational is None
+    assert (sqrt(3) + sqrt(5)).is_rational is None
+    assert (sqrt(3) + S.Pi).is_rational is False
+    assert (x**i).is_rational is None
+    assert (i**i).is_rational is True
+    assert (i**i2).is_rational is None
+    assert (r**i).is_rational is None
+    assert (r**r).is_rational is None
+    assert (r**x).is_rational is None
+    assert (nr**i).is_rational is None  # issue 8598
+    assert (nr**Symbol('z', zero=True)).is_rational
+    assert sin(1).is_rational is False
+    assert sin(ni).is_rational is False
+    assert sin(rn).is_rational is False
+    assert sin(x).is_rational is None
+    assert asin(r).is_rational is False
+    assert sin(asin(3), evaluate=False).is_rational is True
+
+
+@XFAIL
+def test_issue_6275():
+    x = Symbol('x')
+    # both zero or both Muls...but neither "change would be very appreciated.
+    # This is similar to x/x => 1 even though if x = 0, it is really nan.
+    assert isinstance(x*0, type(0*S.Infinity))
+    if 0*S.Infinity is S.NaN:
+        b = Symbol('b', finite=None)
+        assert (b*0).is_zero is None
+
+
+def test_sanitize_assumptions():
+    # issue 6666
+    for cls in (Symbol, Dummy, Wild):
+        x = cls('x', real=1, positive=0)
+        assert x.is_real is True
+        assert x.is_positive is False
+        assert cls('', real=True, positive=None).is_positive is None
+        raises(ValueError, lambda: cls('', commutative=None))
+    raises(ValueError, lambda: Symbol._sanitize({"commutative": None}))
+
+
+def test_special_assumptions():
+    e = -3 - sqrt(5) + (-sqrt(10)/2 - sqrt(2)/2)**2
+    assert simplify(e < 0) is S.false
+    assert simplify(e > 0) is S.false
+    assert (e == 0) is False  # it's not a literal 0
+    assert e.equals(0) is True
+
+
+def test_inconsistent():
+    # cf. issues 5795 and 5545
+    raises(InconsistentAssumptions, lambda: Symbol('x', real=True,
+           commutative=False))
+
+
+def test_issue_6631():
+    assert ((-1)**(I)).is_real is True
+    assert ((-1)**(I*2)).is_real is True
+    assert ((-1)**(I/2)).is_real is True
+    assert ((-1)**(I*S.Pi)).is_real is True
+    assert (I**(I + 2)).is_real is True
+
+
+def test_issue_2730():
+    assert (1/(1 + I)).is_real is False
+
+
+def test_issue_4149():
+    assert (3 + I).is_complex
+    assert (3 + I).is_imaginary is False
+    assert (3*I + S.Pi*I).is_imaginary
+    # as Zero.is_imaginary is False, see issue 7649
+    y = Symbol('y', real=True)
+    assert (3*I + S.Pi*I + y*I).is_imaginary is None
+    p = Symbol('p', positive=True)
+    assert (3*I + S.Pi*I + p*I).is_imaginary
+    n = Symbol('n', negative=True)
+    assert (-3*I - S.Pi*I + n*I).is_imaginary
+
+    i = Symbol('i', imaginary=True)
+    assert ([(i**a).is_imaginary for a in range(4)] ==
+            [False, True, False, True])
+
+    # tests from the PR #7887:
+    e = S("-sqrt(3)*I/2 + 0.866025403784439*I")
+    assert e.is_real is False
+    assert e.is_imaginary
+
+
+def test_issue_2920():
+    n = Symbol('n', negative=True)
+    assert sqrt(n).is_imaginary
+
+
+def test_issue_7899():
+    x = Symbol('x', real=True)
+    assert (I*x).is_real is None
+    assert ((x - I)*(x - 1)).is_zero is None
+    assert ((x - I)*(x - 1)).is_real is None
+
+
+@XFAIL
+def test_issue_7993():
+    x = Dummy(integer=True)
+    y = Dummy(noninteger=True)
+    assert (x - y).is_zero is False
+
+
+def test_issue_8075():
+    raises(InconsistentAssumptions, lambda: Dummy(zero=True, finite=False))
+    raises(InconsistentAssumptions, lambda: Dummy(zero=True, infinite=True))
+
+
+def test_issue_8642():
+    x = Symbol('x', real=True, integer=False)
+    assert (x*2).is_integer is None, (x*2).is_integer
+
+
+def test_issues_8632_8633_8638_8675_8992():
+    p = Dummy(integer=True, positive=True)
+    nn = Dummy(integer=True, nonnegative=True)
+    assert (p - S.Half).is_positive
+    assert (p - 1).is_nonnegative
+    assert (nn + 1).is_positive
+    assert (-p + 1).is_nonpositive
+    assert (-nn - 1).is_negative
+    prime = Dummy(prime=True)
+    assert (prime - 2).is_nonnegative
+    assert (prime - 3).is_nonnegative is None
+    even = Dummy(positive=True, even=True)
+    assert (even - 2).is_nonnegative
+
+    p = Dummy(positive=True)
+    assert (p/(p + 1) - 1).is_negative
+    assert ((p + 2)**3 - S.Half).is_positive
+    n = Dummy(negative=True)
+    assert (n - 3).is_nonpositive
+
+
+def test_issue_9115_9150():
+    n = Dummy('n', integer=True, nonnegative=True)
+    assert (factorial(n) >= 1) == True
+    assert (factorial(n) < 1) == False
+
+    assert factorial(n + 1).is_even is None
+    assert factorial(n + 2).is_even is True
+    assert factorial(n + 2) >= 2
+
+
+def test_issue_9165():
+    z = Symbol('z', zero=True)
+    f = Symbol('f', finite=False)
+    assert 0/z is S.NaN
+    assert 0*(1/z) is S.NaN
+    assert 0*f is S.NaN
+
+
+def test_issue_10024():
+    x = Dummy('x')
+    assert Mod(x, 2*pi).is_zero is None
+
+
+def test_issue_10302():
+    x = Symbol('x')
+    r = Symbol('r', real=True)
+    u = -(3*2**pi)**(1/pi) + 2*3**(1/pi)
+    i = u + u*I
+
+    assert i.is_real is None  # w/o simplification this should fail
+    assert (u + i).is_zero is None
+    assert (1 + i).is_zero is False
+
+    a = Dummy('a', zero=True)
+    assert (a + I).is_zero is False
+    assert (a + r*I).is_zero is None
+    assert (a + I).is_imaginary
+    assert (a + x + I).is_imaginary is None
+    assert (a + r*I + I).is_imaginary is None
+
+
+def test_complex_reciprocal_imaginary():
+    assert (1 / (4 + 3*I)).is_imaginary is False
+
+
+def test_issue_16313():
+    x = Symbol('x', extended_real=False)
+    k = Symbol('k', real=True)
+    l = Symbol('l', real=True, zero=False)
+    assert (-x).is_real is False
+    assert (k*x).is_real is None  # k can be zero also
+    assert (l*x).is_real is False
+    assert (l*x*x).is_real is None  # since x*x can be a real number
+    assert (-x).is_positive is False
+
+
+def test_issue_16579():
+    # extended_real -> finite | infinite
+    x = Symbol('x', extended_real=True, infinite=False)
+    y = Symbol('y', extended_real=True, finite=False)
+    assert x.is_finite is True
+    assert y.is_infinite is True
+
+    # With PR 16978, complex now implies finite
+    c = Symbol('c', complex=True)
+    assert c.is_finite is True
+    raises(InconsistentAssumptions, lambda: Dummy(complex=True, finite=False))
+
+    # Now infinite == !finite
+    nf = Symbol('nf', finite=False)
+    assert nf.is_infinite is True
+
+
+def test_issue_17556():
+    z = I*oo
+    assert z.is_imaginary is False
+    assert z.is_finite is False
+
+
+def test_issue_21651():
+    k = Symbol('k', positive=True, integer=True)
+    exp = 2*2**(-k)
+    assert exp.is_integer is None
+
+
+def test_assumptions_copy():
+    assert assumptions(Symbol('x'), {"commutative": True}
+        ) == {'commutative': True}
+    assert assumptions(Symbol('x'), ['integer']) == {}
+    assert assumptions(Symbol('x'), ['commutative']
+        ) == {'commutative': True}
+    assert assumptions(Symbol('x')) == {'commutative': True}
+    assert assumptions(1)['positive']
+    assert assumptions(3 + I) == {
+        'algebraic': True,
+        'commutative': True,
+        'complex': True,
+        'composite': False,
+        'even': False,
+        'extended_negative': False,
+        'extended_nonnegative': False,
+        'extended_nonpositive': False,
+        'extended_nonzero': False,
+        'extended_positive': False,
+        'extended_real': False,
+        'finite': True,
+        'imaginary': False,
+        'infinite': False,
+        'integer': False,
+        'irrational': False,
+        'negative': False,
+        'noninteger': False,
+        'nonnegative': False,
+        'nonpositive': False,
+        'nonzero': False,
+        'odd': False,
+        'positive': False,
+        'prime': False,
+        'rational': False,
+        'real': False,
+        'transcendental': False,
+        'zero': False}
+
+
+def test_check_assumptions():
+    assert check_assumptions(1, 0) is False
+    x = Symbol('x', positive=True)
+    assert check_assumptions(1, x) is True
+    assert check_assumptions(1, 1) is True
+    assert check_assumptions(-1, 1) is False
+    i = Symbol('i', integer=True)
+    # don't know if i is positive (or prime, etc...)
+    assert check_assumptions(i, 1) is None
+    assert check_assumptions(Dummy(integer=None), integer=True) is None
+    assert check_assumptions(Dummy(integer=None), integer=False) is None
+    assert check_assumptions(Dummy(integer=False), integer=True) is False
+    assert check_assumptions(Dummy(integer=True), integer=False) is False
+    # no T/F assumptions to check
+    assert check_assumptions(Dummy(integer=False), integer=None) is True
+    raises(ValueError, lambda: check_assumptions(2*x, x, positive=True))
+
+
+def test_failing_assumptions():
+    x = Symbol('x', positive=True)
+    y = Symbol('y')
+    assert failing_assumptions(6*x + y, **x.assumptions0) == \
+    {'real': None, 'imaginary': None, 'complex': None, 'hermitian': None,
+    'positive': None, 'nonpositive': None, 'nonnegative': None, 'nonzero': None,
+    'negative': None, 'zero': None, 'extended_real': None, 'finite': None,
+    'infinite': None, 'extended_negative': None, 'extended_nonnegative': None,
+    'extended_nonpositive': None, 'extended_nonzero': None,
+    'extended_positive': None }
+
+
+def test_common_assumptions():
+    assert common_assumptions([0, 1, 2]
+        ) == {'algebraic': True, 'irrational': False, 'hermitian':
+        True, 'extended_real': True, 'real': True, 'extended_negative':
+        False, 'extended_nonnegative': True, 'integer': True,
+        'rational': True, 'imaginary': False, 'complex': True,
+        'commutative': True,'noninteger': False, 'composite': False,
+        'infinite': False, 'nonnegative': True, 'finite': True,
+        'transcendental': False,'negative': False}
+    assert common_assumptions([0, 1, 2], 'positive integer'.split()
+        ) == {'integer': True}
+    assert common_assumptions([0, 1, 2], []) == {}
+    assert common_assumptions([], ['integer']) == {}
+    assert common_assumptions([0], ['integer']) == {'integer': True}
+
+def test_pre_generated_assumption_rules_are_valid():
+    # check the pre-generated assumptions match freshly generated assumptions
+    # if this check fails, consider updating the assumptions
+    # see sympy.core.assumptions._generate_assumption_rules
+    pre_generated_assumptions =_load_pre_generated_assumption_rules()
+    generated_assumptions =_generate_assumption_rules()
+    assert pre_generated_assumptions._to_python() == generated_assumptions._to_python(), "pre-generated assumptions are invalid, see sympy.core.assumptions._generate_assumption_rules"
+
+
+def test_ask_shuffle():
+    grp = PermutationGroup(Permutation(1, 0, 2), Permutation(2, 1, 3))
+
+    seed(123)
+    first = grp.random()
+    seed(123)
+    simplify(I)
+    second = grp.random()
+    seed(123)
+    simplify(-I)
+    third = grp.random()
+
+    assert first == second == third

.venv/lib/python3.11/site-packages/sympy/core/tests/test_basic.py

@@ -0,0 +1,333 @@
+"""This tests sympy/core/basic.py with (ideally) no reference to subclasses
+of Basic or Atom."""
+import collections
+from typing import TypeVar, Generic
+
+from sympy.assumptions.ask import Q
+from sympy.core.basic import (Basic, Atom, as_Basic,
+    _atomic, _aresame)
+from sympy.core.containers import Tuple
+from sympy.core.function import Function, Lambda
+from sympy.core.numbers import I, pi, Float
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols, Symbol, Dummy
+from sympy.concrete.summations import Sum
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.gamma_functions import gamma
+from sympy.integrals.integrals import Integral
+from sympy.functions.elementary.exponential import exp
+from sympy.testing.pytest import raises, warns_deprecated_sympy
+
+b1 = Basic()
+b2 = Basic(b1)
+b3 = Basic(b2)
+b21 = Basic(b2, b1)
+T = TypeVar('T')
+
+
+def test__aresame():
+    assert not _aresame(Basic(Tuple()), Basic())
+    for i, j in [(S(2), S(2.)), (1., Float(1))]:
+        for do in range(2):
+            assert not _aresame(Basic(i), Basic(j))
+            assert not _aresame(i, j)
+            i, j = j, i
+
+
+def test_structure():
+    assert b21.args == (b2, b1)
+    assert b21.func(*b21.args) == b21
+    assert bool(b1)
+
+
+def test_immutable():
+    assert not hasattr(b1, '__dict__')
+    with raises(AttributeError):
+        b1.x = 1
+
+
+def test_equality():
+    instances = [b1, b2, b3, b21, Basic(b1, b1, b1), Basic]
+    for i, b_i in enumerate(instances):
+        for j, b_j in enumerate(instances):
+            assert (b_i == b_j) == (i == j)
+            assert (b_i != b_j) == (i != j)
+
+    assert Basic() != []
+    assert not(Basic() == [])
+    assert Basic() != 0
+    assert not(Basic() == 0)
+
+    class Foo:
+        """
+        Class that is unaware of Basic, and relies on both classes returning
+        the NotImplemented singleton for equivalence to evaluate to False.
+
+        """
+
+    b = Basic()
+    foo = Foo()
+
+    assert b != foo
+    assert foo != b
+    assert not b == foo
+    assert not foo == b
+
+    class Bar:
+        """
+        Class that considers itself equal to any instance of Basic, and relies
+        on Basic returning the NotImplemented singleton in order to achieve
+        a symmetric equivalence relation.
+
+        """
+        def __eq__(self, other):
+            if isinstance(other, Basic):
+                return True
+            return NotImplemented
+
+        def __ne__(self, other):
+            return not self == other
+
+    bar = Bar()
+
+    assert b == bar
+    assert bar == b
+    assert not b != bar
+    assert not bar != b
+
+
+def test_matches_basic():
+    instances = [Basic(b1, b1, b2), Basic(b1, b2, b1), Basic(b2, b1, b1),
+                 Basic(b1, b2), Basic(b2, b1), b2, b1]
+    for i, b_i in enumerate(instances):
+        for j, b_j in enumerate(instances):
+            if i == j:
+                assert b_i.matches(b_j) == {}
+            else:
+                assert b_i.matches(b_j) is None
+    assert b1.match(b1) == {}
+
+
+def test_has():
+    assert b21.has(b1)
+    assert b21.has(b3, b1)
+    assert b21.has(Basic)
+    assert not b1.has(b21, b3)
+    assert not b21.has()
+    assert not b21.has(str)
+    assert not Symbol("x").has("x")
+
+
+def test_subs():
+    assert b21.subs(b2, b1) == Basic(b1, b1)
+    assert b21.subs(b2, b21) == Basic(b21, b1)
+    assert b3.subs(b2, b1) == b2
+
+    assert b21.subs([(b2, b1), (b1, b2)]) == Basic(b2, b2)
+
+    assert b21.subs({b1: b2, b2: b1}) == Basic(b2, b2)
+    assert b21.subs(collections.ChainMap({b1: b2}, {b2: b1})) == Basic(b2, b2)
+    assert b21.subs(collections.OrderedDict([(b2, b1), (b1, b2)])) == Basic(b2, b2)
+
+    raises(ValueError, lambda: b21.subs('bad arg'))
+    raises(ValueError, lambda: b21.subs(b1, b2, b3))
+    # dict(b1=foo) creates a string 'b1' but leaves foo unchanged; subs
+    # will convert the first to a symbol but will raise an error if foo
+    # cannot be sympified; sympification is strict if foo is not string
+    raises(ValueError, lambda: b21.subs(b1='bad arg'))
+
+    assert Symbol("text").subs({"text": b1}) == b1
+    assert Symbol("s").subs({"s": 1}) == 1
+
+
+def test_subs_with_unicode_symbols():
+    expr = Symbol('var1')
+    replaced = expr.subs('var1', 'x')
+    assert replaced.name == 'x'
+
+    replaced = expr.subs('var1', 'x')
+    assert replaced.name == 'x'
+
+
+def test_atoms():
+    assert b21.atoms() == {Basic()}
+
+
+def test_free_symbols_empty():
+    assert b21.free_symbols == set()
+
+
+def test_doit():
+    assert b21.doit() == b21
+    assert b21.doit(deep=False) == b21
+
+
+def test_S():
+    assert repr(S) == 'S'
+
+
+def test_xreplace():
+    assert b21.xreplace({b2: b1}) == Basic(b1, b1)
+    assert b21.xreplace({b2: b21}) == Basic(b21, b1)
+    assert b3.xreplace({b2: b1}) == b2
+    assert Basic(b1, b2).xreplace({b1: b2, b2: b1}) == Basic(b2, b1)
+    assert Atom(b1).xreplace({b1: b2}) == Atom(b1)
+    assert Atom(b1).xreplace({Atom(b1): b2}) == b2
+    raises(TypeError, lambda: b1.xreplace())
+    raises(TypeError, lambda: b1.xreplace([b1, b2]))
+    for f in (exp, Function('f')):
+        assert f.xreplace({}) == f
+        assert f.xreplace({}, hack2=True) == f
+        assert f.xreplace({f: b1}) == b1
+        assert f.xreplace({f: b1}, hack2=True) == b1
+
+
+def test_sorted_args():
+    x = symbols('x')
+    assert b21._sorted_args == b21.args
+    raises(AttributeError, lambda: x._sorted_args)
+
+def test_call():
+    x, y = symbols('x y')
+    # See the long history of this in issues 5026 and 5105.
+
+    raises(TypeError, lambda: sin(x)({ x : 1, sin(x) : 2}))
+    raises(TypeError, lambda: sin(x)(1))
+
+    # No effect as there are no callables
+    assert sin(x).rcall(1) == sin(x)
+    assert (1 + sin(x)).rcall(1) == 1 + sin(x)
+
+    # Effect in the pressence of callables
+    l = Lambda(x, 2*x)
+    assert (l + x).rcall(y) == 2*y + x
+    assert (x**l).rcall(2) == x**4
+    # TODO UndefinedFunction does not subclass Expr
+    #f = Function('f')
+    #assert (2*f)(x) == 2*f(x)
+
+    assert (Q.real & Q.positive).rcall(x) == Q.real(x) & Q.positive(x)
+
+
+def test_rewrite():
+    x, y, z = symbols('x y z')
+    a, b = symbols('a b')
+    f1 = sin(x) + cos(x)
+    assert f1.rewrite(cos,exp) == exp(I*x)/2 + sin(x) + exp(-I*x)/2
+    assert f1.rewrite([cos],sin) == sin(x) + sin(x + pi/2, evaluate=False)
+    f2 = sin(x) + cos(y)/gamma(z)
+    assert f2.rewrite(sin,exp) == -I*(exp(I*x) - exp(-I*x))/2 + cos(y)/gamma(z)
+
+    assert f1.rewrite() == f1
+
+def test_literal_evalf_is_number_is_zero_is_comparable():
+    x = symbols('x')
+    f = Function('f')
+
+    # issue 5033
+    assert f.is_number is False
+    # issue 6646
+    assert f(1).is_number is False
+    i = Integral(0, (x, x, x))
+    # expressions that are symbolically 0 can be difficult to prove
+    # so in case there is some easy way to know if something is 0
+    # it should appear in the is_zero property for that object;
+    # if is_zero is true evalf should always be able to compute that
+    # zero
+    assert i.n() == 0
+    assert i.is_zero
+    assert i.is_number is False
+    assert i.evalf(2, strict=False) == 0
+
+    # issue 10268
+    n = sin(1)**2 + cos(1)**2 - 1
+    assert n.is_comparable is False
+    assert n.n(2).is_comparable is False
+    assert n.n(2).n(2).is_comparable
+
+
+def test_as_Basic():
+    assert as_Basic(1) is S.One
+    assert as_Basic(()) == Tuple()
+    raises(TypeError, lambda: as_Basic([]))
+
+
+def test_atomic():
+    g, h = map(Function, 'gh')
+    x = symbols('x')
+    assert _atomic(g(x + h(x))) == {g(x + h(x))}
+    assert _atomic(g(x + h(x)), recursive=True) == {h(x), x, g(x + h(x))}
+    assert _atomic(1) == set()
+    assert _atomic(Basic(S(1), S(2))) == set()
+
+
+def test_as_dummy():
+    u, v, x, y, z, _0, _1 = symbols('u v x y z _0 _1')
+    assert Lambda(x, x + 1).as_dummy() == Lambda(_0, _0 + 1)
+    assert Lambda(x, x + _0).as_dummy() == Lambda(_1, _0 + _1)
+    eq = (1 + Sum(x, (x, 1, x)))
+    ans = 1 + Sum(_0, (_0, 1, x))
+    once = eq.as_dummy()
+    assert once == ans
+    twice = once.as_dummy()
+    assert twice == ans
+    assert Integral(x + _0, (x, x + 1), (_0, 1, 2)
+        ).as_dummy() == Integral(_0 + _1, (_0, x + 1), (_1, 1, 2))
+    for T in (Symbol, Dummy):
+        d = T('x', real=True)
+        D = d.as_dummy()
+        assert D != d and D.func == Dummy and D.is_real is None
+    assert Dummy().as_dummy().is_commutative
+    assert Dummy(commutative=False).as_dummy().is_commutative is False
+
+
+def test_canonical_variables():
+    x, i0, i1 = symbols('x _:2')
+    assert Integral(x, (x, x + 1)).canonical_variables == {x: i0}
+    assert Integral(x, (x, x + 1), (i0, 1, 2)).canonical_variables == {
+        x: i0, i0: i1}
+    assert Integral(x, (x, x + i0)).canonical_variables == {x: i1}
+
+
+def test_replace_exceptions():
+    from sympy.core.symbol import Wild
+    x, y = symbols('x y')
+    e = (x**2 + x*y)
+    raises(TypeError, lambda: e.replace(sin, 2))
+    b = Wild('b')
+    c = Wild('c')
+    raises(TypeError, lambda: e.replace(b*c, c.is_real))
+    raises(TypeError, lambda: e.replace(b.is_real, 1))
+    raises(TypeError, lambda: e.replace(lambda d: d.is_Number, 1))
+
+
+def test_ManagedProperties():
+    # ManagedProperties is now deprecated. Here we do our best to check that if
+    # someone is using it then it does work in the way that it previously did
+    # but gives a deprecation warning.
+    from sympy.core.assumptions import ManagedProperties
+
+    myclasses = []
+
+    class MyMeta(ManagedProperties):
+        def __init__(cls, *args, **kwargs):
+            myclasses.append('executed')
+            super().__init__(*args, **kwargs)
+
+    code = """
+class MySubclass(Basic, metaclass=MyMeta):
+    pass
+"""
+    with warns_deprecated_sympy():
+        exec(code)
+
+    assert myclasses == ['executed']
+
+
+def test_generic():
+    # https://github.com/sympy/sympy/issues/25399
+    class A(Symbol, Generic[T]):
+        pass
+
+    class B(A[T]):
+        pass

.venv/lib/python3.11/site-packages/sympy/core/tests/test_cache.py

@@ -0,0 +1,91 @@
+import sys
+from sympy.core.cache import cacheit, cached_property, lazy_function
+from sympy.testing.pytest import raises
+
+def test_cacheit_doc():
+    @cacheit
+    def testfn():
+        "test docstring"
+        pass
+
+    assert testfn.__doc__ == "test docstring"
+    assert testfn.__name__ == "testfn"
+
+def test_cacheit_unhashable():
+    @cacheit
+    def testit(x):
+        return x
+
+    assert testit(1) == 1
+    assert testit(1) == 1
+    a = {}
+    assert testit(a) == {}
+    a[1] = 2
+    assert testit(a) == {1: 2}
+
+def test_cachit_exception():
+    # Make sure the cache doesn't call functions multiple times when they
+    # raise TypeError
+
+    a = []
+
+    @cacheit
+    def testf(x):
+        a.append(0)
+        raise TypeError
+
+    raises(TypeError, lambda: testf(1))
+    assert len(a) == 1
+
+    a.clear()
+    # Unhashable type
+    raises(TypeError, lambda: testf([]))
+    assert len(a) == 1
+
+    @cacheit
+    def testf2(x):
+        a.append(0)
+        raise TypeError("Error")
+
+    a.clear()
+    raises(TypeError, lambda: testf2(1))
+    assert len(a) == 1
+
+    a.clear()
+    # Unhashable type
+    raises(TypeError, lambda: testf2([]))
+    assert len(a) == 1
+
+def test_cached_property():
+    class A:
+        def __init__(self, value):
+            self.value = value
+            self.calls = 0
+
+        @cached_property
+        def prop(self):
+            self.calls = self.calls + 1
+            return self.value
+
+    a = A(2)
+    assert a.calls == 0
+    assert a.prop == 2
+    assert a.calls == 1
+    assert a.prop == 2
+    assert a.calls == 1
+    b = A(None)
+    assert b.prop == None
+
+
+def test_lazy_function():
+    module_name='xmlrpc.client'
+    function_name = 'gzip_decode'
+    lazy = lazy_function(module_name, function_name)
+    assert lazy(b'') == b''
+    assert module_name in sys.modules
+    assert function_name in str(lazy)
+    repr_lazy = repr(lazy)
+    assert 'LazyFunction' in repr_lazy
+    assert function_name in repr_lazy
+
+    lazy = lazy_function('sympy.core.cache', 'cheap')

.venv/lib/python3.11/site-packages/sympy/core/tests/test_compatibility.py

@@ -0,0 +1,6 @@
+from sympy.testing.pytest import warns_deprecated_sympy
+
+def test_compatibility_submodule():
+    # Test the sympy.core.compatibility deprecation warning
+    with warns_deprecated_sympy():
+        import sympy.core.compatibility # noqa:F401

.venv/lib/python3.11/site-packages/sympy/core/tests/test_complex.py

@@ -0,0 +1,226 @@
+from sympy.core.function import expand_complex
+from sympy.core.numbers import (I, Integer, Rational, pi)
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import (Abs, conjugate, im, re, sign)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.hyperbolic import (cosh, coth, sinh, tanh)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, cot, sin, tan)
+
+def test_complex():
+    a = Symbol("a", real=True)
+    b = Symbol("b", real=True)
+    e = (a + I*b)*(a - I*b)
+    assert e.expand() == a**2 + b**2
+    assert sqrt(I) == Pow(I, S.Half)
+
+
+def test_conjugate():
+    a = Symbol("a", real=True)
+    b = Symbol("b", real=True)
+    c = Symbol("c", imaginary=True)
+    d = Symbol("d", imaginary=True)
+    x = Symbol('x')
+    z = a + I*b + c + I*d
+    zc = a - I*b - c + I*d
+    assert conjugate(z) == zc
+    assert conjugate(exp(z)) == exp(zc)
+    assert conjugate(exp(I*x)) == exp(-I*conjugate(x))
+    assert conjugate(z**5) == zc**5
+    assert conjugate(abs(x)) == abs(x)
+    assert conjugate(sign(z)) == sign(zc)
+    assert conjugate(sin(z)) == sin(zc)
+    assert conjugate(cos(z)) == cos(zc)
+    assert conjugate(tan(z)) == tan(zc)
+    assert conjugate(cot(z)) == cot(zc)
+    assert conjugate(sinh(z)) == sinh(zc)
+    assert conjugate(cosh(z)) == cosh(zc)
+    assert conjugate(tanh(z)) == tanh(zc)
+    assert conjugate(coth(z)) == coth(zc)
+
+
+def test_abs1():
+    a = Symbol("a", real=True)
+    b = Symbol("b", real=True)
+    assert abs(a) == Abs(a)
+    assert abs(-a) == abs(a)
+    assert abs(a + I*b) == sqrt(a**2 + b**2)
+
+
+def test_abs2():
+    a = Symbol("a", real=False)
+    b = Symbol("b", real=False)
+    assert abs(a) != a
+    assert abs(-a) != a
+    assert abs(a + I*b) != sqrt(a**2 + b**2)
+
+
+def test_evalc():
+    x = Symbol("x", real=True)
+    y = Symbol("y", real=True)
+    z = Symbol("z")
+    assert ((x + I*y)**2).expand(complex=True) == x**2 + 2*I*x*y - y**2
+    assert expand_complex(z**(2*I)) == (re((re(z) + I*im(z))**(2*I)) +
+        I*im((re(z) + I*im(z))**(2*I)))
+    assert expand_complex(
+        z**(2*I), deep=False) == I*im(z**(2*I)) + re(z**(2*I))
+
+    assert exp(I*x) != cos(x) + I*sin(x)
+    assert exp(I*x).expand(complex=True) == cos(x) + I*sin(x)
+    assert exp(I*x + y).expand(complex=True) == exp(y)*cos(x) + I*sin(x)*exp(y)
+
+    assert sin(I*x).expand(complex=True) == I * sinh(x)
+    assert sin(x + I*y).expand(complex=True) == sin(x)*cosh(y) + \
+        I * sinh(y) * cos(x)
+
+    assert cos(I*x).expand(complex=True) == cosh(x)
+    assert cos(x + I*y).expand(complex=True) == cos(x)*cosh(y) - \
+        I * sinh(y) * sin(x)
+
+    assert tan(I*x).expand(complex=True) == tanh(x) * I
+    assert tan(x + I*y).expand(complex=True) == (
+        sin(2*x)/(cos(2*x) + cosh(2*y)) +
+        I*sinh(2*y)/(cos(2*x) + cosh(2*y)))
+
+    assert sinh(I*x).expand(complex=True) == I * sin(x)
+    assert sinh(x + I*y).expand(complex=True) == sinh(x)*cos(y) + \
+        I * sin(y) * cosh(x)
+
+    assert cosh(I*x).expand(complex=True) == cos(x)
+    assert cosh(x + I*y).expand(complex=True) == cosh(x)*cos(y) + \
+        I * sin(y) * sinh(x)
+
+    assert tanh(I*x).expand(complex=True) == tan(x) * I
+    assert tanh(x + I*y).expand(complex=True) == (
+        (sinh(x)*cosh(x) + I*cos(y)*sin(y)) /
+        (sinh(x)**2 + cos(y)**2)).expand()
+
+
+def test_pythoncomplex():
+    x = Symbol("x")
+    assert 4j*x != 4*x*I
+    assert 4j*x == 4.0*x*I
+    assert 4.1j*x != 4*x*I
+
+
+def test_rootcomplex():
+    R = Rational
+    assert ((+1 + I)**R(1, 2)).expand(
+        complex=True) == 2**R(1, 4)*cos(  pi/8) + 2**R(1, 4)*sin(  pi/8)*I
+    assert ((-1 - I)**R(1, 2)).expand(
+        complex=True) == 2**R(1, 4)*cos(3*pi/8) - 2**R(1, 4)*sin(3*pi/8)*I
+    assert (sqrt(-10)*I).as_real_imag() == (-sqrt(10), 0)
+
+
+def test_expand_inverse():
+    assert (1/(1 + I)).expand(complex=True) == (1 - I)/2
+    assert ((1 + 2*I)**(-2)).expand(complex=True) == (-3 - 4*I)/25
+    assert ((1 + I)**(-8)).expand(complex=True) == Rational(1, 16)
+
+
+def test_expand_complex():
+    assert ((2 + 3*I)**10).expand(complex=True) == -341525 - 145668*I
+    # the following two tests are to ensure the SymPy uses an efficient
+    # algorithm for calculating powers of complex numbers. They should execute
+    # in something like 0.01s.
+    assert ((2 + 3*I)**1000).expand(complex=True) == \
+        -81079464736246615951519029367296227340216902563389546989376269312984127074385455204551402940331021387412262494620336565547972162814110386834027871072723273110439771695255662375718498785908345629702081336606863762777939617745464755635193139022811989314881997210583159045854968310911252660312523907616129080027594310008539817935736331124833163907518549408018652090650537035647520296539436440394920287688149200763245475036722326561143851304795139005599209239350981457301460233967137708519975586996623552182807311159141501424576682074392689622074945519232029999 + \
+        46938745946789557590804551905243206242164799136976022474337918748798900569942573265747576032611189047943842446167719177749107138603040963603119861476016947257034472364028585381714774667326478071264878108114128915685688115488744955550920239128462489496563930809677159214598114273887061533057125164518549173898349061972857446844052995037423459472376202251620778517659247970283904820245958198842631651569984310559418135975795868314764489884749573052997832686979294085577689571149679540256349988338406458116270429842222666345146926395233040564229555893248370000*I
+    assert ((2 + 3*I/4)**1000).expand(complex=True) == \
+        Integer(1)*37079892761199059751745775382463070250205990218394308874593455293485167797989691280095867197640410033222367257278387021789651672598831503296531725827158233077451476545928116965316544607115843772405184272449644892857783761260737279675075819921259597776770965829089907990486964515784097181964312256560561065607846661496055417619388874421218472707497847700629822858068783288579581649321248495739224020822198695759609598745114438265083593711851665996586461937988748911532242908776883696631067311443171682974330675406616373422505939887984366289623091300746049101284856530270685577940283077888955692921951247230006346681086274961362500646889925803654263491848309446197554307105991537357310209426736453173441104334496173618419659521888945605315751089087820455852582920963561495787655250624781448951403353654348109893478206364632640344111022531861683064175862889459084900614967785405977231549003280842218501570429860550379522498497412180001/114813069527425452423283320117768198402231770208869520047764273682576626139237031385665948631650626991844596463898746277344711896086305533142593135616665318539129989145312280000688779148240044871428926990063486244781615463646388363947317026040466353970904996558162398808944629605623311649536164221970332681344168908984458505602379484807914058900934776500429002716706625830522008132236281291761267883317206598995396418127021779858404042159853183251540889433902091920554957783589672039160081957216630582755380425583726015528348786419432054508915275783882625175435528800822842770817965453762184851149029376 + \
+        I*421638390580169706973991429333213477486930178424989246669892530737775352519112934278994501272111385966211392610029433824534634841747911783746811994443436271013377059560245191441549885048056920190833693041257216263519792201852046825443439142932464031501882145407459174948712992271510309541474392303461939389368955986650538525895866713074543004916049550090364398070215427272240155060576252568700906004691224321432509053286859100920489253598392100207663785243368195857086816912514025693453058403158416856847185079684216151337200057494966741268925263085619240941610301610538225414050394612058339070756009433535451561664522479191267503989904464718368605684297071150902631208673621618217106272361061676184840810762902463998065947687814692402219182668782278472952758690939877465065070481351343206840649517150634973307937551168752642148704904383991876969408056379195860410677814566225456558230131911142229028179902418223009651437985670625/1793954211366022694113801876840128100034871409513586250746316776290259783425578615401030447369541046747571819748417910583511123376348523955353017744010395602173906080395504375010762174191250701116076984219741972574712741619474818186676828531882286780795390571221287481389759837587864244524002565968286448146002639202882164150037179450123657170327105882819203167448541028601906377066191895183769810676831353109303069033234715310287563158747705988305326397404720186258671215368588625611876280581509852855552819149745718992630449787803625851701801184123166018366180137512856918294030710215034138299203584
+    assert ((2 + 3*I)**-1000).expand(complex=True) == \
+        Integer(1)*-81079464736246615951519029367296227340216902563389546989376269312984127074385455204551402940331021387412262494620336565547972162814110386834027871072723273110439771695255662375718498785908345629702081336606863762777939617745464755635193139022811989314881997210583159045854968310911252660312523907616129080027594310008539817935736331124833163907518549408018652090650537035647520296539436440394920287688149200763245475036722326561143851304795139005599209239350981457301460233967137708519975586996623552182807311159141501424576682074392689622074945519232029999/8777125472973511649630750050295188683351430110097915876250894978429797369155961290321829625004920141758416719066805645579710744290541337680113772670040386863849283653078324415471816788604945889094925784900885812724984087843737442111926413818245854362613018058774368703971604921858023116665586358870612944209398056562604561248859926344335598822815885851096698226775053153403320782439987679978321289537645645163767251396759519805603090332694449553371530571613352311006350058217982509738362083094920649452123351717366337410243853659113315547584871655479914439219520157174729130746351059075207407866012574386726064196992865627149566238044625779078186624347183905913357718850537058578084932880569701242598663149911276357125355850792073635533676541250531086757377369962506979378337216411188347761901006460813413505861461267545723590468627854202034450569581626648934062198718362303420281555886394558137408159453103395918783625713213314350531051312551733021627153081075080140680608080529736975658786227362251632725009435866547613598753584705455955419696609282059191031962604169242974038517575645939316377801594539335940001 - Integer(1)*46938745946789557590804551905243206242164799136976022474337918748798900569942573265747576032611189047943842446167719177749107138603040963603119861476016947257034472364028585381714774667326478071264878108114128915685688115488744955550920239128462489496563930809677159214598114273887061533057125164518549173898349061972857446844052995037423459472376202251620778517659247970283904820245958198842631651569984310559418135975795868314764489884749573052997832686979294085577689571149679540256349988338406458116270429842222666345146926395233040564229555893248370000*I/8777125472973511649630750050295188683351430110097915876250894978429797369155961290321829625004920141758416719066805645579710744290541337680113772670040386863849283653078324415471816788604945889094925784900885812724984087843737442111926413818245854362613018058774368703971604921858023116665586358870612944209398056562604561248859926344335598822815885851096698226775053153403320782439987679978321289537645645163767251396759519805603090332694449553371530571613352311006350058217982509738362083094920649452123351717366337410243853659113315547584871655479914439219520157174729130746351059075207407866012574386726064196992865627149566238044625779078186624347183905913357718850537058578084932880569701242598663149911276357125355850792073635533676541250531086757377369962506979378337216411188347761901006460813413505861461267545723590468627854202034450569581626648934062198718362303420281555886394558137408159453103395918783625713213314350531051312551733021627153081075080140680608080529736975658786227362251632725009435866547613598753584705455955419696609282059191031962604169242974038517575645939316377801594539335940001
+    assert ((2 + 3*I/4)**-1000).expand(complex=True) == \
+        Integer(1)*4257256305661027385394552848555894604806501409793288342610746813288539790051927148781268212212078237301273165351052934681382567968787279534591114913777456610214738290619922068269909423637926549603264174216950025398244509039145410016404821694746262142525173737175066432954496592560621330313807235750500564940782099283410261748370262433487444897446779072067625787246390824312580440138770014838135245148574339248259670887549732495841810961088930810608893772914812838358159009303794863047635845688453859317690488124382253918725010358589723156019888846606295866740117645571396817375322724096486161308083462637370825829567578309445855481578518239186117686659177284332344643124760453112513611749309168470605289172320376911472635805822082051716625171429727162039621902266619821870482519063133136820085579315127038372190224739238686708451840610064871885616258831386810233957438253532027049148030157164346719204500373766157143311767338973363806106967439378604898250533766359989107510507493549529158818602327525235240510049484816090584478644771183158342479140194633579061295740839490629457435283873180259847394582069479062820225159699506175855369539201399183443253793905149785994830358114153241481884290274629611529758663543080724574566578220908907477622643689220814376054314972190402285121776593824615083669045183404206291739005554569305329760211752815718335731118664756831942466773261465213581616104242113894521054475516019456867271362053692785300826523328020796670205463390909136593859765912483565093461468865534470710132881677639651348709376/2103100954337624833663208713697737151593634525061637972297915388685604042449504336765884978184588688426595940401280828953096857809292320006227881797146858511436638446932833617514351442216409828605662238790280753075176269765767010004889778647709740770757817960711900340755635772183674511158570690702969774966791073165467918123298694584729211212414462628433370481195120564586361368504153395406845170075275051749019600057116719726628746724489572189061061036426955163696859127711110719502594479795200686212257570291758725259007379710596548777812659422174199194837355646482046783616494013289495563083118517507178847555801163089723056310287760875135196081975602765511153122381201303871673391366630940702817360340900568748719988954847590748960761446218262344767250783946365392689256634180417145926390656439421745644011831124277463643383712803287985472471755648426749842410972650924240795946699346613614779460399530274263580007672855851663196114585312432954432654691485867618908420370875753749297487803461900447407917655296784879220450937110470920633595689721819488638484547259978337741496090602390463594556401615298457456112485536498177883358587125449801777718900375736758266215245325999241624148841915093787519330809347240990363802360596034171167818310322276373120180985148650099673289383722502488957717848531612020897298448601714154586319660314294591620415272119454982220034319689607295960162971300417552364254983071768070124456169427638371140064235083443242844616326538396503937972586505546495649094344512270582463639152160238137952390380581401171977159154009407415523525096743009110916334144716516647041176989758534635251844947906038080852185583742296318878233394998111078843229681030277039104786225656992262073797524057992347971177720807155842376332851559276430280477639539393920006008737472164850104411971830120295750221200029811143140323763349636629725073624360001 - Integer(1)*3098214262599218784594285246258841485430681674561917573155883806818465520660668045042109232930382494608383663464454841313154390741655282039877410154577448327874989496074260116195788919037407420625081798124301494353693248757853222257918294662198297114746822817460991242508743651430439120439020484502408313310689912381846149597061657483084652685283853595100434135149479564507015504022249330340259111426799121454516345905101620532787348293877485702600390665276070250119465888154331218827342488849948540687659846652377277250614246402784754153678374932540789808703029043827352976139228402417432199779415751301480406673762521987999573209628597459357964214510139892316208670927074795773830798600837815329291912002136924506221066071242281626618211060464126372574400100990746934953437169840312584285942093951405864225230033279614235191326102697164613004299868695519642598882914862568516635347204441042798206770888274175592401790040170576311989738272102077819127459014286741435419468254146418098278519775722104890854275995510700298782146199325790002255362719776098816136732897323406228294203133323296591166026338391813696715894870956511298793595675308998014158717167429941371979636895553724830981754579086664608880698350866487717403917070872269853194118364230971216854931998642990452908852258008095741042117326241406479532880476938937997238098399302185675832474590293188864060116934035867037219176916416481757918864533515526389079998129329045569609325290897577497835388451456680707076072624629697883854217331728051953671643278797380171857920000*I/2103100954337624833663208713697737151593634525061637972297915388685604042449504336765884978184588688426595940401280828953096857809292320006227881797146858511436638446932833617514351442216409828605662238790280753075176269765767010004889778647709740770757817960711900340755635772183674511158570690702969774966791073165467918123298694584729211212414462628433370481195120564586361368504153395406845170075275051749019600057116719726628746724489572189061061036426955163696859127711110719502594479795200686212257570291758725259007379710596548777812659422174199194837355646482046783616494013289495563083118517507178847555801163089723056310287760875135196081975602765511153122381201303871673391366630940702817360340900568748719988954847590748960761446218262344767250783946365392689256634180417145926390656439421745644011831124277463643383712803287985472471755648426749842410972650924240795946699346613614779460399530274263580007672855851663196114585312432954432654691485867618908420370875753749297487803461900447407917655296784879220450937110470920633595689721819488638484547259978337741496090602390463594556401615298457456112485536498177883358587125449801777718900375736758266215245325999241624148841915093787519330809347240990363802360596034171167818310322276373120180985148650099673289383722502488957717848531612020897298448601714154586319660314294591620415272119454982220034319689607295960162971300417552364254983071768070124456169427638371140064235083443242844616326538396503937972586505546495649094344512270582463639152160238137952390380581401171977159154009407415523525096743009110916334144716516647041176989758534635251844947906038080852185583742296318878233394998111078843229681030277039104786225656992262073797524057992347971177720807155842376332851559276430280477639539393920006008737472164850104411971830120295750221200029811143140323763349636629725073624360001
+
+    a = Symbol('a', real=True)
+    b = Symbol('b', real=True)
+    assert exp(a*(2 + I*b)).expand(complex=True) == \
+        I*exp(2*a)*sin(a*b) + exp(2*a)*cos(a*b)
+
+
+def test_expand():
+    f = (16 - 2*sqrt(29))**2
+    assert f.expand() == 372 - 64*sqrt(29)
+    f = (Integer(1)/2 + I/2)**10
+    assert f.expand() == I/32
+    f = (Integer(1)/2 + I)**10
+    assert f.expand() == Integer(237)/1024 - 779*I/256
+
+
+def test_re_im1652():
+    x = Symbol('x')
+    assert re(x) == re(conjugate(x))
+    assert im(x) == - im(conjugate(x))
+    assert im(x)*re(conjugate(x)) + im(conjugate(x)) * re(x) == 0
+
+
+def test_issue_5084():
+    x = Symbol('x')
+    assert ((x + x*I)/(1 + I)).as_real_imag() == (re((x + I*x)/(1 + I)
+            ), im((x + I*x)/(1 + I)))
+
+
+def test_issue_5236():
+    assert (cos(1 + I)**3).as_real_imag() == (-3*sin(1)**2*sinh(1)**2*cos(1)*cosh(1) +
+        cos(1)**3*cosh(1)**3, -3*cos(1)**2*cosh(1)**2*sin(1)*sinh(1) + sin(1)**3*sinh(1)**3)
+
+
+def test_real_imag():
+    x, y, z = symbols('x, y, z')
+    X, Y, Z = symbols('X, Y, Z', commutative=False)
+    a = Symbol('a', real=True)
+    assert (2*a*x).as_real_imag() == (2*a*re(x), 2*a*im(x))
+
+    # issue 5395:
+    assert (x*x.conjugate()).as_real_imag() == (Abs(x)**2, 0)
+    assert im(x*x.conjugate()) == 0
+    assert im(x*y.conjugate()*z*y) == im(x*z)*Abs(y)**2
+    assert im(x*y.conjugate()*x*y) == im(x**2)*Abs(y)**2
+    assert im(Z*y.conjugate()*X*y) == im(Z*X)*Abs(y)**2
+    assert im(X*X.conjugate()) == im(X*X.conjugate(), evaluate=False)
+    assert (sin(x)*sin(x).conjugate()).as_real_imag() == \
+        (Abs(sin(x))**2, 0)
+
+    # issue 6573:
+    assert (x**2).as_real_imag() == (re(x)**2 - im(x)**2, 2*re(x)*im(x))
+
+    # issue 6428:
+    r = Symbol('r', real=True)
+    i = Symbol('i', imaginary=True)
+    assert (i*r*x).as_real_imag() == (I*i*r*im(x), -I*i*r*re(x))
+    assert (i*r*x*(y + 2)).as_real_imag() == (
+        I*i*r*(re(y) + 2)*im(x) + I*i*r*re(x)*im(y),
+        -I*i*r*(re(y) + 2)*re(x) + I*i*r*im(x)*im(y))
+
+    # issue 7106:
+    assert ((1 + I)/(1 - I)).as_real_imag() == (0, 1)
+    assert ((1 + 2*I)*(1 + 3*I)).as_real_imag() == (-5, 5)
+
+
+def test_pow_issue_1724():
+    e = ((S.NegativeOne)**(S.One/3))
+    assert e.conjugate().n() == e.n().conjugate()
+    e = S('-2/3 - (-29/54 + sqrt(93)/18)**(1/3) - 1/(9*(-29/54 + sqrt(93)/18)**(1/3))')
+    assert e.conjugate().n() == e.n().conjugate()
+    e = 2**I
+    assert e.conjugate().n() == e.n().conjugate()
+
+
+def test_issue_5429():
+    assert sqrt(I).conjugate() != sqrt(I)
+
+def test_issue_4124():
+    from sympy.core.numbers import oo
+    assert expand_complex(I*oo) == oo*I
+
+def test_issue_11518():
+    x = Symbol("x", real=True)
+    y = Symbol("y", real=True)
+    r = sqrt(x**2 + y**2)
+    assert conjugate(r) == r
+    s = abs(x + I * y)
+    assert conjugate(s) == r

.venv/lib/python3.11/site-packages/sympy/core/tests/test_constructor_postprocessor.py

@@ -0,0 +1,87 @@
+from sympy.core.basic import Basic
+from sympy.core.mul import Mul
+from sympy.core.symbol import (Symbol, symbols)
+
+from sympy.testing.pytest import XFAIL
+
+class SymbolInMulOnce(Symbol):
+    # Test class for a symbol that can only appear once in a `Mul` expression.
+    pass
+
+
+Basic._constructor_postprocessor_mapping[SymbolInMulOnce] = {
+    "Mul": [lambda x: x],
+    "Pow": [lambda x: x.base if isinstance(x.base, SymbolInMulOnce) else x],
+    "Add": [lambda x: x],
+}
+
+
+def _postprocess_SymbolRemovesOtherSymbols(expr):
+    args = tuple(i for i in expr.args if not isinstance(i, Symbol) or isinstance(i, SymbolRemovesOtherSymbols))
+    if args == expr.args:
+        return expr
+    return Mul.fromiter(args)
+
+
+class SymbolRemovesOtherSymbols(Symbol):
+    # Test class for a symbol that removes other symbols in `Mul`.
+    pass
+
+Basic._constructor_postprocessor_mapping[SymbolRemovesOtherSymbols] = {
+    "Mul": [_postprocess_SymbolRemovesOtherSymbols],
+}
+
+class SubclassSymbolInMulOnce(SymbolInMulOnce):
+    pass
+
+class SubclassSymbolRemovesOtherSymbols(SymbolRemovesOtherSymbols):
+    pass
+
+
+def test_constructor_postprocessors1():
+    x = SymbolInMulOnce("x")
+    y = SymbolInMulOnce("y")
+    assert isinstance(3*x, Mul)
+    assert (3*x).args == (3, x)
+    assert x*x == x
+    assert 3*x*x == 3*x
+    assert 2*x*x + x == 3*x
+    assert x**3*y*y == x*y
+    assert x**5 + y*x**3 == x + x*y
+
+    w = SymbolRemovesOtherSymbols("w")
+    assert x*w == w
+    assert (3*w).args == (3, w)
+    assert set((w + x).args) == {x, w}
+
+def test_constructor_postprocessors2():
+    x = SubclassSymbolInMulOnce("x")
+    y = SubclassSymbolInMulOnce("y")
+    assert isinstance(3*x, Mul)
+    assert (3*x).args == (3, x)
+    assert x*x == x
+    assert 3*x*x == 3*x
+    assert 2*x*x + x == 3*x
+    assert x**3*y*y == x*y
+    assert x**5 + y*x**3 == x + x*y
+
+    w = SubclassSymbolRemovesOtherSymbols("w")
+    assert x*w == w
+    assert (3*w).args == (3, w)
+    assert set((w + x).args) == {x, w}
+
+
+@XFAIL
+def test_subexpression_postprocessors():
+    # The postprocessors used to work with subexpressions, but the
+    # functionality was removed. See #15948.
+    a = symbols("a")
+    x = SymbolInMulOnce("x")
+    w = SymbolRemovesOtherSymbols("w")
+    assert 3*a*w**2 == 3*w**2
+    assert 3*a*x**3*w**2 == 3*w**2
+
+    x = SubclassSymbolInMulOnce("x")
+    w = SubclassSymbolRemovesOtherSymbols("w")
+    assert 3*a*w**2 == 3*w**2
+    assert 3*a*x**3*w**2 == 3*w**2

.venv/lib/python3.11/site-packages/sympy/core/tests/test_containers.py

@@ -0,0 +1,217 @@
+from collections import defaultdict
+
+from sympy.core.basic import Basic
+from sympy.core.containers import (Dict, Tuple)
+from sympy.core.numbers import Integer
+from sympy.core.kind import NumberKind
+from sympy.matrices.kind import MatrixKind
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.core.sympify import sympify
+from sympy.matrices.dense import Matrix
+from sympy.sets.sets import FiniteSet
+from sympy.core.containers import tuple_wrapper, TupleKind
+from sympy.core.expr import unchanged
+from sympy.core.function import Function, Lambda
+from sympy.core.relational import Eq
+from sympy.testing.pytest import raises
+from sympy.utilities.iterables import is_sequence, iterable
+
+from sympy.abc import x, y
+
+
+def test_Tuple():
+    t = (1, 2, 3, 4)
+    st = Tuple(*t)
+    assert set(sympify(t)) == set(st)
+    assert len(t) == len(st)
+    assert set(sympify(t[:2])) == set(st[:2])
+    assert isinstance(st[:], Tuple)
+    assert st == Tuple(1, 2, 3, 4)
+    assert st.func(*st.args) == st
+    p, q, r, s = symbols('p q r s')
+    t2 = (p, q, r, s)
+    st2 = Tuple(*t2)
+    assert st2.atoms() == set(t2)
+    assert st == st2.subs({p: 1, q: 2, r: 3, s: 4})
+    # issue 5505
+    assert all(isinstance(arg, Basic) for arg in st.args)
+    assert Tuple(p, 1).subs(p, 0) == Tuple(0, 1)
+    assert Tuple(p, Tuple(p, 1)).subs(p, 0) == Tuple(0, Tuple(0, 1))
+
+    assert Tuple(t2) == Tuple(Tuple(*t2))
+    assert Tuple.fromiter(t2) == Tuple(*t2)
+    assert Tuple.fromiter(x for x in range(4)) == Tuple(0, 1, 2, 3)
+    assert st2.fromiter(st2.args) == st2
+
+
+def test_Tuple_contains():
+    t1, t2 = Tuple(1), Tuple(2)
+    assert t1 in Tuple(1, 2, 3, t1, Tuple(t2))
+    assert t2 not in Tuple(1, 2, 3, t1, Tuple(t2))
+
+
+def test_Tuple_concatenation():
+    assert Tuple(1, 2) + Tuple(3, 4) == Tuple(1, 2, 3, 4)
+    assert (1, 2) + Tuple(3, 4) == Tuple(1, 2, 3, 4)
+    assert Tuple(1, 2) + (3, 4) == Tuple(1, 2, 3, 4)
+    raises(TypeError, lambda: Tuple(1, 2) + 3)
+    raises(TypeError, lambda: 1 + Tuple(2, 3))
+
+    #the Tuple case in __radd__ is only reached when a subclass is involved
+    class Tuple2(Tuple):
+        def __radd__(self, other):
+            return Tuple.__radd__(self, other + other)
+    assert Tuple(1, 2) + Tuple2(3, 4) == Tuple(1, 2, 1, 2, 3, 4)
+    assert Tuple2(1, 2) + Tuple(3, 4) == Tuple(1, 2, 3, 4)
+
+
+def test_Tuple_equality():
+    assert not isinstance(Tuple(1, 2), tuple)
+    assert (Tuple(1, 2) == (1, 2)) is True
+    assert (Tuple(1, 2) != (1, 2)) is False
+    assert (Tuple(1, 2) == (1, 3)) is False
+    assert (Tuple(1, 2) != (1, 3)) is True
+    assert (Tuple(1, 2) == Tuple(1, 2)) is True
+    assert (Tuple(1, 2) != Tuple(1, 2)) is False
+    assert (Tuple(1, 2) == Tuple(1, 3)) is False
+    assert (Tuple(1, 2) != Tuple(1, 3)) is True
+
+
+def test_Tuple_Eq():
+    assert Eq(Tuple(), Tuple()) is S.true
+    assert Eq(Tuple(1), 1) is S.false
+    assert Eq(Tuple(1, 2), Tuple(1)) is S.false
+    assert Eq(Tuple(1), Tuple(1)) is S.true
+    assert Eq(Tuple(1, 2), Tuple(1, 3)) is S.false
+    assert Eq(Tuple(1, 2), Tuple(1, 2)) is S.true
+    assert unchanged(Eq, Tuple(1, x), Tuple(1, 2))
+    assert Eq(Tuple(1, x), Tuple(1, 2)).subs(x, 2) is S.true
+    assert unchanged(Eq, Tuple(1, 2), x)
+    f = Function('f')
+    assert unchanged(Eq, Tuple(1), f(x))
+    assert Eq(Tuple(1), f(x)).subs(x, 1).subs(f, Lambda(y, (y,))) is S.true
+
+
+def test_Tuple_comparision():
+    assert (Tuple(1, 3) >= Tuple(-10, 30)) is S.true
+    assert (Tuple(1, 3) <= Tuple(-10, 30)) is S.false
+    assert (Tuple(1, 3) >= Tuple(1, 3)) is S.true
+    assert (Tuple(1, 3) <= Tuple(1, 3)) is S.true
+
+
+def test_Tuple_tuple_count():
+    assert Tuple(0, 1, 2, 3).tuple_count(4) == 0
+    assert Tuple(0, 4, 1, 2, 3).tuple_count(4) == 1
+    assert Tuple(0, 4, 1, 4, 2, 3).tuple_count(4) == 2
+    assert Tuple(0, 4, 1, 4, 2, 4, 3).tuple_count(4) == 3
+
+
+def test_Tuple_index():
+    assert Tuple(4, 0, 1, 2, 3).index(4) == 0
+    assert Tuple(0, 4, 1, 2, 3).index(4) == 1
+    assert Tuple(0, 1, 4, 2, 3).index(4) == 2
+    assert Tuple(0, 1, 2, 4, 3).index(4) == 3
+    assert Tuple(0, 1, 2, 3, 4).index(4) == 4
+
+    raises(ValueError, lambda: Tuple(0, 1, 2, 3).index(4))
+    raises(ValueError, lambda: Tuple(4, 0, 1, 2, 3).index(4, 1))
+    raises(ValueError, lambda: Tuple(0, 1, 2, 3, 4).index(4, 1, 4))
+
+
+def test_Tuple_mul():
+    assert Tuple(1, 2, 3)*2 == Tuple(1, 2, 3, 1, 2, 3)
+    assert 2*Tuple(1, 2, 3) == Tuple(1, 2, 3, 1, 2, 3)
+    assert Tuple(1, 2, 3)*Integer(2) == Tuple(1, 2, 3, 1, 2, 3)
+    assert Integer(2)*Tuple(1, 2, 3) == Tuple(1, 2, 3, 1, 2, 3)
+
+    raises(TypeError, lambda: Tuple(1, 2, 3)*S.Half)
+    raises(TypeError, lambda: S.Half*Tuple(1, 2, 3))
+
+
+def test_tuple_wrapper():
+
+    @tuple_wrapper
+    def wrap_tuples_and_return(*t):
+        return t
+
+    p = symbols('p')
+    assert wrap_tuples_and_return(p, 1) == (p, 1)
+    assert wrap_tuples_and_return((p, 1)) == (Tuple(p, 1),)
+    assert wrap_tuples_and_return(1, (p, 2), 3) == (1, Tuple(p, 2), 3)
+
+
+def test_iterable_is_sequence():
+    ordered = [[], (), Tuple(), Matrix([[]])]
+    unordered = [set()]
+    not_sympy_iterable = [{}, '', '']
+    assert all(is_sequence(i) for i in ordered)
+    assert all(not is_sequence(i) for i in unordered)
+    assert all(iterable(i) for i in ordered + unordered)
+    assert all(not iterable(i) for i in not_sympy_iterable)
+    assert all(iterable(i, exclude=None) for i in not_sympy_iterable)
+
+
+def test_TupleKind():
+    kind = TupleKind(NumberKind, MatrixKind(NumberKind))
+    assert Tuple(1, Matrix([1, 2])).kind is kind
+    assert Tuple(1, 2).kind is TupleKind(NumberKind, NumberKind)
+    assert Tuple(1, 2).kind.element_kind == (NumberKind, NumberKind)
+
+
+def test_Dict():
+    x, y, z = symbols('x y z')
+    d = Dict({x: 1, y: 2, z: 3})
+    assert d[x] == 1
+    assert d[y] == 2
+    raises(KeyError, lambda: d[2])
+    raises(KeyError, lambda: d['2'])
+    assert len(d) == 3
+    assert set(d.keys()) == {x, y, z}
+    assert set(d.values()) == {S.One, S(2), S(3)}
+    assert d.get(5, 'default') == 'default'
+    assert d.get('5', 'default') == 'default'
+    assert x in d and z in d and 5 not in d and '5' not in d
+    assert d.has(x) and d.has(1)  # SymPy Basic .has method
+
+    # Test input types
+    # input - a Python dict
+    # input - items as args - SymPy style
+    assert (Dict({x: 1, y: 2, z: 3}) ==
+            Dict((x, 1), (y, 2), (z, 3)))
+
+    raises(TypeError, lambda: Dict(((x, 1), (y, 2), (z, 3))))
+    with raises(NotImplementedError):
+        d[5] = 6  # assert immutability
+
+    assert set(
+        d.items()) == {Tuple(x, S.One), Tuple(y, S(2)), Tuple(z, S(3))}
+    assert set(d) == {x, y, z}
+    assert str(d) == '{x: 1, y: 2, z: 3}'
+    assert d.__repr__() == '{x: 1, y: 2, z: 3}'
+
+    # Test creating a Dict from a Dict.
+    d = Dict({x: 1, y: 2, z: 3})
+    assert d == Dict(d)
+
+    # Test for supporting defaultdict
+    d = defaultdict(int)
+    assert d[x] == 0
+    assert d[y] == 0
+    assert d[z] == 0
+    assert Dict(d)
+    d = Dict(d)
+    assert len(d) == 3
+    assert set(d.keys()) == {x, y, z}
+    assert set(d.values()) == {S.Zero, S.Zero, S.Zero}
+
+
+def test_issue_5788():
+    args = [(1, 2), (2, 1)]
+    for o in [Dict, Tuple, FiniteSet]:
+        # __eq__ and arg handling
+        if o != Tuple:
+            assert o(*args) == o(*reversed(args))
+        pair = [o(*args), o(*reversed(args))]
+        assert sorted(pair) == sorted(pair)
+        assert set(o(*args))  # doesn't fail

.venv/lib/python3.11/site-packages/sympy/core/tests/test_count_ops.py

@@ -0,0 +1,155 @@
+from sympy.concrete.summations import Sum
+from sympy.core.basic import Basic
+from sympy.core.function import (Derivative, Function, count_ops)
+from sympy.core.numbers import (I, Rational, pi)
+from sympy.core.relational import (Eq, Rel)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.integrals.integrals import Integral
+from sympy.logic.boolalg import (And, Equivalent, ITE, Implies, Nand,
+    Nor, Not, Or, Xor)
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.core.containers import Tuple
+
+x, y, z = symbols('x,y,z')
+a, b, c = symbols('a,b,c')
+
+def test_count_ops_non_visual():
+    def count(val):
+        return count_ops(val, visual=False)
+    assert count(x) == 0
+    assert count(x) is not S.Zero
+    assert count(x + y) == 1
+    assert count(x + y) is not S.One
+    assert count(x + y*x + 2*y) == 4
+    assert count({x + y: x}) == 1
+    assert count({x + y: S(2) + x}) is not S.One
+    assert count(x < y) == 1
+    assert count(Or(x,y)) == 1
+    assert count(And(x,y)) == 1
+    assert count(Not(x)) == 1
+    assert count(Nor(x,y)) == 2
+    assert count(Nand(x,y)) == 2
+    assert count(Xor(x,y)) == 1
+    assert count(Implies(x,y)) == 1
+    assert count(Equivalent(x,y)) == 1
+    assert count(ITE(x,y,z)) == 1
+    assert count(ITE(True,x,y)) == 0
+
+
+def test_count_ops_visual():
+    ADD, MUL, POW, SIN, COS, EXP, AND, D, G, M = symbols(
+        'Add Mul Pow sin cos exp And Derivative Integral Sum'.upper())
+    DIV, SUB, NEG = symbols('DIV SUB NEG')
+    LT, LE, GT, GE, EQ, NE = symbols('LT LE GT GE EQ NE')
+    NOT, OR, AND, XOR, IMPLIES, EQUIVALENT, _ITE, BASIC, TUPLE = symbols(
+        'Not Or And Xor Implies Equivalent ITE Basic Tuple'.upper())
+
+    def count(val):
+        return count_ops(val, visual=True)
+
+    assert count(7) is S.Zero
+    assert count(S(7)) is S.Zero
+    assert count(-1) == NEG
+    assert count(-2) == NEG
+    assert count(S(2)/3) == DIV
+    assert count(Rational(2, 3)) == DIV
+    assert count(pi/3) == DIV
+    assert count(-pi/3) == DIV + NEG
+    assert count(I - 1) == SUB
+    assert count(1 - I) == SUB
+    assert count(1 - 2*I) == SUB + MUL
+
+    assert count(x) is S.Zero
+    assert count(-x) == NEG
+    assert count(-2*x/3) == NEG + DIV + MUL
+    assert count(Rational(-2, 3)*x) == NEG + DIV + MUL
+    assert count(1/x) == DIV
+    assert count(1/(x*y)) == DIV + MUL
+    assert count(-1/x) == NEG + DIV
+    assert count(-2/x) == NEG + DIV
+    assert count(x/y) == DIV
+    assert count(-x/y) == NEG + DIV
+
+    assert count(x**2) == POW
+    assert count(-x**2) == POW + NEG
+    assert count(-2*x**2) == POW + MUL + NEG
+
+    assert count(x + pi/3) == ADD + DIV
+    assert count(x + S.One/3) == ADD + DIV
+    assert count(x + Rational(1, 3)) == ADD + DIV
+    assert count(x + y) == ADD
+    assert count(x - y) == SUB
+    assert count(y - x) == SUB
+    assert count(-1/(x - y)) == DIV + NEG + SUB
+    assert count(-1/(y - x)) == DIV + NEG + SUB
+    assert count(1 + x**y) == ADD + POW
+    assert count(1 + x + y) == 2*ADD
+    assert count(1 + x + y + z) == 3*ADD
+    assert count(1 + x**y + 2*x*y + y**2) == 3*ADD + 2*POW + 2*MUL
+    assert count(2*z + y + x + 1) == 3*ADD + MUL
+    assert count(2*z + y**17 + x + 1) == 3*ADD + MUL + POW
+    assert count(2*z + y**17 + x + sin(x)) == 3*ADD + POW + MUL + SIN
+    assert count(2*z + y**17 + x + sin(x**2)) == 3*ADD + MUL + 2*POW + SIN
+    assert count(2*z + y**17 + x + sin(
+        x**2) + exp(cos(x))) == 4*ADD + MUL + 2*POW + EXP + COS + SIN
+
+    assert count(Derivative(x, x)) == D
+    assert count(Integral(x, x) + 2*x/(1 + x)) == G + DIV + MUL + 2*ADD
+    assert count(Sum(x, (x, 1, x + 1)) + 2*x/(1 + x)) == M + DIV + MUL + 3*ADD
+    assert count(Basic()) is S.Zero
+
+    assert count({x + 1: sin(x)}) == ADD + SIN
+    assert count([x + 1, sin(x) + y, None]) == ADD + SIN + ADD
+    assert count({x + 1: sin(x), y: cos(x) + 1}) == SIN + COS + 2*ADD
+    assert count({}) is S.Zero
+    assert count([x + 1, sin(x)*y, None]) == SIN + ADD + MUL
+    assert count([]) is S.Zero
+
+    assert count(Basic()) == 0
+    assert count(Basic(Basic(),Basic(x,x+y))) == ADD + 2*BASIC
+    assert count(Basic(x, x + y)) == ADD + BASIC
+    assert [count(Rel(x, y, op)) for op in '< <= > >= == <> !='.split()
+        ] == [LT, LE, GT, GE, EQ, NE, NE]
+    assert count(Or(x, y)) == OR
+    assert count(And(x, y)) == AND
+    assert count(Or(x, Or(y, And(z, a)))) == AND + OR
+    assert count(Nor(x, y)) == NOT + OR
+    assert count(Nand(x, y)) == NOT + AND
+    assert count(Xor(x, y)) == XOR
+    assert count(Implies(x, y)) == IMPLIES
+    assert count(Equivalent(x, y)) == EQUIVALENT
+    assert count(ITE(x, y, z)) == _ITE
+    assert count([Or(x, y), And(x, y), Basic(x + y)]
+        ) == ADD + AND + BASIC + OR
+
+    assert count(Basic(Tuple(x))) == BASIC + TUPLE
+    #It checks that TUPLE is counted as an operation.
+
+    assert count(Eq(x + y, S(2))) == ADD + EQ
+
+
+def test_issue_9324():
+    def count(val):
+        return count_ops(val, visual=False)
+
+    M = MatrixSymbol('M', 10, 10)
+    assert count(M[0, 0]) == 0
+    assert count(2 * M[0, 0] + M[5, 7]) == 2
+    P = MatrixSymbol('P', 3, 3)
+    Q = MatrixSymbol('Q', 3, 3)
+    assert count(P + Q) == 1
+    m = Symbol('m', integer=True)
+    n = Symbol('n', integer=True)
+    M = MatrixSymbol('M', m + n, m * m)
+    assert count(M[0, 1]) == 2
+
+
+def test_issue_21532():
+    f = Function('f')
+    g = Function('g')
+    FUNC_F, FUNC_G = symbols('FUNC_F, FUNC_G')
+    assert f(x).count_ops(visual=True) == FUNC_F
+    assert g(x).count_ops(visual=True) == FUNC_G

.venv/lib/python3.11/site-packages/sympy/core/tests/test_diff.py

@@ -0,0 +1,160 @@
+from sympy.concrete.summations import Sum
+from sympy.core.expr import Expr
+from sympy.core.function import (Derivative, Function, diff, Subs)
+from sympy.core.numbers import (I, Rational, pi)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.complexes import (im, re)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import Max
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (cos, cot, sin, tan)
+from sympy.tensor.array.ndim_array import NDimArray
+from sympy.testing.pytest import raises
+from sympy.abc import a, b, c, x, y, z
+
+def test_diff():
+    assert Rational(1, 3).diff(x) is S.Zero
+    assert I.diff(x) is S.Zero
+    assert pi.diff(x) is S.Zero
+    assert x.diff(x, 0) == x
+    assert (x**2).diff(x, 2, x) == 0
+    assert (x**2).diff((x, 2), x) == 0
+    assert (x**2).diff((x, 1), x) == 2
+    assert (x**2).diff((x, 1), (x, 1)) == 2
+    assert (x**2).diff((x, 2)) == 2
+    assert (x**2).diff(x, y, 0) == 2*x
+    assert (x**2).diff(x, (y, 0)) == 2*x
+    assert (x**2).diff(x, y) == 0
+    raises(ValueError, lambda: x.diff(1, x))
+
+    p = Rational(5)
+    e = a*b + b**p
+    assert e.diff(a) == b
+    assert e.diff(b) == a + 5*b**4
+    assert e.diff(b).diff(a) == Rational(1)
+    e = a*(b + c)
+    assert e.diff(a) == b + c
+    assert e.diff(b) == a
+    assert e.diff(b).diff(a) == Rational(1)
+    e = c**p
+    assert e.diff(c, 6) == Rational(0)
+    assert e.diff(c, 5) == Rational(120)
+    e = c**Rational(2)
+    assert e.diff(c) == 2*c
+    e = a*b*c
+    assert e.diff(c) == a*b
+
+
+def test_diff2():
+    n3 = Rational(3)
+    n2 = Rational(2)
+    n6 = Rational(6)
+
+    e = n3*(-n2 + x**n2)*cos(x) + x*(-n6 + x**n2)*sin(x)
+    assert e == 3*(-2 + x**2)*cos(x) + x*(-6 + x**2)*sin(x)
+    assert e.diff(x).expand() == x**3*cos(x)
+
+    e = (x + 1)**3
+    assert e.diff(x) == 3*(x + 1)**2
+    e = x*(x + 1)**3
+    assert e.diff(x) == (x + 1)**3 + 3*x*(x + 1)**2
+    e = 2*exp(x*x)*x
+    assert e.diff(x) == 2*exp(x**2) + 4*x**2*exp(x**2)
+
+
+def test_diff3():
+    p = Rational(5)
+    e = a*b + sin(b**p)
+    assert e == a*b + sin(b**5)
+    assert e.diff(a) == b
+    assert e.diff(b) == a + 5*b**4*cos(b**5)
+    e = tan(c)
+    assert e == tan(c)
+    assert e.diff(c) in [cos(c)**(-2), 1 + sin(c)**2/cos(c)**2, 1 + tan(c)**2]
+    e = c*log(c) - c
+    assert e == -c + c*log(c)
+    assert e.diff(c) == log(c)
+    e = log(sin(c))
+    assert e == log(sin(c))
+    assert e.diff(c) in [sin(c)**(-1)*cos(c), cot(c)]
+    e = (Rational(2)**a/log(Rational(2)))
+    assert e == 2**a*log(Rational(2))**(-1)
+    assert e.diff(a) == 2**a
+
+
+def test_diff_no_eval_derivative():
+    class My(Expr):
+        def __new__(cls, x):
+            return Expr.__new__(cls, x)
+
+    # My doesn't have its own _eval_derivative method
+    assert My(x).diff(x).func is Derivative
+    assert My(x).diff(x, 3).func is Derivative
+    assert re(x).diff(x, 2) == Derivative(re(x), (x, 2))  # issue 15518
+    assert diff(NDimArray([re(x), im(x)]), (x, 2)) == NDimArray(
+        [Derivative(re(x), (x, 2)), Derivative(im(x), (x, 2))])
+    # it doesn't have y so it shouldn't need a method for this case
+    assert My(x).diff(y) == 0
+
+
+def test_speed():
+    # this should return in 0.0s. If it takes forever, it's wrong.
+    assert x.diff(x, 10**8) == 0
+
+
+def test_deriv_noncommutative():
+    A = Symbol("A", commutative=False)
+    f = Function("f")
+    assert A*f(x)*A == f(x)*A**2
+    assert A*f(x).diff(x)*A == f(x).diff(x) * A**2
+
+
+def test_diff_nth_derivative():
+    f =  Function("f")
+    n = Symbol("n", integer=True)
+
+    expr = diff(sin(x), (x, n))
+    expr2 = diff(f(x), (x, 2))
+    expr3 = diff(f(x), (x, n))
+
+    assert expr.subs(sin(x), cos(-x)) == Derivative(cos(-x), (x, n))
+    assert expr.subs(n, 1).doit() == cos(x)
+    assert expr.subs(n, 2).doit() == -sin(x)
+
+    assert expr2.subs(Derivative(f(x), x), y) == Derivative(y, x)
+    # Currently not supported (cannot determine if `n > 1`):
+    #assert expr3.subs(Derivative(f(x), x), y) == Derivative(y, (x, n-1))
+    assert expr3 == Derivative(f(x), (x, n))
+
+    assert diff(x, (x, n)) == Piecewise((x, Eq(n, 0)), (1, Eq(n, 1)), (0, True))
+    assert diff(2*x, (x, n)).dummy_eq(
+        Sum(Piecewise((2*x*factorial(n)/(factorial(y)*factorial(-y + n)),
+        Eq(y, 0) & Eq(Max(0, -y + n), 0)),
+        (2*factorial(n)/(factorial(y)*factorial(-y + n)), Eq(y, 0) & Eq(Max(0,
+        -y + n), 1)), (0, True)), (y, 0, n)))
+    # TODO: assert diff(x**2, (x, n)) == x**(2-n)*ff(2, n)
+    exprm = x*sin(x)
+    mul_diff = diff(exprm, (x, n))
+    assert isinstance(mul_diff, Sum)
+    for i in range(5):
+        assert mul_diff.subs(n, i).doit() == exprm.diff((x, i)).expand()
+
+    exprm2 = 2*y*x*sin(x)*cos(x)*log(x)*exp(x)
+    dex = exprm2.diff((x, n))
+    assert isinstance(dex, Sum)
+    for i in range(7):
+        assert dex.subs(n, i).doit().expand() == \
+        exprm2.diff((x, i)).expand()
+
+    assert (cos(x)*sin(y)).diff([[x, y, z]]) == NDimArray([
+        -sin(x)*sin(y), cos(x)*cos(y), 0])
+
+
+def test_issue_16160():
+    assert Derivative(x**3, (x, x)).subs(x, 2) == Subs(
+        Derivative(x**3, (x, 2)), x, 2)
+    assert Derivative(1 + x**3, (x, x)).subs(x, 0
+        ) == Derivative(1 + y**3, (y, 0)).subs(y, 0)

.venv/lib/python3.11/site-packages/sympy/core/tests/test_equal.py

@@ -0,0 +1,89 @@
+from sympy.core.numbers import Rational
+from sympy.core.symbol import (Dummy, Symbol)
+from sympy.functions.elementary.exponential import exp
+
+
+def test_equal():
+    b = Symbol("b")
+    a = Symbol("a")
+    e1 = a + b
+    e2 = 2*a*b
+    e3 = a**3*b**2
+    e4 = a*b + b*a
+    assert not e1 == e2
+    assert not e1 == e2
+    assert e1 != e2
+    assert e2 == e4
+    assert e2 != e3
+    assert not e2 == e3
+
+    x = Symbol("x")
+    e1 = exp(x + 1/x)
+    y = Symbol("x")
+    e2 = exp(y + 1/y)
+    assert e1 == e2
+    assert not e1 != e2
+    y = Symbol("y")
+    e2 = exp(y + 1/y)
+    assert not e1 == e2
+    assert e1 != e2
+
+    e5 = Rational(3) + 2*x - x - x
+    assert e5 == 3
+    assert 3 == e5
+    assert e5 != 4
+    assert 4 != e5
+    assert e5 != 3 + x
+    assert 3 + x != e5
+
+
+def test_expevalbug():
+    x = Symbol("x")
+    e1 = exp(1*x)
+    e3 = exp(x)
+    assert e1 == e3
+
+
+def test_cmp_bug1():
+    class T:
+        pass
+
+    t = T()
+    x = Symbol("x")
+
+    assert not (x == t)
+    assert (x != t)
+
+
+def test_cmp_bug2():
+    class T:
+        pass
+
+    t = T()
+
+    assert not (Symbol == t)
+    assert (Symbol != t)
+
+
+def test_cmp_issue_4357():
+    """ Check that Basic subclasses can be compared with sympifiable objects.
+
+    https://github.com/sympy/sympy/issues/4357
+    """
+    assert not (Symbol == 1)
+    assert (Symbol != 1)
+    assert not (Symbol == 'x')
+    assert (Symbol != 'x')
+
+
+def test_dummy_eq():
+    x = Symbol('x')
+    y = Symbol('y')
+
+    u = Dummy('u')
+
+    assert (u**2 + 1).dummy_eq(x**2 + 1) is True
+    assert ((u**2 + 1) == (x**2 + 1)) is False
+
+    assert (u**2 + y).dummy_eq(x**2 + y, x) is True
+    assert (u**2 + y).dummy_eq(x**2 + y, y) is False

.venv/lib/python3.11/site-packages/sympy/core/tests/test_eval.py

@@ -0,0 +1,95 @@
+from sympy.core.function import Function
+from sympy.core.numbers import (I, Rational)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, tan)
+from sympy.testing.pytest import XFAIL
+
+
+def test_add_eval():
+    a = Symbol("a")
+    b = Symbol("b")
+    c = Rational(1)
+    p = Rational(5)
+    assert a*b + c + p == a*b + 6
+    assert c + a + p == a + 6
+    assert c + a - p == a + (-4)
+    assert a + a == 2*a
+    assert a + p + a == 2*a + 5
+    assert c + p == Rational(6)
+    assert b + a - b == a
+
+
+def test_addmul_eval():
+    a = Symbol("a")
+    b = Symbol("b")
+    c = Rational(1)
+    p = Rational(5)
+    assert c + a + b*c + a - p == 2*a + b + (-4)
+    assert a*2 + p + a == a*2 + 5 + a
+    assert a*2 + p + a == 3*a + 5
+    assert a*2 + a == 3*a
+
+
+def test_pow_eval():
+    # XXX Pow does not fully support conversion of negative numbers
+    #     to their complex equivalent
+
+    assert sqrt(-1) == I
+
+    assert sqrt(-4) == 2*I
+    assert sqrt( 4) == 2
+    assert (8)**Rational(1, 3) == 2
+    assert (-8)**Rational(1, 3) == 2*((-1)**Rational(1, 3))
+
+    assert sqrt(-2) == I*sqrt(2)
+    assert (-1)**Rational(1, 3) != I
+    assert (-10)**Rational(1, 3) != I*((10)**Rational(1, 3))
+    assert (-2)**Rational(1, 4) != (2)**Rational(1, 4)
+
+    assert 64**Rational(1, 3) == 4
+    assert 64**Rational(2, 3) == 16
+    assert 24/sqrt(64) == 3
+    assert (-27)**Rational(1, 3) == 3*(-1)**Rational(1, 3)
+
+    assert (cos(2) / tan(2))**2 == (cos(2) / tan(2))**2
+
+
+@XFAIL
+def test_pow_eval_X1():
+    assert (-1)**Rational(1, 3) == S.Half + S.Half*I*sqrt(3)
+
+
+def test_mulpow_eval():
+    x = Symbol('x')
+    assert sqrt(50)/(sqrt(2)*x) == 5/x
+    assert sqrt(27)/sqrt(3) == 3
+
+
+def test_evalpow_bug():
+    x = Symbol("x")
+    assert 1/(1/x) == x
+    assert 1/(-1/x) == -x
+
+
+def test_symbol_expand():
+    x = Symbol('x')
+    y = Symbol('y')
+
+    f = x**4*y**4
+    assert f == x**4*y**4
+    assert f == f.expand()
+
+    g = (x*y)**4
+    assert g == f
+    assert g.expand() == f
+    assert g.expand() == g.expand().expand()
+
+
+def test_function():
+    f, l = map(Function, 'fl')
+    x = Symbol('x')
+    assert exp(l(x))*l(x)/exp(l(x)) == l(x)
+    assert exp(f(x))*f(x)/exp(f(x)) == f(x)

.venv/lib/python3.11/site-packages/sympy/core/tests/test_evalf.py

@@ -0,0 +1,734 @@
+import math
+
+from sympy.concrete.products import (Product, product)
+from sympy.concrete.summations import Sum
+from sympy.core.add import Add
+from sympy.core.evalf import N
+from sympy.core.function import (Function, nfloat)
+from sympy.core.mul import Mul
+from sympy.core import (GoldenRatio)
+from sympy.core.numbers import (AlgebraicNumber, E, Float, I, Rational,
+                                oo, zoo, nan, pi)
+from sympy.core.power import Pow
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.combinatorial.numbers import fibonacci
+from sympy.functions.elementary.complexes import (Abs, re, im)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.hyperbolic import (acosh, cosh)
+from sympy.functions.elementary.integers import (ceiling, floor)
+from sympy.functions.elementary.miscellaneous import (Max, sqrt)
+from sympy.functions.elementary.trigonometric import (acos, atan, cos, sin, tan)
+from sympy.integrals.integrals import (Integral, integrate)
+from sympy.polys.polytools import factor
+from sympy.polys.rootoftools import CRootOf
+from sympy.polys.specialpolys import cyclotomic_poly
+from sympy.printing import srepr
+from sympy.printing.str import sstr
+from sympy.simplify.simplify import simplify
+from sympy.core.numbers import comp
+from sympy.core.evalf import (complex_accuracy, PrecisionExhausted,
+                              scaled_zero, get_integer_part, as_mpmath, evalf, _evalf_with_bounded_error)
+from mpmath import inf, ninf, make_mpc
+from mpmath.libmp.libmpf import from_float, fzero
+from sympy.core.expr import unchanged
+from sympy.testing.pytest import raises, XFAIL
+from sympy.abc import n, x, y
+
+
+def NS(e, n=15, **options):
+    return sstr(sympify(e).evalf(n, **options), full_prec=True)
+
+
+def test_evalf_helpers():
+    from mpmath.libmp import finf
+    assert complex_accuracy((from_float(2.0), None, 35, None)) == 35
+    assert complex_accuracy((from_float(2.0), from_float(10.0), 35, 100)) == 37
+    assert complex_accuracy(
+        (from_float(2.0), from_float(1000.0), 35, 100)) == 43
+    assert complex_accuracy((from_float(2.0), from_float(10.0), 100, 35)) == 35
+    assert complex_accuracy(
+        (from_float(2.0), from_float(1000.0), 100, 35)) == 35
+    assert complex_accuracy(finf) == math.inf
+    assert complex_accuracy(zoo) == math.inf
+    raises(ValueError, lambda: get_integer_part(zoo, 1, {}))
+
+
+def test_evalf_basic():
+    assert NS('pi', 15) == '3.14159265358979'
+    assert NS('2/3', 10) == '0.6666666667'
+    assert NS('355/113-pi', 6) == '2.66764e-7'
+    assert NS('16*atan(1/5)-4*atan(1/239)', 15) == '3.14159265358979'
+
+
+def test_cancellation():
+    assert NS(Add(pi, Rational(1, 10**1000), -pi, evaluate=False), 15,
+              maxn=1200) == '1.00000000000000e-1000'
+
+
+def test_evalf_powers():
+    assert NS('pi**(10**20)', 10) == '1.339148777e+49714987269413385435'
+    assert NS(pi**(10**100), 10) == ('4.946362032e+4971498726941338543512682882'
+          '9089887365167832438044244613405349992494711208'
+          '95526746555473864642912223')
+    assert NS('2**(1/10**50)', 15) == '1.00000000000000'
+    assert NS('2**(1/10**50)-1', 15) == '6.93147180559945e-51'
+
+# Evaluation of Rump's ill-conditioned polynomial
+
+
+def test_evalf_rump():
+    a = 1335*y**6/4 + x**2*(11*x**2*y**2 - y**6 - 121*y**4 - 2) + 11*y**8/2 + x/(2*y)
+    assert NS(a, 15, subs={x: 77617, y: 33096}) == '-0.827396059946821'
+
+
+def test_evalf_complex():
+    assert NS('2*sqrt(pi)*I', 10) == '3.544907702*I'
+    assert NS('3+3*I', 15) == '3.00000000000000 + 3.00000000000000*I'
+    assert NS('E+pi*I', 15) == '2.71828182845905 + 3.14159265358979*I'
+    assert NS('pi * (3+4*I)', 15) == '9.42477796076938 + 12.5663706143592*I'
+    assert NS('I*(2+I)', 15) == '-1.00000000000000 + 2.00000000000000*I'
+
+
+@XFAIL
+def test_evalf_complex_bug():
+    assert NS('(pi+E*I)*(E+pi*I)', 15) in ('0.e-15 + 17.25866050002*I',
+              '0.e-17 + 17.25866050002*I', '-0.e-17 + 17.25866050002*I')
+
+
+def test_evalf_complex_powers():
+    assert NS('(E+pi*I)**100000000000000000') == \
+        '-3.58896782867793e+61850354284995199 + 4.58581754997159e+61850354284995199*I'
+    # XXX: rewrite if a+a*I simplification introduced in SymPy
+    #assert NS('(pi + pi*I)**2') in ('0.e-15 + 19.7392088021787*I', '0.e-16 + 19.7392088021787*I')
+    assert NS('(pi + pi*I)**2', chop=True) == '19.7392088021787*I'
+    assert NS(
+        '(pi + 1/10**8 + pi*I)**2') == '6.2831853e-8 + 19.7392088650106*I'
+    assert NS('(pi + 1/10**12 + pi*I)**2') == '6.283e-12 + 19.7392088021850*I'
+    assert NS('(pi + pi*I)**4', chop=True) == '-389.636364136010'
+    assert NS(
+        '(pi + 1/10**8 + pi*I)**4') == '-389.636366616512 + 2.4805021e-6*I'
+    assert NS('(pi + 1/10**12 + pi*I)**4') == '-389.636364136258 + 2.481e-10*I'
+    assert NS(
+        '(10000*pi + 10000*pi*I)**4', chop=True) == '-3.89636364136010e+18'
+
+
+@XFAIL
+def test_evalf_complex_powers_bug():
+    assert NS('(pi + pi*I)**4') == '-389.63636413601 + 0.e-14*I'
+
+
+def test_evalf_exponentiation():
+    assert NS(sqrt(-pi)) == '1.77245385090552*I'
+    assert NS(Pow(pi*I, Rational(
+        1, 2), evaluate=False)) == '1.25331413731550 + 1.25331413731550*I'
+    assert NS(pi**I) == '0.413292116101594 + 0.910598499212615*I'
+    assert NS(pi**(E + I/3)) == '20.8438653991931 + 8.36343473930031*I'
+    assert NS((pi + I/3)**(E + I/3)) == '17.2442906093590 + 13.6839376767037*I'
+    assert NS(exp(pi)) == '23.1406926327793'
+    assert NS(exp(pi + E*I)) == '-21.0981542849657 + 9.50576358282422*I'
+    assert NS(pi**pi) == '36.4621596072079'
+    assert NS((-pi)**pi) == '-32.9138577418939 - 15.6897116534332*I'
+    assert NS((-pi)**(-pi)) == '-0.0247567717232697 + 0.0118013091280262*I'
+
+# An example from Smith, "Multiple Precision Complex Arithmetic and Functions"
+
+
+def test_evalf_complex_cancellation():
+    A = Rational('63287/100000')
+    B = Rational('52498/100000')
+    C = Rational('69301/100000')
+    D = Rational('83542/100000')
+    F = Rational('2231321613/2500000000')
+    # XXX: the number of returned mantissa digits in the real part could
+    # change with the implementation. What matters is that the returned digits are
+    # correct; those that are showing now are correct.
+    # >>> ((A+B*I)*(C+D*I)).expand()
+    # 64471/10000000000 + 2231321613*I/2500000000
+    # >>> 2231321613*4
+    # 8925286452L
+    assert NS((A + B*I)*(C + D*I), 6) == '6.44710e-6 + 0.892529*I'
+    assert NS((A + B*I)*(C + D*I), 10) == '6.447100000e-6 + 0.8925286452*I'
+    assert NS((A + B*I)*(
+        C + D*I) - F*I, 5) in ('6.4471e-6 + 0.e-14*I', '6.4471e-6 - 0.e-14*I')
+
+
+def test_evalf_logs():
+    assert NS("log(3+pi*I)", 15) == '1.46877619736226 + 0.808448792630022*I'
+    assert NS("log(pi*I)", 15) == '1.14472988584940 + 1.57079632679490*I'
+    assert NS('log(-1 + 0.00001)', 2) == '-1.0e-5 + 3.1*I'
+    assert NS('log(100, 10, evaluate=False)', 15) == '2.00000000000000'
+    assert NS('-2*I*log(-(-1)**(S(1)/9))', 15) == '-5.58505360638185'
+
+
+def test_evalf_trig():
+    assert NS('sin(1)', 15) == '0.841470984807897'
+    assert NS('cos(1)', 15) == '0.540302305868140'
+    assert NS('sin(10**-6)', 15) == '9.99999999999833e-7'
+    assert NS('cos(10**-6)', 15) == '0.999999999999500'
+    assert NS('sin(E*10**100)', 15) == '0.409160531722613'
+    # Some input near roots
+    assert NS(sin(exp(pi*sqrt(163))*pi), 15) == '-2.35596641936785e-12'
+    assert NS(sin(pi*10**100 + Rational(7, 10**5), evaluate=False), 15, maxn=120) == \
+        '6.99999999428333e-5'
+    assert NS(sin(Rational(7, 10**5), evaluate=False), 15) == \
+        '6.99999999428333e-5'
+
+# Check detection of various false identities
+
+
+def test_evalf_near_integers():
+    # Binet's formula
+    f = lambda n: ((1 + sqrt(5))**n)/(2**n * sqrt(5))
+    assert NS(f(5000) - fibonacci(5000), 10, maxn=1500) == '5.156009964e-1046'
+    # Some near-integer identities from
+    # http://mathworld.wolfram.com/AlmostInteger.html
+    assert NS('sin(2017*2**(1/5))', 15) == '-1.00000000000000'
+    assert NS('sin(2017*2**(1/5))', 20) == '-0.99999999999999997857'
+    assert NS('1+sin(2017*2**(1/5))', 15) == '2.14322287389390e-17'
+    assert NS('45 - 613*E/37 + 35/991', 15) == '6.03764498766326e-11'
+
+
+def test_evalf_ramanujan():
+    assert NS(exp(pi*sqrt(163)) - 640320**3 - 744, 10) == '-7.499274028e-13'
+    # A related identity
+    A = 262537412640768744*exp(-pi*sqrt(163))
+    B = 196884*exp(-2*pi*sqrt(163))
+    C = 103378831900730205293632*exp(-3*pi*sqrt(163))
+    assert NS(1 - A - B + C, 10) == '1.613679005e-59'
+
+# Input that for various reasons have failed at some point
+
+
+def test_evalf_bugs():
+    assert NS(sin(1) + exp(-10**10), 10) == NS(sin(1), 10)
+    assert NS(exp(10**10) + sin(1), 10) == NS(exp(10**10), 10)
+    assert NS('expand_log(log(1+1/10**50))', 20) == '1.0000000000000000000e-50'
+    assert NS('log(10**100,10)', 10) == '100.0000000'
+    assert NS('log(2)', 10) == '0.6931471806'
+    assert NS(
+        '(sin(x)-x)/x**3', 15, subs={x: '1/10**50'}) == '-0.166666666666667'
+    assert NS(sin(1) + Rational(
+        1, 10**100)*I, 15) == '0.841470984807897 + 1.00000000000000e-100*I'
+    assert x.evalf() == x
+    assert NS((1 + I)**2*I, 6) == '-2.00000'
+    d = {n: (
+        -1)**Rational(6, 7), y: (-1)**Rational(4, 7), x: (-1)**Rational(2, 7)}
+    assert NS((x*(1 + y*(1 + n))).subs(d).evalf(), 6) == '0.346011 + 0.433884*I'
+    assert NS(((-I - sqrt(2)*I)**2).evalf()) == '-5.82842712474619'
+    assert NS((1 + I)**2*I, 15) == '-2.00000000000000'
+    # issue 4758 (1/2):
+    assert NS(pi.evalf(69) - pi) == '-4.43863937855894e-71'
+    # issue 4758 (2/2): With the bug present, this still only fails if the
+    # terms are in the order given here. This is not generally the case,
+    # because the order depends on the hashes of the terms.
+    assert NS(20 - 5008329267844*n**25 - 477638700*n**37 - 19*n,
+              subs={n: .01}) == '19.8100000000000'
+    assert NS(((x - 1)*(1 - x)**1000).n()
+              ) == '(1.00000000000000 - x)**1000*(x - 1.00000000000000)'
+    assert NS((-x).n()) == '-x'
+    assert NS((-2*x).n()) == '-2.00000000000000*x'
+    assert NS((-2*x*y).n()) == '-2.00000000000000*x*y'
+    assert cos(x).n(subs={x: 1+I}) == cos(x).subs(x, 1+I).n()
+    # issue 6660. Also NaN != mpmath.nan
+    # In this order:
+    # 0*nan, 0/nan, 0*inf, 0/inf
+    # 0+nan, 0-nan, 0+inf, 0-inf
+    # >>> n = Some Number
+    # n*nan, n/nan, n*inf, n/inf
+    # n+nan, n-nan, n+inf, n-inf
+    assert (0*E**(oo)).n() is S.NaN
+    assert (0/E**(oo)).n() is S.Zero
+
+    assert (0+E**(oo)).n() is S.Infinity
+    assert (0-E**(oo)).n() is S.NegativeInfinity
+
+    assert (5*E**(oo)).n() is S.Infinity
+    assert (5/E**(oo)).n() is S.Zero
+
+    assert (5+E**(oo)).n() is S.Infinity
+    assert (5-E**(oo)).n() is S.NegativeInfinity
+
+    #issue 7416
+    assert as_mpmath(0.0, 10, {'chop': True}) == 0
+
+    #issue 5412
+    assert ((oo*I).n() == S.Infinity*I)
+    assert ((oo+oo*I).n() == S.Infinity + S.Infinity*I)
+
+    #issue 11518
+    assert NS(2*x**2.5, 5) == '2.0000*x**2.5000'
+
+    #issue 13076
+    assert NS(Mul(Max(0, y), x, evaluate=False).evalf()) == 'x*Max(0, y)'
+
+    #issue 18516
+    assert NS(log(S(3273390607896141870013189696827599152216642046043064789483291368096133796404674554883270092325904157150886684127560071009217256545885393053328527589376)/36360291795869936842385267079543319118023385026001623040346035832580600191583895484198508262979388783308179702534403855752855931517013066142992430916562025780021771247847643450125342836565813209972590371590152578728008385990139795377610001).evalf(15, chop=True)) == '-oo'
+
+
+def test_evalf_integer_parts():
+    a = floor(log(8)/log(2) - exp(-1000), evaluate=False)
+    b = floor(log(8)/log(2), evaluate=False)
+    assert a.evalf() == 3.0
+    assert b.evalf() == 3.0
+    # equals, as a fallback, can still fail but it might succeed as here
+    assert ceiling(10*(sin(1)**2 + cos(1)**2)) == 10
+
+    assert int(floor(factorial(50)/E, evaluate=False).evalf(70)) == \
+        int(11188719610782480504630258070757734324011354208865721592720336800)
+    assert int(ceiling(factorial(50)/E, evaluate=False).evalf(70)) == \
+        int(11188719610782480504630258070757734324011354208865721592720336801)
+    assert int(floor(GoldenRatio**999 / sqrt(5) + S.Half)
+               .evalf(1000)) == fibonacci(999)
+    assert int(floor(GoldenRatio**1000 / sqrt(5) + S.Half)
+               .evalf(1000)) == fibonacci(1000)
+
+    assert ceiling(x).evalf(subs={x: 3}) == 3.0
+    assert ceiling(x).evalf(subs={x: 3*I}) == 3.0*I
+    assert ceiling(x).evalf(subs={x: 2 + 3*I}) == 2.0 + 3.0*I
+    assert ceiling(x).evalf(subs={x: 3.}) == 3.0
+    assert ceiling(x).evalf(subs={x: 3.*I}) == 3.0*I
+    assert ceiling(x).evalf(subs={x: 2. + 3*I}) == 2.0 + 3.0*I
+
+    assert float((floor(1.5, evaluate=False)+1/9).evalf()) == 1 + 1/9
+    assert float((floor(0.5, evaluate=False)+20).evalf()) == 20
+
+    # issue 19991
+    n = 1169809367327212570704813632106852886389036911
+    r = 744723773141314414542111064094745678855643068
+
+    assert floor(n / (pi / 2)) == r
+    assert floor(80782 * sqrt(2)) == 114242
+
+    # issue 20076
+    assert 260515 - floor(260515/pi + 1/2) * pi == atan(tan(260515))
+
+    assert floor(x).evalf(subs={x: sqrt(2)}) == 1.0
+
+
+def test_evalf_trig_zero_detection():
+    a = sin(160*pi, evaluate=False)
+    t = a.evalf(maxn=100)
+    assert abs(t) < 1e-100
+    assert t._prec < 2
+    assert a.evalf(chop=True) == 0
+    raises(PrecisionExhausted, lambda: a.evalf(strict=True))
+
+
+def test_evalf_sum():
+    assert Sum(n,(n,1,2)).evalf() == 3.
+    assert Sum(n,(n,1,2)).doit().evalf() == 3.
+    # the next test should return instantly
+    assert Sum(1/n,(n,1,2)).evalf() == 1.5
+
+    # issue 8219
+    assert Sum(E/factorial(n), (n, 0, oo)).evalf() == (E*E).evalf()
+    # issue 8254
+    assert Sum(2**n*n/factorial(n), (n, 0, oo)).evalf() == (2*E*E).evalf()
+    # issue 8411
+    s = Sum(1/x**2, (x, 100, oo))
+    assert s.n() == s.doit().n()
+
+
+def test_evalf_divergent_series():
+    raises(ValueError, lambda: Sum(1/n, (n, 1, oo)).evalf())
+    raises(ValueError, lambda: Sum(n/(n**2 + 1), (n, 1, oo)).evalf())
+    raises(ValueError, lambda: Sum((-1)**n, (n, 1, oo)).evalf())
+    raises(ValueError, lambda: Sum((-1)**n, (n, 1, oo)).evalf())
+    raises(ValueError, lambda: Sum(n**2, (n, 1, oo)).evalf())
+    raises(ValueError, lambda: Sum(2**n, (n, 1, oo)).evalf())
+    raises(ValueError, lambda: Sum((-2)**n, (n, 1, oo)).evalf())
+    raises(ValueError, lambda: Sum((2*n + 3)/(3*n**2 + 4), (n, 0, oo)).evalf())
+    raises(ValueError, lambda: Sum((0.5*n**3)/(n**4 + 1), (n, 0, oo)).evalf())
+
+
+def test_evalf_product():
+    assert Product(n, (n, 1, 10)).evalf() == 3628800.
+    assert comp(Product(1 - S.Half**2/n**2, (n, 1, oo)).n(5), 0.63662)
+    assert Product(n, (n, -1, 3)).evalf() == 0
+
+
+def test_evalf_py_methods():
+    assert abs(float(pi + 1) - 4.1415926535897932) < 1e-10
+    assert abs(complex(pi + 1) - 4.1415926535897932) < 1e-10
+    assert abs(
+        complex(pi + E*I) - (3.1415926535897931 + 2.7182818284590451j)) < 1e-10
+    raises(TypeError, lambda: float(pi + x))
+
+
+def test_evalf_power_subs_bugs():
+    assert (x**2).evalf(subs={x: 0}) == 0
+    assert sqrt(x).evalf(subs={x: 0}) == 0
+    assert (x**Rational(2, 3)).evalf(subs={x: 0}) == 0
+    assert (x**x).evalf(subs={x: 0}) == 1.0
+    assert (3**x).evalf(subs={x: 0}) == 1.0
+    assert exp(x).evalf(subs={x: 0}) == 1.0
+    assert ((2 + I)**x).evalf(subs={x: 0}) == 1.0
+    assert (0**x).evalf(subs={x: 0}) == 1.0
+
+
+def test_evalf_arguments():
+    raises(TypeError, lambda: pi.evalf(method="garbage"))
+
+
+def test_implemented_function_evalf():
+    from sympy.utilities.lambdify import implemented_function
+    f = Function('f')
+    f = implemented_function(f, lambda x: x + 1)
+    assert str(f(x)) == "f(x)"
+    assert str(f(2)) == "f(2)"
+    assert f(2).evalf() == 3.0
+    assert f(x).evalf() == f(x)
+    f = implemented_function(Function('sin'), lambda x: x + 1)
+    assert f(2).evalf() != sin(2)
+    del f._imp_     # XXX: due to caching _imp_ would influence all other tests
+
+
+def test_evaluate_false():
+    for no in [0, False]:
+        assert Add(3, 2, evaluate=no).is_Add
+        assert Mul(3, 2, evaluate=no).is_Mul
+        assert Pow(3, 2, evaluate=no).is_Pow
+    assert Pow(y, 2, evaluate=True) - Pow(y, 2, evaluate=True) == 0
+
+
+def test_evalf_relational():
+    assert Eq(x/5, y/10).evalf() == Eq(0.2*x, 0.1*y)
+    # if this first assertion fails it should be replaced with
+    # one that doesn't
+    assert unchanged(Eq, (3 - I)**2/2 + I, 0)
+    assert Eq((3 - I)**2/2 + I, 0).n() is S.false
+    assert nfloat(Eq((3 - I)**2 + I, 0)) == S.false
+
+
+def test_issue_5486():
+    assert not cos(sqrt(0.5 + I)).n().is_Function
+
+
+def test_issue_5486_bug():
+    from sympy.core.expr import Expr
+    from sympy.core.numbers import I
+    assert abs(Expr._from_mpmath(I._to_mpmath(15), 15) - I) < 1.0e-15
+
+
+def test_bugs():
+    from sympy.functions.elementary.complexes import (polar_lift, re)
+
+    assert abs(re((1 + I)**2)) < 1e-15
+
+    # anything that evalf's to 0 will do in place of polar_lift
+    assert abs(polar_lift(0)).n() == 0
+
+
+def test_subs():
+    assert NS('besseli(-x, y) - besseli(x, y)', subs={x: 3.5, y: 20.0}) == \
+        '-4.92535585957223e-10'
+    assert NS('Piecewise((x, x>0)) + Piecewise((1-x, x>0))', subs={x: 0.1}) == \
+        '1.00000000000000'
+    raises(TypeError, lambda: x.evalf(subs=(x, 1)))
+
+
+def test_issue_4956_5204():
+    # issue 4956
+    v = S('''(-27*12**(1/3)*sqrt(31)*I +
+    27*2**(2/3)*3**(1/3)*sqrt(31)*I)/(-2511*2**(2/3)*3**(1/3) +
+    (29*18**(1/3) + 9*2**(1/3)*3**(2/3)*sqrt(31)*I +
+    87*2**(1/3)*3**(1/6)*I)**2)''')
+    assert NS(v, 1) == '0.e-118 - 0.e-118*I'
+
+    # issue 5204
+    v = S('''-(357587765856 + 18873261792*249**(1/2) + 56619785376*I*83**(1/2) +
+    108755765856*I*3**(1/2) + 41281887168*6**(1/3)*(1422 +
+    54*249**(1/2))**(1/3) - 1239810624*6**(1/3)*249**(1/2)*(1422 +
+    54*249**(1/2))**(1/3) - 3110400000*I*6**(1/3)*83**(1/2)*(1422 +
+    54*249**(1/2))**(1/3) + 13478400000*I*3**(1/2)*6**(1/3)*(1422 +
+    54*249**(1/2))**(1/3) + 1274950152*6**(2/3)*(1422 +
+    54*249**(1/2))**(2/3) + 32347944*6**(2/3)*249**(1/2)*(1422 +
+    54*249**(1/2))**(2/3) - 1758790152*I*3**(1/2)*6**(2/3)*(1422 +
+    54*249**(1/2))**(2/3) - 304403832*I*6**(2/3)*83**(1/2)*(1422 +
+    4*249**(1/2))**(2/3))/(175732658352 + (1106028 + 25596*249**(1/2) +
+    76788*I*83**(1/2))**2)''')
+    assert NS(v, 5) == '0.077284 + 1.1104*I'
+    assert NS(v, 1) == '0.08 + 1.*I'
+
+
+def test_old_docstring():
+    a = (E + pi*I)*(E - pi*I)
+    assert NS(a) == '17.2586605000200'
+    assert a.n() == 17.25866050002001
+
+
+def test_issue_4806():
+    assert integrate(atan(x)**2, (x, -1, 1)).evalf().round(1) == Float(0.5, 1)
+    assert atan(0, evaluate=False).n() == 0
+
+
+def test_evalf_mul():
+    # SymPy should not try to expand this; it should be handled term-wise
+    # in evalf through mpmath
+    assert NS(product(1 + sqrt(n)*I, (n, 1, 500)), 1) == '5.e+567 + 2.e+568*I'
+
+
+def test_scaled_zero():
+    a, b = (([0], 1, 100, 1), -1)
+    assert scaled_zero(100) == (a, b)
+    assert scaled_zero(a) == (0, 1, 100, 1)
+    a, b = (([1], 1, 100, 1), -1)
+    assert scaled_zero(100, -1) == (a, b)
+    assert scaled_zero(a) == (1, 1, 100, 1)
+    raises(ValueError, lambda: scaled_zero(scaled_zero(100)))
+    raises(ValueError, lambda: scaled_zero(100, 2))
+    raises(ValueError, lambda: scaled_zero(100, 0))
+    raises(ValueError, lambda: scaled_zero((1, 5, 1, 3)))
+
+
+def test_chop_value():
+    for i in range(-27, 28):
+        assert (Pow(10, i)*2).n(chop=10**i) and not (Pow(10, i)).n(chop=10**i)
+
+
+def test_infinities():
+    assert oo.evalf(chop=True) == inf
+    assert (-oo).evalf(chop=True) == ninf
+
+
+def test_to_mpmath():
+    assert sqrt(3)._to_mpmath(20)._mpf_ == (0, int(908093), -19, 20)
+    assert S(3.2)._to_mpmath(20)._mpf_ == (0, int(838861), -18, 20)
+
+
+def test_issue_6632_evalf():
+    add = (-100000*sqrt(2500000001) + 5000000001)
+    assert add.n() == 9.999999998e-11
+    assert (add*add).n() == 9.999999996e-21
+
+
+def test_issue_4945():
+    from sympy.abc import H
+    assert (H/0).evalf(subs={H:1}) == zoo
+
+
+def test_evalf_integral():
+    # test that workprec has to increase in order to get a result other than 0
+    eps = Rational(1, 1000000)
+    assert Integral(sin(x), (x, -pi, pi + eps)).n(2)._prec == 10
+
+
+def test_issue_8821_highprec_from_str():
+    s = str(pi.evalf(128))
+    p = N(s)
+    assert Abs(sin(p)) < 1e-15
+    p = N(s, 64)
+    assert Abs(sin(p)) < 1e-64
+
+
+def test_issue_8853():
+    p = Symbol('x', even=True, positive=True)
+    assert floor(-p - S.Half).is_even == False
+    assert floor(-p + S.Half).is_even == True
+    assert ceiling(p - S.Half).is_even == True
+    assert ceiling(p + S.Half).is_even == False
+
+    assert get_integer_part(S.Half, -1, {}, True) == (0, 0)
+    assert get_integer_part(S.Half, 1, {}, True) == (1, 0)
+    assert get_integer_part(Rational(-1, 2), -1, {}, True) == (-1, 0)
+    assert get_integer_part(Rational(-1, 2), 1, {}, True) == (0, 0)
+
+
+def test_issue_17681():
+    class identity_func(Function):
+
+        def _eval_evalf(self, *args, **kwargs):
+            return self.args[0].evalf(*args, **kwargs)
+
+    assert floor(identity_func(S(0))) == 0
+    assert get_integer_part(S(0), 1, {}, True) == (0, 0)
+
+
+def test_issue_9326():
+    from sympy.core.symbol import Dummy
+    d1 = Dummy('d')
+    d2 = Dummy('d')
+    e = d1 + d2
+    assert e.evalf(subs = {d1: 1, d2: 2}) == 3.0
+
+
+def test_issue_10323():
+    assert ceiling(sqrt(2**30 + 1)) == 2**15 + 1
+
+
+def test_AssocOp_Function():
+    # the first arg of Min is not comparable in the imaginary part
+    raises(ValueError, lambda: S('''
+    Min(-sqrt(3)*cos(pi/18)/6 + re(1/((-1/2 - sqrt(3)*I/2)*(1/6 +
+    sqrt(3)*I/18)**(1/3)))/3 + sin(pi/18)/2 + 2 + I*(-cos(pi/18)/2 -
+    sqrt(3)*sin(pi/18)/6 + im(1/((-1/2 - sqrt(3)*I/2)*(1/6 +
+    sqrt(3)*I/18)**(1/3)))/3), re(1/((-1/2 + sqrt(3)*I/2)*(1/6 +
+    sqrt(3)*I/18)**(1/3)))/3 - sqrt(3)*cos(pi/18)/6 - sin(pi/18)/2 + 2 +
+    I*(im(1/((-1/2 + sqrt(3)*I/2)*(1/6 + sqrt(3)*I/18)**(1/3)))/3 -
+    sqrt(3)*sin(pi/18)/6 + cos(pi/18)/2))'''))
+    # if that is changed so a non-comparable number remains as
+    # an arg, then the Min/Max instantiation needs to be changed
+    # to watch out for non-comparable args when making simplifications
+    # and the following test should be added instead (with e being
+    # the sympified expression above):
+    # raises(ValueError, lambda: e._eval_evalf(2))
+
+
+def test_issue_10395():
+    eq = x*Max(0, y)
+    assert nfloat(eq) == eq
+    eq = x*Max(y, -1.1)
+    assert nfloat(eq) == eq
+    assert Max(y, 4).n() == Max(4.0, y)
+
+
+def test_issue_13098():
+    assert floor(log(S('9.'+'9'*20), 10)) == 0
+    assert ceiling(log(S('9.'+'9'*20), 10)) == 1
+    assert floor(log(20 - S('9.'+'9'*20), 10)) == 1
+    assert ceiling(log(20 - S('9.'+'9'*20), 10)) == 2
+
+
+def test_issue_14601():
+    e = 5*x*y/2 - y*(35*(x**3)/2 - 15*x/2)
+    subst = {x:0.0, y:0.0}
+    e2 = e.evalf(subs=subst)
+    assert float(e2) == 0.0
+    assert float((x + x*(x**2 + x)).evalf(subs={x: 0.0})) == 0.0
+
+
+def test_issue_11151():
+    z = S.Zero
+    e = Sum(z, (x, 1, 2))
+    assert e != z  # it shouldn't evaluate
+    # when it does evaluate, this is what it should give
+    assert evalf(e, 15, {}) == \
+        evalf(z, 15, {}) == (None, None, 15, None)
+    # so this shouldn't fail
+    assert (e/2).n() == 0
+    # this was where the issue appeared
+    expr0 = Sum(x**2 + x, (x, 1, 2))
+    expr1 = Sum(0, (x, 1, 2))
+    expr2 = expr1/expr0
+    assert simplify(factor(expr2) - expr2) == 0
+
+
+def test_issue_13425():
+    assert N('2**.5', 30) == N('sqrt(2)', 30)
+    assert N('x - x', 30) == 0
+    assert abs((N('pi*.1', 22)*10 - pi).n()) < 1e-22
+
+
+def test_issue_17421():
+    assert N(acos(-I + acosh(cosh(cosh(1) + I)))) == 1.0*I
+
+
+def test_issue_20291():
+    from sympy.sets import EmptySet, Reals
+    from sympy.sets.sets import (Complement, FiniteSet, Intersection)
+    a = Symbol('a')
+    b = Symbol('b')
+    A = FiniteSet(a, b)
+    assert A.evalf(subs={a: 1, b: 2}) == FiniteSet(1.0, 2.0)
+    B = FiniteSet(a-b, 1)
+    assert B.evalf(subs={a: 1, b: 2}) == FiniteSet(-1.0, 1.0)
+
+    sol = Complement(Intersection(FiniteSet(-b/2 - sqrt(b**2-4*pi)/2), Reals), FiniteSet(0))
+    assert sol.evalf(subs={b: 1}) == EmptySet
+
+
+def test_evalf_with_zoo():
+    assert (1/x).evalf(subs={x: 0}) == zoo  # issue 8242
+    assert (-1/x).evalf(subs={x: 0}) == zoo  # PR 16150
+    assert (0 ** x).evalf(subs={x: -1}) == zoo  # PR 16150
+    assert (0 ** x).evalf(subs={x: -1 + I}) == nan
+    assert Mul(2, Pow(0, -1, evaluate=False), evaluate=False).evalf() == zoo  # issue 21147
+    assert Mul(x, 1/x, evaluate=False).evalf(subs={x: 0}) == Mul(x, 1/x, evaluate=False).subs(x, 0) == nan
+    assert Mul(1/x, 1/x, evaluate=False).evalf(subs={x: 0}) == zoo
+    assert Mul(1/x, Abs(1/x), evaluate=False).evalf(subs={x: 0}) == zoo
+    assert Abs(zoo, evaluate=False).evalf() == oo
+    assert re(zoo, evaluate=False).evalf() == nan
+    assert im(zoo, evaluate=False).evalf() == nan
+    assert Add(zoo, zoo, evaluate=False).evalf() == nan
+    assert Add(oo, zoo, evaluate=False).evalf() == nan
+    assert Pow(zoo, -1, evaluate=False).evalf() == 0
+    assert Pow(zoo, Rational(-1, 3), evaluate=False).evalf() == 0
+    assert Pow(zoo, Rational(1, 3), evaluate=False).evalf() == zoo
+    assert Pow(zoo, S.Half, evaluate=False).evalf() == zoo
+    assert Pow(zoo, 2, evaluate=False).evalf() == zoo
+    assert Pow(0, zoo, evaluate=False).evalf() == nan
+    assert log(zoo, evaluate=False).evalf() == zoo
+    assert zoo.evalf(chop=True) == zoo
+    assert x.evalf(subs={x: zoo}) == zoo
+
+
+def test_evalf_with_bounded_error():
+    cases = [
+        # zero
+        (Rational(0), None, 1),
+        # zero im part
+        (pi, None, 10),
+        # zero real part
+        (pi*I, None, 10),
+        # re and im nonzero
+        (2-3*I, None, 5),
+        # similar tests again, but using eps instead of m
+        (Rational(0), Rational(1, 2), None),
+        (pi, Rational(1, 1000), None),
+        (pi * I, Rational(1, 1000), None),
+        (2 - 3 * I, Rational(1, 1000), None),
+        # very large eps
+        (2 - 3 * I, Rational(1000), None),
+        # case where x already small, hence some cancellation in p = m + n - 1
+        (Rational(1234, 10**8), Rational(1, 10**12), None),
+    ]
+    for x0, eps, m in cases:
+        a, b, _, _ = evalf(x0, 53, {})
+        c, d, _, _ = _evalf_with_bounded_error(x0, eps, m)
+        if eps is None:
+            eps = 2**(-m)
+        z = make_mpc((a or fzero, b or fzero))
+        w = make_mpc((c or fzero, d or fzero))
+        assert abs(w - z) < eps
+
+    # eps must be positive
+    raises(ValueError, lambda: _evalf_with_bounded_error(pi, Rational(0)))
+    raises(ValueError, lambda: _evalf_with_bounded_error(pi, -pi))
+    raises(ValueError, lambda: _evalf_with_bounded_error(pi, I))
+
+
+def test_issue_22849():
+    a = -8 + 3 * sqrt(3)
+    x = AlgebraicNumber(a)
+    assert evalf(a, 1, {}) == evalf(x, 1, {})
+
+
+def test_evalf_real_alg_num():
+    # This test demonstrates why the entry for `AlgebraicNumber` in
+    # `sympy.core.evalf._create_evalf_table()` has to use `x.to_root()`,
+    # instead of `x.as_expr()`. If the latter is used, then `z` will be
+    # a complex number with `0.e-20` for imaginary part, even though `a5`
+    # is a real number.
+    zeta = Symbol('zeta')
+    a5 = AlgebraicNumber(CRootOf(cyclotomic_poly(5), -1), [-1, -1, 0, 0], alias=zeta)
+    z = a5.evalf()
+    assert isinstance(z, Float)
+    assert not hasattr(z, '_mpc_')
+    assert hasattr(z, '_mpf_')
+
+
+def test_issue_20733():
+    expr = 1/((x - 9)*(x - 8)*(x - 7)*(x - 4)**2*(x - 3)**3*(x - 2))
+    assert str(expr.evalf(1, subs={x:1})) == '-4.e-5'
+    assert str(expr.evalf(2, subs={x:1})) == '-4.1e-5'
+    assert str(expr.evalf(11, subs={x:1})) == '-4.1335978836e-5'
+    assert str(expr.evalf(20, subs={x:1})) == '-0.000041335978835978835979'
+
+    expr = Mul(*((x - i) for i in range(2, 1000)))
+    assert srepr(expr.evalf(2, subs={x: 1})) == "Float('4.0271e+2561', precision=10)"
+    assert srepr(expr.evalf(10, subs={x: 1})) == "Float('4.02790050126e+2561', precision=37)"
+    assert srepr(expr.evalf(53, subs={x: 1})) == "Float('4.0279005012722099453824067459760158730668154575647110393e+2561', precision=179)"