sympy-simplify

suite simplipy · 2026-10-13 16:42:18 · CAS sympy 1.14.0, mode fork · machine pi5 · dialect sympy · case set 3ba0dfac4bca

By category

old report format (graded with a combined score): its nulls are shown as no verdict, because an old report cannot tell a correct decline on a contingent case from no verdict

category	n	solved	no verdict
simplipy-complex-branch	80	13	67
simplipy-conditional	92	12	80
simplipy-f64-edge	45	14	31
simplipy-ground	20	20	0
simplipy-real	70	24	46
total	307	83	224

Setup (run once per start, not counted in the per-query times)

measured setup time: 0.44 s

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

sympy	`sympy.__version__`	→	`1.14.0`
warm-up	`simplify(sin(W)2 + cos(W)2)`	→	`1`

Cases

case category outcome query (as sent) answer steps (from the trace) s detail

sp-acj4-0-complex contingent simplipy-complex-branch no verdict Q.complex(x) ⊢ Eq(acosh(cosh(x)), Abs(x)) null difference → -Abs(x) + acosh(cosh(x)) · simplify → -Abs(x) + acosh(cosh(x)) 0.053 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
Residual = acosh(cosh(x)) - Abs(x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`acosh(cosh(x)) - Abs(x)`	→	`-Abs(x) + acosh(cosh(x))`
simplify	`simplify(Residual)`	→	`-Abs(x) + acosh(cosh(x))`
answer			`null`

sp-acj4-102-complex true simplipy-complex-branch solved Q.complex(x) ⊢ Eq((Abs(x)/6), Abs((x/(-6)))) true difference → 0 · simplify → 0 0.008 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
Residual = Abs(x) / 6 - Abs(x / -6)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(x) / 6 - Abs(x / -6)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-108-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(x)) ∧ (~Q.zero(Abs(x))) ⊢ Eq((Abs(x)/x), (x/Abs(x))) null difference → -x/Abs(x) + Abs(x)/x · simplify → -x/Abs(x) + Abs(x)/x 0.033 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(Abs(x))
Residual = Abs(x) / x - (x / Abs(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(x) / x - (x / Abs(x))`	→	`-x/Abs(x) + Abs(x)/x`
simplify	`simplify(Residual)`	→	`-x/Abs(x) + Abs(x)/x`
answer			`null`

sp-acj4-120-complex true simplipy-complex-branch solved Q.complex(x) ∧ (~Q.zero(Abs(x))) ∧ (~Q.zero(x)) ⊢ Eq((pi/Abs(x)), Abs((pi/x))) true difference → 0 · simplify → 0 0.008 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(Abs(x))
Residual = pi / Abs(x) - Abs(pi / x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`pi / Abs(x) - Abs(pi / x)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-130-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(cos(x))) ∧ (~Q.zero((1/cos(x)))) ⊢ Eq(Abs(log(cos(x))), log((1/cos(x)))) null difference → -log(1/cos(x)) + Abs(log(cos(x))) · simplify → -log(1/cos(x)) + Abs(log(cos(x))) 0.061 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(x))
# dropped (not a unary fact about one symbol): ~Q.zero(1 / cos(x))
Residual = Abs(log(cos(x))) - log(1 / cos(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(log(cos(x))) - log(1 / cos(x))`	→	`-log(1/cos(x)) + Abs(log(cos(x)))`
simplify	`simplify(Residual)`	→	`-log(1/cos(x)) + Abs(log(cos(x)))`
answer			`null`

sp-acj4-131-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(cosh(x))) ⊢ Eq(Abs(log(cosh(x))), log(cosh(x))) null difference → -log(cosh(x)) + Abs(log(cosh(x))) · simplify → -log(cosh(x)) + Abs(log(cosh(x))) 0.071 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(x))
Residual = Abs(log(cosh(x))) - log(cosh(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(log(cosh(x))) - log(cosh(x))`	→	`-log(cosh(x)) + Abs(log(cosh(x)))`
simplify	`simplify(Residual)`	→	`-log(cosh(x)) + Abs(log(cosh(x)))`
answer			`null`

sp-acj4-132-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(sin(x))) ⊢ Eq(Abs(log(sin(x))), (-log(sin(x)))) null difference → log(sin(x)) + Abs(log(sin(x))) · simplify → log(sin(x)) + Abs(log(sin(x))) 0.046 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): ~Q.zero(sin(x))
Residual = Abs(log(sin(x))) - (-log(sin(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(log(sin(x))) - (-log(sin(x)))`	→	`log(sin(x)) + Abs(log(sin(x)))`
simplify	`simplify(Residual)`	→	`log(sin(x)) + Abs(log(sin(x)))`
answer			`null`

sp-acj4-133-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(cosh(x))) ∧ (~Q.zero(tanh(x))) ⊢ Eq(Abs(log(tanh(x))), (-log(tanh(x)))) null difference → log(tanh(x)) + Abs(log(tanh(x))) · simplify → log(tanh(x)) + Abs(log(tanh(x))) 0.075 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(x))
# dropped (not a unary fact about one symbol): ~Q.zero(tanh(x))
Residual = Abs(log(tanh(x))) - (-log(tanh(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(log(tanh(x))) - (-log(tanh(x)))`	→	`log(tanh(x)) + Abs(log(tanh(x)))`
simplify	`simplify(Residual)`	→	`log(tanh(x)) + Abs(log(tanh(x)))`
answer			`null`

sp-acj4-137-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ Or((~Q.zero(x)), (re(pi) > 0)) ⊢ Eq(Abs(Pow(x, pi)), Pow(x, pi)) null difference → -x**pi + Abs(x**pi) · simplify → -x**pi + Abs(x**pi) 0.022 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): Or(~Q.zero(x), re(pi) > 0)
Residual = Abs(Pow(x, pi)) - Pow(x, pi)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(Pow(x, pi)) - Pow(x, pi)`	→	`-xpi + Abs(xpi)`
simplify	`simplify(Residual)`	→	`-xpi + Abs(xpi)`
answer			`null`

sp-acj4-147-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(cosh(asinh(x)))) ∧ (~Q.zero(x)) ∧ Ne((1/x), I) ∧ Ne((1/x), (-I)) ⊢ Eq(Abs(tanh(asinh(x))), cos(atan((1/x)))) null difference → Abs(x)/Abs(sqrt(x**2 + 1)) - 1/sqrt(1 + x**(-2)) · simplify → Abs(x/sqrt(x**2 + 1)) - 1/sqrt(1 + x**(-2)) 0.06 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(asinh(x)))
# dropped (not a unary fact about one symbol): Ne(1 / x, I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(1 / x, -I, evaluate=False)
Residual = Abs(tanh(asinh(x))) - cos(atan(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(tanh(asinh(x))) - cos(atan(1 / x))`	→	`Abs(x)/Abs(sqrt(x2 + 1)) - 1/sqrt(1 + x(-2))`
simplify	`simplify(Residual)`	→	`Abs(x/sqrt(x2 + 1)) - 1/sqrt(1 + x(-2))`
answer			`null`

sp-acj4-151-complex contingent simplipy-complex-branch no verdict Q.complex(x) ⊢ Eq(acos(cos(asin(x))), Abs(asin(x))) null difference → -Abs(asin(x)) + acos(sqrt(1 - x**2)) · simplify → -Abs(asin(x)) + acos(sqrt(1 - x**2)) 0.032 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
Residual = acos(cos(asin(x))) - Abs(asin(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`acos(cos(asin(x))) - Abs(asin(x))`	→	`-Abs(asin(x)) + acos(sqrt(1 - x**2))`
simplify	`simplify(Residual)`	→	`-Abs(asin(x)) + acos(sqrt(1 - x**2))`
answer			`null`

sp-acj4-153-complex contingent simplipy-complex-branch no verdict Q.complex(x) ⊢ Eq(acos(cos(cos(x))), Abs(cos(x))) null difference → -Abs(cos(x)) + acos(cos(cos(x))) · simplify → -Abs(cos(x)) + acos(cos(cos(x))) 0.057 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
Residual = acos(cos(cos(x))) - Abs(cos(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`acos(cos(cos(x))) - Abs(cos(x))`	→	`-Abs(cos(x)) + acos(cos(cos(x)))`
simplify	`simplify(Residual)`	→	`-Abs(cos(x)) + acos(cos(cos(x)))`
answer			`null`

sp-acj4-154-complex contingent simplipy-complex-branch no verdict Q.complex(x) ⊢ Eq(acos(cos(sin(x))), Abs(sin(x))) null difference → -Abs(sin(x)) + acos(cos(sin(x))) · simplify → -Abs(sin(x)) + acos(cos(sin(x))) 0.063 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
Residual = acos(cos(sin(x))) - Abs(sin(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`acos(cos(sin(x))) - Abs(sin(x))`	→	`-Abs(sin(x)) + acos(cos(sin(x)))`
simplify	`simplify(Residual)`	→	`-Abs(sin(x)) + acos(cos(sin(x)))`
answer			`null`

sp-acj4-165-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ Ne(x, I) ∧ Ne(x, (-I)) ∧ (~Q.zero(x)) ∧ Ne((1/x), I) ∧ Ne((1/x), (-I)) ⊢ Eq(asin(cos(atan(x))), Abs(atan((1/x)))) null difference → -Abs(atan(1/x)) + asin(1/sqrt(x**2 + 1)) · simplify → -Abs(atan(1/x)) + asin(1/sqrt(x**2 + 1)) 0.033 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): Ne(x, I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(x, -I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(1 / x, I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(1 / x, -I, evaluate=False)
Residual = asin(cos(atan(x))) - Abs(atan(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`asin(cos(atan(x))) - Abs(atan(1 / x))`	→	`-Abs(atan(1/x)) + asin(1/sqrt(x**2 + 1))`
simplify	`simplify(Residual)`	→	`-Abs(atan(1/x)) + asin(1/sqrt(x**2 + 1))`
answer			`null`

sp-acj4-173-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(cosh(x))) ⊢ Eq(asin(tanh(Abs(x))), acos((1/cosh(x)))) null difference → -acos(1/cosh(x)) + asin(tanh(Abs(x))) · simplify → -acos(1/cosh(x)) + asin(tanh(Abs(x))) 0.124 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(x))
Residual = asin(tanh(Abs(x))) - acos(1 / cosh(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`asin(tanh(Abs(x))) - acos(1 / cosh(x))`	→	`-acos(1/cosh(x)) + asin(tanh(Abs(x)))`
simplify	`simplify(Residual)`	→	`-acos(1/cosh(x)) + asin(tanh(Abs(x)))`
answer			`null`

sp-acj4-176-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(cosh(x))) ⊢ Eq(atan(Abs(sinh(x))), acos((1/cosh(x)))) null difference → -acos(1/cosh(x)) + atan(Abs(sinh(x))) · simplify → -acos(1/cosh(x)) + atan(Abs(sinh(x))) 0.095 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(x))
Residual = atan(Abs(sinh(x))) - acos(1 / cosh(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atan(Abs(sinh(x))) - acos(1 / cosh(x))`	→	`-acos(1/cosh(x)) + atan(Abs(sinh(x)))`
simplify	`simplify(Residual)`	→	`-acos(1/cosh(x)) + atan(Abs(sinh(x)))`
answer			`null`

sp-acj4-177-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(cos(x))) ⊢ Eq(atan(Abs(tan(x))), Abs(asin(sin(x)))) null difference → -Abs(asin(sin(x))) + atan(Abs(tan(x))) · simplify → -Abs(asin(sin(x))) + atan(Abs(tan(x))) 0.068 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(x))
Residual = atan(Abs(tan(x))) - Abs(asin(sin(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atan(Abs(tan(x))) - Abs(asin(sin(x)))`	→	`-Abs(asin(sin(x))) + atan(Abs(tan(x)))`
simplify	`simplify(Residual)`	→	`-Abs(asin(sin(x))) + atan(Abs(tan(x)))`
answer			`null`

sp-acj4-180-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ Ne(sinh(acosh(x)), I) ∧ Ne(sinh(acosh(x)), (-I)) ∧ (~Q.zero(cosh(acosh(x)))) ⊢ Eq(atan(sinh(acosh(x))), asin(tanh(acosh(x)))) null difference → -asin(sqrt(x - 1)*sqrt(x + 1)/x) + atan(sqrt(x - 1)*sqrt(x + 1)) · simplify → -asin(sqrt(x - 1)*sqrt(x + 1)/x) + atan(sqrt(x - 1)*sqrt(x + 1)) 0.053 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): Ne(sinh(acosh(x)), I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(sinh(acosh(x)), -I, evaluate=False)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(acosh(x)))
Residual = atan(sinh(acosh(x))) - asin(tanh(acosh(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atan(sinh(acosh(x))) - asin(tanh(acosh(x)))`	→	`-asin(sqrt(x - 1)sqrt(x + 1)/x) + atan(sqrt(x - 1)sqrt(x + 1))`
simplify	`simplify(Residual)`	→	`-asin(sqrt(x - 1)sqrt(x + 1)/x) + atan(sqrt(x - 1)sqrt(x + 1))`
answer			`null`

sp-acj4-183-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(x)) ∧ Ne(sinh(log(x)), I) ∧ Ne(sinh(log(x)), (-I)) ∧ (~Q.zero(cosh(log(x)))) ⊢ Eq(atan(sinh(log(x))), asin(tanh(log(x)))) null difference → -asin(tanh(log(x))) + atan(sinh(log(x))) · simplify → -asin(tanh(log(x))) + atan(sinh(log(x))) 0.079 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): Ne(sinh(log(x)), I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(sinh(log(x)), -I, evaluate=False)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(log(x)))
Residual = atan(sinh(log(x))) - asin(tanh(log(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atan(sinh(log(x))) - asin(tanh(log(x)))`	→	`-asin(tanh(log(x))) + atan(sinh(log(x)))`
simplify	`simplify(Residual)`	→	`-asin(tanh(log(x))) + atan(sinh(log(x)))`
answer			`null`

sp-acj4-189-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ Ne(cos(asin(x)), 1) ∧ Ne(cos(asin(x)), (-1)) ∧ (~Q.zero(x)) ⊢ Eq(atanh(cos(asin(x))), acosh(Abs((1/x)))) null difference → -acosh(1/Abs(x)) + atanh(sqrt(1 - x**2)) · simplify → -acosh(1/Abs(x)) + atanh(sqrt(1 - x**2)) 0.047 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): Ne(cos(asin(x)), 1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(cos(asin(x)), -1, evaluate=False)
Residual = atanh(cos(asin(x))) - acosh(Abs(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atanh(cos(asin(x))) - acosh(Abs(1 / x))`	→	`-acosh(1/Abs(x)) + atanh(sqrt(1 - x**2))`
simplify	`simplify(Residual)`	→	`-acosh(1/Abs(x)) + atanh(sqrt(1 - x**2))`
answer			`null`

sp-acj4-190-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ Ne(x, I) ∧ Ne(x, (-I)) ∧ Ne(cos(atan(x)), 1) ∧ Ne(cos(atan(x)), (-1)) ∧ (~Q.zero(x)) ⊢ Eq(atanh(cos(atan(x))), Abs(asinh((1/x)))) null difference → -Abs(asinh(1/x)) + atanh(1/sqrt(x**2 + 1)) · simplify → -Abs(asinh(1/x)) + atanh(1/sqrt(x**2 + 1)) 0.036 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): Ne(x, I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(x, -I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(cos(atan(x)), 1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(cos(atan(x)), -1, evaluate=False)
Residual = atanh(cos(atan(x))) - Abs(asinh(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atanh(cos(atan(x))) - Abs(asinh(1 / x))`	→	`-Abs(asinh(1/x)) + atanh(1/sqrt(x**2 + 1))`
simplify	`simplify(Residual)`	→	`-Abs(asinh(1/x)) + atanh(1/sqrt(x**2 + 1))`
answer			`null`

sp-acj4-191-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ Ne(sin(acos(x)), 1) ∧ Ne(sin(acos(x)), (-1)) ∧ (~Q.zero(x)) ⊢ Eq(atanh(sin(acos(x))), acosh(Abs((1/x)))) null difference → -acosh(1/Abs(x)) + atanh(sqrt(1 - x**2)) · simplify → -acosh(1/Abs(x)) + atanh(sqrt(1 - x**2)) 0.047 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): Ne(sin(acos(x)), 1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(sin(acos(x)), -1, evaluate=False)
Residual = atanh(sin(acos(x))) - acosh(Abs(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atanh(sin(acos(x))) - acosh(Abs(1 / x))`	→	`-acosh(1/Abs(x)) + atanh(sqrt(1 - x**2))`
simplify	`simplify(Residual)`	→	`-acosh(1/Abs(x)) + atanh(sqrt(1 - x**2))`
answer			`null`

sp-acj4-20-complex contingent simplipy-complex-branch no verdict Q.complex(x) ⊢ Eq(sinh(Abs(x)), Abs(sinh(x))) null difference → sinh(Abs(x)) - Abs(sinh(x)) · simplify → sinh(Abs(x)) - Abs(sinh(x)) 0.083 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
Residual = sinh(Abs(x)) - Abs(sinh(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`sinh(Abs(x)) - Abs(sinh(x))`	→	`sinh(Abs(x)) - Abs(sinh(x))`
simplify	`simplify(Residual)`	→	`sinh(Abs(x)) - Abs(sinh(x))`
answer			`null`

sp-acj4-203-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(x)) ∧ (~Q.zero((1/x))) ⊢ Eq(cos(log((1/x))), cos(log(x))) null difference → cos(log(1/x)) - cos(log(x)) · simplify → cos(log(1/x)) - cos(log(x)) 0.049 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(1 / x)
Residual = cos(log(1 / x)) - cos(log(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`cos(log(1 / x)) - cos(log(x))`	→	`cos(log(1/x)) - cos(log(x))`
simplify	`simplify(Residual)`	→	`cos(log(1/x)) - cos(log(x))`
answer			`null`

sp-acj4-213-complex true simplipy-complex-branch solved Q.complex(x) ∧ (~Q.zero(x)) ∧ (~Q.zero(((-10)/x))) ⊢ Eq((1/((-10)/x)), (x/(-10))) true difference → 0 · simplify → 0 0.008 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(-10 / x)
Residual = 1 / (-10 / x) - (x / -10)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`1 / (-10 / x) - (x / -10)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-216-complex true simplipy-complex-branch solved Q.complex(x) ∧ (~Q.zero(x)) ∧ (~Q.zero(((-4)/x))) ⊢ Eq((1/((-4)/x)), (x/(-4))) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(-4 / x)
Residual = 1 / (-4 / x) - (x / -4)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`1 / (-4 / x) - (x / -4)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-22-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(cosh(x))) ⊢ Eq(tanh(Abs(x)), Abs(tanh(x))) null difference → tanh(Abs(x)) - Abs(tanh(x)) · simplify → tanh(Abs(x)) - Abs(tanh(x)) 0.096 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(x))
Residual = tanh(Abs(x)) - Abs(tanh(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`tanh(Abs(x)) - Abs(tanh(x))`	→	`tanh(Abs(x)) - Abs(tanh(x))`
simplify	`simplify(Residual)`	→	`tanh(Abs(x)) - Abs(tanh(x))`
answer			`null`

sp-acj4-234-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ Or((~Q.zero(x)), (re(x) > 0)) ∧ (~Q.zero(Pow(x, x))) ∧ (~Q.zero(x)) ∧ Or((~Q.zero((1/x))), (re(x) > 0)) ⊢ Eq((1/Pow(x, x)), Pow((1/x), x)) null difference → -(1/x)**x + x**(-x) · simplify → -(1/x)**x + x**(-x) 0.028 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): Or(~Q.zero(x), re(x) > 0)
# dropped (not a unary fact about one symbol): ~Q.zero(Pow(x, x))
# dropped (not a unary fact about one symbol): Or(~Q.zero(1 / x), re(x) > 0)
Residual = 1 / Pow(x, x) - Pow(1 / x, x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`1 / Pow(x, x) - Pow(1 / x, x)`	→	`-(1/x)x + x(-x)`
simplify	`simplify(Residual)`	→	`-(1/x)x + x(-x)`
answer			`null`

sp-acj4-252-complex contingent simplipy-complex-branch no verdict Q.complex(x) ⊢ Eq((-Abs(sinh(x))), sinh((-Abs(x)))) null difference → sinh(Abs(x)) - Abs(sinh(x)) · simplify → sinh(Abs(x)) - Abs(sinh(x)) 0.083 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
Residual = -Abs(sinh(x)) - sinh(-Abs(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-Abs(sinh(x)) - sinh(-Abs(x))`	→	`sinh(Abs(x)) - Abs(sinh(x))`
simplify	`simplify(Residual)`	→	`sinh(Abs(x)) - Abs(sinh(x))`
answer			`null`

sp-acj4-253-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(cosh(x))) ⊢ Eq((-Abs(tanh(x))), tanh((-Abs(x)))) null difference → tanh(Abs(x)) - Abs(tanh(x)) · simplify → tanh(Abs(x)) - Abs(tanh(x)) 0.096 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(x))
Residual = -Abs(tanh(x)) - tanh(-Abs(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-Abs(tanh(x)) - tanh(-Abs(x))`	→	`tanh(Abs(x)) - Abs(tanh(x))`
simplify	`simplify(Residual)`	→	`tanh(Abs(x)) - Abs(tanh(x))`
answer			`null`

sp-acj4-260-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(cos(x))) ∧ (~Q.zero((1/cos(x)))) ⊢ Eq((-log(cos(x))), log((1/cos(x)))) null difference → -log(1/cos(x)) - log(cos(x)) · simplify → -log(1/cos(x)) - log(cos(x)) 0.06 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(x))
# dropped (not a unary fact about one symbol): ~Q.zero(1 / cos(x))
Residual = -log(cos(x)) - log(1 / cos(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-log(cos(x)) - log(1 / cos(x))`	→	`-log(1/cos(x)) - log(cos(x))`
simplify	`simplify(Residual)`	→	`-log(1/cos(x)) - log(cos(x))`
answer			`null`

sp-acj4-261-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(cosh(x))) ∧ (~Q.zero((1/cosh(x)))) ⊢ Eq((-log(cosh(x))), log((1/cosh(x)))) null difference → -log(1/cosh(x)) - log(cosh(x)) · simplify → -log(1/cosh(x)) - log(cosh(x)) 0.084 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(x))
# dropped (not a unary fact about one symbol): ~Q.zero(1 / cosh(x))
Residual = -log(cosh(x)) - log(1 / cosh(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-log(cosh(x)) - log(1 / cosh(x))`	→	`-log(1/cosh(x)) - log(cosh(x))`
simplify	`simplify(Residual)`	→	`-log(1/cosh(x)) - log(cosh(x))`
answer			`null`

sp-acj4-266-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(x)) ∧ (~Q.zero((1/x))) ⊢ Eq((-sin(log(x))), sin(log((1/x)))) null difference → -sin(log(1/x)) - sin(log(x)) · simplify → -sin(log(1/x)) - sin(log(x)) 0.051 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(1 / x)
Residual = -sin(log(x)) - sin(log(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-sin(log(x)) - sin(log(1 / x))`	→	`-sin(log(1/x)) - sin(log(x))`
simplify	`simplify(Residual)`	→	`-sin(log(1/x)) - sin(log(x))`
answer			`null`

sp-acj4-267-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(x)) ∧ (~Q.zero(cos(log(x)))) ∧ (~Q.zero((1/x))) ∧ (~Q.zero(cos(log((1/x))))) ⊢ Eq((-tan(log(x))), tan(log((1/x)))) null difference → -tan(log(1/x)) - tan(log(x)) · simplify → -tan(log(1/x)) - tan(log(x)) 0.055 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(log(x)))
# dropped (not a unary fact about one symbol): ~Q.zero(1 / x)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(log(1 / x)))
Residual = -tan(log(x)) - tan(log(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-tan(log(x)) - tan(log(1 / x))`	→	`-tan(log(1/x)) - tan(log(x))`
simplify	`simplify(Residual)`	→	`-tan(log(1/x)) - tan(log(x))`
answer			`null`

sp-acj4-274-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(Abs(x))) ∧ (~Q.zero(x)) ⊢ Eq(Pow(Abs(x), (-2)), Pow(x, (-2))) null difference → Abs(x)**(-2) - 1/x**2 · simplify → 1/Abs(x**2) - 1/x**2 0.032 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(Abs(x))
Residual = Pow(Abs(x), -2) - Pow(x, -2)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(Abs(x), -2) - Pow(x, -2)`	→	`Abs(x)(-2) - 1/x2`
simplify	`simplify(Residual)`	→	`1/Abs(x2) - 1/x2`
answer			`null`

sp-acj4-278-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(Abs(x))) ∧ (~Q.zero(x)) ⊢ Eq(Pow(Abs(x), (-6)), Pow(x, (-6))) null difference → Abs(x)**(-6) - 1/x**6 · simplify → 1/Abs(x**6) - 1/x**6 0.032 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(Abs(x))
Residual = Pow(Abs(x), -6) - Pow(x, -6)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(Abs(x), -6) - Pow(x, -6)`	→	`Abs(x)(-6) - 1/x6`
simplify	`simplify(Residual)`	→	`1/Abs(x6) - 1/x6`
answer			`null`

sp-acj4-283-complex contingent simplipy-complex-branch no verdict Q.complex(x) ⊢ Eq(Pow(Abs(x), 2), (x*x)) null difference → -x**2 + Abs(x)**2 · simplify → -x**2 + Abs(x)**2 0.021 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
Residual = Pow(Abs(x), 2) - (x * x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(Abs(x), 2) - (x * x)`	→	`-x2 + Abs(x)2`
simplify	`simplify(Residual)`	→	`-x2 + Abs(x)2`
answer			`null`

sp-acj4-284-complex true simplipy-complex-branch no verdict Q.complex(x) ⊢ Eq(Pow(Abs(x), 3), Abs(Pow(x, 3))) null difference → Abs(x)**3 - Abs(x**3) · simplify → Abs(x)**3 - Abs(x**3) 0.023 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
Residual = Pow(Abs(x), 3) - Abs(Pow(x, 3))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(Abs(x), 3) - Abs(Pow(x, 3))`	→	`Abs(x)3 - Abs(x3)`
simplify	`simplify(Residual)`	→	`Abs(x)3 - Abs(x3)`
answer			`null`

sp-acj4-288-complex true simplipy-complex-branch no verdict Q.complex(x) ⊢ Eq(Pow(Abs(x), 7), Abs(Pow(x, 7))) null difference → Abs(x)**7 - Abs(x**7) · simplify → Abs(x)**7 - Abs(x**7) 0.023 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
Residual = Pow(Abs(x), 7) - Abs(Pow(x, 7))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(Abs(x), 7) - Abs(Pow(x, 7))`	→	`Abs(x)7 - Abs(x7)`
simplify	`simplify(Residual)`	→	`Abs(x)7 - Abs(x7)`
answer			`null`

sp-acj4-30-complex true simplipy-complex-branch solved Q.complex(x) ⊢ Eq((4*Abs(x)), Abs(((-4)*x))) true difference → 0 · simplify → 0 0.008 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
Residual = 4 * Abs(x) - Abs(-4 * x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`4 * Abs(x) - Abs(-4 * x)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-334-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ Or((~Q.zero(exp(x))), (re(exp(1)) > 0)) ⊢ Eq(Pow(exp(x), exp(1)), exp((exp(1)*x))) null difference → exp(x)**E - exp(E*x) · simplify → exp(x)**E - exp(E*x) 0.035 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): Or(~Q.zero(exp(x)), re(exp(1)) > 0)
Residual = Pow(exp(x), exp(1)) - exp(exp(1) * x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(exp(x), exp(1)) - exp(exp(1) * x)`	→	`exp(x)*E - exp(Ex)`
simplify	`simplify(Residual)`	→	`exp(x)*E - exp(Ex)`
answer			`null`

sp-acj4-335-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ Or((~Q.zero(exp(x))), (re(pi) > 0)) ⊢ Eq(Pow(exp(x), pi), exp((pi*x))) null difference → exp(x)**pi - exp(pi*x) · simplify → exp(x)**pi - exp(pi*x) 0.031 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): Or(~Q.zero(exp(x)), re(pi) > 0)
Residual = Pow(exp(x), pi) - exp(pi * x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(exp(x), pi) - exp(pi * x)`	→	`exp(x)*pi - exp(pix)`
simplify	`simplify(Residual)`	→	`exp(x)*pi - exp(pix)`
answer			`null`

sp-acj4-336-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ Or((~Q.zero(exp(x))), (re(x) > 0)) ⊢ Eq(Pow(exp(x), x), exp((x*x))) null difference → exp(x)**x - exp(x**2) · simplify → exp(x)**x - exp(x**2) 0.031 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): Or(~Q.zero(exp(x)), re(x) > 0)
Residual = Pow(exp(x), x) - exp(x * x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(exp(x), x) - exp(x * x)`	→	`exp(x)x - exp(x2)`
simplify	`simplify(Residual)`	→	`exp(x)x - exp(x2)`
answer			`null`

sp-acj4-343-complex true simplipy-complex-branch solved Q.complex(x) ⊢ Eq(Pow((1/pi), x), Pow(pi, (-x))) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
Residual = Pow(1 / pi, x) - Pow(pi, -x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(1 / pi, x) - Pow(pi, -x)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-344-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(x)) ∧ Or((~Q.zero((1/x))), (re(x) > 0)) ∧ Or((~Q.zero(x)), (re((-x)) > 0)) ⊢ Eq(Pow((1/x), x), Pow(x, (-x))) null difference → (1/x)**x - 1/x**x · simplify → (1/x)**x - 1/x**x 0.028 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): Or(~Q.zero(1 / x), re(x) > 0)
# dropped (not a unary fact about one symbol): Or(~Q.zero(x), re(-x) > 0)
Residual = Pow(1 / x, x) - Pow(x, -x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(1 / x, x) - Pow(x, -x)`	→	`(1/x)x - 1/xx`
simplify	`simplify(Residual)`	→	`(1/x)x - 1/xx`
answer			`null`

sp-acj4-368-complex true simplipy-complex-branch no verdict Q.complex(x) ∧ Q.real(acos(x)) ∧ (~Q.zero(acos(x))) ⊢ Eq(real_root(acos(x), (-5)), Pow(acos(x), Rational(-1, 5))) null difference → Piecewise((sign(acos(x))/Abs(acos(x))**(1/5), Eq(im(acos(x)), 0)), (acos(x)**(-1/5), True… · simplify → Piecewise((-1/acos(x)**(1/5), Eq(acos(x), 0) & Eq(im(acos(x)), 0)), (-1/acos(x)**(1/5) + … 0.107 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): Q.real(acos(x))
# dropped (not a unary fact about one symbol): ~Q.zero(acos(x))
Residual = real_root(acos(x), -5) - Pow(acos(x), Rational(-1, 5))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`real_root(acos(x), -5) - Pow(acos(x), Rational(-1, 5))`	→	`Piecewise((sign(acos(x))/Abs(acos(x))(1/5), Eq(im(acos(x)), 0)), (acos(x)(-1/5), True)) - 1/acos(x)**(1/5)`
simplify	`simplify(Residual)`	→	`Piecewise((-1/acos(x)(1/5), Eq(acos(x), 0) & Eq(im(acos(x)), 0)), (-1/acos(x)(1/5) + acos(x)/Abs(acos(x)**(6/5)), Eq(im(acos(x)), 0)), (0, True))`
answer			`null`

sp-acj4-369-complex true simplipy-complex-branch no verdict Q.complex(x) ∧ Q.real(acos(x)) ⊢ Eq(real_root(acos(x), 5), Pow(acos(x), Rational(1, 5))) null difference → Piecewise((Abs(acos(x))**(1/5)*sign(acos(x)), Eq(im(acos(x)), 0)), (acos(x)**(1/5), True)… · simplify → Piecewise((-acos(x)**(1/5), Eq(acos(x), 0) & Eq(im(acos(x)), 0)), (-acos(x)**(1/5) + acos… 0.093 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): Q.real(acos(x))
Residual = real_root(acos(x), 5) - Pow(acos(x), Rational(1, 5))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`real_root(acos(x), 5) - Pow(acos(x), Rational(1, 5))`	→	`Piecewise((Abs(acos(x))*(1/5)sign(acos(x)), Eq(im(acos(x)), 0)), (acos(x)(1/5), True)) - acos(x)(1/5)`
simplify	`simplify(Residual)`	→	`Piecewise((-acos(x)(1/5), Eq(acos(x), 0) & Eq(im(acos(x)), 0)), (-acos(x)(1/5) + acos(x)/Abs(acos(x)**(4/5)), Eq(im(acos(x)), 0)), (0, True))`
answer			`null`

sp-acj4-370-complex true simplipy-complex-branch no verdict Q.complex(x) ∧ Q.real(acosh(x)) ∧ (~Q.zero(acosh(x))) ⊢ Eq(real_root(acosh(x), (-5)), Pow(acosh(x), Rational(-1, 5))) null difference → Piecewise((sign(acosh(x))/Abs(acosh(x))**(1/5), Eq(im(acosh(x)), 0)), (acosh(x)**(-1/5), … · simplify → Piecewise((-1/acosh(x)**(1/5), Eq(acosh(x), 0) & Eq(im(acosh(x)), 0)), (-1/acosh(x)**(1/5… 0.106 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): Q.real(acosh(x))
# dropped (not a unary fact about one symbol): ~Q.zero(acosh(x))
Residual = real_root(acosh(x), -5) - Pow(acosh(x), Rational(-1, 5))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`real_root(acosh(x), -5) - Pow(acosh(x), Rational(-1, 5))`	→	`Piecewise((sign(acosh(x))/Abs(acosh(x))(1/5), Eq(im(acosh(x)), 0)), (acosh(x)(-1/5), True)) - 1/acosh(x)**(1/5)`
simplify	`simplify(Residual)`	→	`Piecewise((-1/acosh(x)(1/5), Eq(acosh(x), 0) & Eq(im(acosh(x)), 0)), (-1/acosh(x)(1/5) + acosh(x)/Abs(acosh(x)**(6/5)), Eq(im(acosh(x)), 0)), (0, True))`
answer			`null`

sp-acj4-371-complex true simplipy-complex-branch no verdict Q.complex(x) ∧ Q.real(acosh(x)) ⊢ Eq(real_root(acosh(x), 5), Pow(acosh(x), Rational(1, 5))) null difference → Piecewise((Abs(acosh(x))**(1/5)*sign(acosh(x)), Eq(im(acosh(x)), 0)), (acosh(x)**(1/5), T… · simplify → Piecewise((-acosh(x)**(1/5), Eq(acosh(x), 0) & Eq(im(acosh(x)), 0)), (-acosh(x)**(1/5) + … 0.093 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): Q.real(acosh(x))
Residual = real_root(acosh(x), 5) - Pow(acosh(x), Rational(1, 5))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`real_root(acosh(x), 5) - Pow(acosh(x), Rational(1, 5))`	→	`Piecewise((Abs(acosh(x))*(1/5)sign(acosh(x)), Eq(im(acosh(x)), 0)), (acosh(x)(1/5), True)) - acosh(x)(1/5)`
simplify	`simplify(Residual)`	→	`Piecewise((-acosh(x)(1/5), Eq(acosh(x), 0) & Eq(im(acosh(x)), 0)), (-acosh(x)(1/5) + acosh(x)/Abs(acosh(x)**(4/5)), Eq(im(acosh(x)), 0)), (0, True))`
answer			`null`

sp-acj4-372-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ Q.real(cosh(x)) ∧ (~Q.zero(cosh(x))) ⊢ Eq(real_root(cosh(x), (-5)), Pow(cosh(x), Rational(-1, 5))) null difference → Piecewise((sign(cosh(x))/Abs(cosh(x))**(1/5), Eq(sin(im(x))*sinh(re(x)), 0)), (cosh(x)**(… · simplify → Piecewise((-1/cosh(x)**(1/5), Eq(cosh(x), 0) & Eq(sin(im(x))*sinh(re(x)), 0)), (cosh(x)/A… 0.368 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): Q.real(cosh(x))
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(x))
Residual = real_root(cosh(x), -5) - Pow(cosh(x), Rational(-1, 5))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`real_root(cosh(x), -5) - Pow(cosh(x), Rational(-1, 5))`	→	`Piecewise((sign(cosh(x))/Abs(cosh(x))*(1/5), Eq(sin(im(x))sinh(re(x)), 0)), (cosh(x)(-1/5), True)) - 1/cosh(x)(1/5)`
simplify	`simplify(Residual)`	→	`Piecewise((-1/cosh(x)*(1/5), Eq(cosh(x), 0) & Eq(sin(im(x))sinh(re(x)), 0)), (cosh(x)/Abs(cosh(x)(6/5)) - 1/cosh(x)(1/5), Eq(sin(im(x))*sinh(re(x)), 0)), (0, True))`
answer			`null`

sp-acj4-373-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ Q.real(cosh(x)) ⊢ Eq(real_root(cosh(x), 5), Pow(cosh(x), Rational(1, 5))) null difference → Piecewise((Abs(cosh(x))**(1/5)*sign(cosh(x)), Eq(sin(im(x))*sinh(re(x)), 0)), (cosh(x)**(… · simplify → Piecewise((-cosh(x)**(1/5), Eq(cosh(x), 0) & Eq(sin(im(x))*sinh(re(x)), 0)), (-cosh(x)**(… 0.351 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): Q.real(cosh(x))
Residual = real_root(cosh(x), 5) - Pow(cosh(x), Rational(1, 5))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`real_root(cosh(x), 5) - Pow(cosh(x), Rational(1, 5))`	→	`Piecewise((Abs(cosh(x))*(1/5)sign(cosh(x)), Eq(sin(im(x))sinh(re(x)), 0)), (cosh(x)(1/5), True)) - cosh(x)*(1/5)`
simplify	`simplify(Residual)`	→	`Piecewise((-cosh(x)*(1/5), Eq(cosh(x), 0) & Eq(sin(im(x))sinh(re(x)), 0)), (-cosh(x)(1/5) + cosh(x)/Abs(cosh(x)(4/5)), Eq(sin(im(x))*sinh(re(x)), 0)), (0, True))`
answer			`null`

sp-acj4-387-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ Q.real(exp(x)) ⊢ Eq(real_root(exp(x), 5), exp((x/5))) null difference → Piecewise((exp(re(x)/5)*sign(exp(x)), Eq(exp(re(x))*sin(im(x)), 0)), (exp(x)**(1/5), True… · simplify → Piecewise((-exp(x/5) + exp(x - 4*re(x)/5), Eq(exp(re(x))*sin(im(x)), 0)), (-exp(x/5) + ex… 0.151 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): Q.real(exp(x))
Residual = real_root(exp(x), 5) - exp(x / 5)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`real_root(exp(x), 5) - exp(x / 5)`	→	`Piecewise((exp(re(x)/5)sign(exp(x)), Eq(exp(re(x))sin(im(x)), 0)), (exp(x)**(1/5), True)) - exp(x/5)`
simplify	`simplify(Residual)`	→	`Piecewise((-exp(x/5) + exp(x - 4re(x)/5), Eq(exp(re(x))sin(im(x)), 0)), (-exp(x/5) + exp(x)**(1/5), True))`
answer			`null`

sp-acj4-389-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ Q.real(exp(x)) ⊢ Eq(real_root(exp(x), 7), exp((x/7))) null difference → Piecewise((exp(re(x)/7)*sign(exp(x)), Eq(exp(re(x))*sin(im(x)), 0)), (exp(x)**(1/7), True… · simplify → Piecewise((-exp(x/7) + exp(x - 6*re(x)/7), Eq(exp(re(x))*sin(im(x)), 0)), (-exp(x/7) + ex… 0.151 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): Q.real(exp(x))
Residual = real_root(exp(x), 7) - exp(x / 7)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`real_root(exp(x), 7) - exp(x / 7)`	→	`Piecewise((exp(re(x)/7)sign(exp(x)), Eq(exp(re(x))sin(im(x)), 0)), (exp(x)**(1/7), True)) - exp(x/7)`
simplify	`simplify(Residual)`	→	`Piecewise((-exp(x/7) + exp(x - 6re(x)/7), Eq(exp(re(x))sin(im(x)), 0)), (-exp(x/7) + exp(x)**(1/7), True))`
answer			`null`

sp-acj4-396-complex contingent simplipy-complex-branch no verdict Q.complex(x) ⊢ Eq(sin(Abs(sin(x))), Abs(sin(sin(x)))) null difference → sin(Abs(sin(x))) - Abs(sin(sin(x))) · simplify → sin(Abs(sin(x))) - Abs(sin(sin(x))) 0.095 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
Residual = sin(Abs(sin(x))) - Abs(sin(sin(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`sin(Abs(sin(x))) - Abs(sin(sin(x)))`	→	`sin(Abs(sin(x))) - Abs(sin(sin(x)))`
simplify	`simplify(Residual)`	→	`sin(Abs(sin(x))) - Abs(sin(sin(x)))`
answer			`null`

sp-acj4-40-complex true simplipy-complex-branch solved Q.complex(x) ⊢ Eq((Abs(x)*pi), Abs((pi*x))) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
Residual = Abs(x) * pi - Abs(pi * x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(x) * pi - Abs(pi * x)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-403-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(x)) ∧ (~Q.zero((1/x))) ⊢ Eq(sin((-log(x))), sin(log((1/x)))) null difference → -sin(log(1/x)) - sin(log(x)) · simplify → -sin(log(1/x)) - sin(log(x)) 0.051 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(1 / x)
Residual = sin(-log(x)) - sin(log(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`sin(-log(x)) - sin(log(1 / x))`	→	`-sin(log(1/x)) - sin(log(x))`
simplify	`simplify(Residual)`	→	`-sin(log(1/x)) - sin(log(x))`
answer			`null`

sp-acj4-404-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(cosh(x))) ⊢ Eq(sin(tanh(Abs(x))), Abs(sin(tanh(x)))) null difference → sin(tanh(Abs(x))) - Abs(sin(tanh(x))) · simplify → sin(tanh(Abs(x))) - Abs(sin(tanh(x))) 0.09 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(x))
Residual = sin(tanh(Abs(x))) - Abs(sin(tanh(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`sin(tanh(Abs(x))) - Abs(sin(tanh(x)))`	→	`sin(tanh(Abs(x))) - Abs(sin(tanh(x)))`
simplify	`simplify(Residual)`	→	`sin(tanh(Abs(x))) - Abs(sin(tanh(x)))`
answer			`null`

sp-acj4-414-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(cos(Abs(sin(x))))) ∧ (~Q.zero(cos(sin(x)))) ⊢ Eq(tan(Abs(sin(x))), Abs(tan(sin(x)))) null difference → tan(Abs(sin(x))) - Abs(tan(sin(x))) · simplify → tan(Abs(sin(x))) - Abs(tan(sin(x))) 0.11 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(Abs(sin(x))))
# dropped (not a unary fact about one symbol): ~Q.zero(cos(sin(x)))
Residual = tan(Abs(sin(x))) - Abs(tan(sin(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`tan(Abs(sin(x))) - Abs(tan(sin(x)))`	→	`tan(Abs(sin(x))) - Abs(tan(sin(x)))`
simplify	`simplify(Residual)`	→	`tan(Abs(sin(x))) - Abs(tan(sin(x)))`
answer			`null`

sp-acj4-415-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(cosh(x))) ∧ (~Q.zero(cos(Abs(tanh(x))))) ∧ (~Q.zero(cos(tanh(x)))) ⊢ Eq(tan(Abs(tanh(x))), Abs(tan(tanh(x)))) null difference → tan(Abs(tanh(x))) - Abs(tan(tanh(x))) · simplify → tan(Abs(tanh(x))) - Abs(tan(tanh(x))) 0.097 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(x))
# dropped (not a unary fact about one symbol): ~Q.zero(cos(Abs(tanh(x))))
# dropped (not a unary fact about one symbol): ~Q.zero(cos(tanh(x)))
Residual = tan(Abs(tanh(x))) - Abs(tan(tanh(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`tan(Abs(tanh(x))) - Abs(tan(tanh(x)))`	→	`tan(Abs(tanh(x))) - Abs(tan(tanh(x)))`
simplify	`simplify(Residual)`	→	`tan(Abs(tanh(x))) - Abs(tan(tanh(x)))`
answer			`null`

sp-acj4-420-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(x)) ∧ (~Q.zero(cos((-log(x))))) ∧ (~Q.zero((1/x))) ∧ (~Q.zero(cos(log((1/x))))) ⊢ Eq(tan((-log(x))), tan(log((1/x)))) null difference → -tan(log(1/x)) - tan(log(x)) · simplify → -tan(log(1/x)) - tan(log(x)) 0.055 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(-log(x)))
# dropped (not a unary fact about one symbol): ~Q.zero(1 / x)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(log(1 / x)))
Residual = tan(-log(x)) - tan(log(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`tan(-log(x)) - tan(log(1 / x))`	→	`-tan(log(1/x)) - tan(log(x))`
simplify	`simplify(Residual)`	→	`-tan(log(1/x)) - tan(log(x))`
answer			`null`

sp-acj4-421-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(cos(tanh(Abs(x))))) ∧ (~Q.zero(cosh(x))) ∧ (~Q.zero(cos(tanh(x)))) ⊢ Eq(tan(tanh(Abs(x))), Abs(tan(tanh(x)))) null difference → tan(tanh(Abs(x))) - Abs(tan(tanh(x))) · simplify → tan(tanh(Abs(x))) - Abs(tan(tanh(x))) 0.102 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(tanh(Abs(x))))
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(x))
# dropped (not a unary fact about one symbol): ~Q.zero(cos(tanh(x)))
Residual = tan(tanh(Abs(x))) - Abs(tan(tanh(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`tan(tanh(Abs(x))) - Abs(tan(tanh(x)))`	→	`tan(tanh(Abs(x))) - Abs(tan(tanh(x)))`
simplify	`simplify(Residual)`	→	`tan(tanh(Abs(x))) - Abs(tan(tanh(x)))`
answer			`null`

sp-acj4-422-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(x)) ∧ Ne((1/x), I) ∧ Ne((1/x), (-I)) ⊢ Eq(tanh(Abs(asinh(x))), cos(atan((1/x)))) null difference → tanh(Abs(asinh(x))) - 1/sqrt(1 + x**(-2)) · simplify → tanh(Abs(asinh(x))) - 1/sqrt(1 + x**(-2)) 0.13 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): Ne(1 / x, I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(1 / x, -I, evaluate=False)
Residual = tanh(Abs(asinh(x))) - cos(atan(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`tanh(Abs(asinh(x))) - cos(atan(1 / x))`	→	`tanh(Abs(asinh(x))) - 1/sqrt(1 + x**(-2))`
simplify	`simplify(Residual)`	→	`tanh(Abs(asinh(x))) - 1/sqrt(1 + x**(-2))`
answer			`null`

sp-acj4-423-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(cosh(acosh(Abs(x))))) ∧ (~Q.zero(x)) ⊢ Eq(tanh(acosh(Abs(x))), cos(asin((1/x)))) null difference → -sqrt(1 - 1/x**2) + sqrt(Abs(x) - 1)*sqrt(Abs(x) + 1)/Abs(x) · simplify → -sqrt(1 - 1/x**2) + sqrt(Abs(x)**2 - 1)/Abs(x) 0.059 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(acosh(Abs(x))))
Residual = tanh(acosh(Abs(x))) - cos(asin(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`tanh(acosh(Abs(x))) - cos(asin(1 / x))`	→	`-sqrt(1 - 1/x*2) + sqrt(Abs(x) - 1)sqrt(Abs(x) + 1)/Abs(x)`
simplify	`simplify(Residual)`	→	`-sqrt(1 - 1/x2) + sqrt(Abs(x)2 - 1)/Abs(x)`
answer			`null`

sp-acj4-424-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(x)) ∧ Ne((1/x), I) ∧ Ne((1/x), (-I)) ⊢ Eq(tanh(asinh(Abs(x))), cos(atan((1/x)))) null difference → Abs(x)/sqrt(Abs(x)**2 + 1) - 1/sqrt(1 + x**(-2)) · simplify → Abs(x)/sqrt(Abs(x)**2 + 1) - 1/sqrt(1 + x**(-2)) 0.056 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): Ne(1 / x, I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(1 / x, -I, evaluate=False)
Residual = tanh(asinh(Abs(x))) - cos(atan(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`tanh(asinh(Abs(x))) - cos(atan(1 / x))`	→	`Abs(x)/sqrt(Abs(x)2 + 1) - 1/sqrt(1 + x(-2))`
simplify	`simplify(Residual)`	→	`Abs(x)/sqrt(Abs(x)2 + 1) - 1/sqrt(1 + x(-2))`
answer			`null`

sp-acj4-430-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(x)) ∧ Or((~Q.zero(x)), (re(x) > 0)) ∧ (~Q.zero(Pow(x, x))) ⊢ Eq((log(x)*x), log(Pow(x, x))) null difference → x*log(x) - log(x**x) · simplify → x*log(x) - log(x**x) 0.025 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): Or(~Q.zero(x), re(x) > 0)
# dropped (not a unary fact about one symbol): ~Q.zero(Pow(x, x))
Residual = log(x) * x - log(Pow(x, x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`log(x) * x - log(Pow(x, x))`	→	`xlog(x) - log(x*x)`
simplify	`simplify(Residual)`	→	`xlog(x) - log(x*x)`
answer			`null`

sp-acj4-433-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(x)) ∧ Ne((-log(x)), I) ∧ Ne((-log(x)), (-I)) ∧ (~Q.zero((1/x))) ∧ Ne(log((1/x)), I) ∧ Ne(log((1/x)), (-I)) ⊢ Eq(atan((-log(x))), atan(log((1/x)))) null difference → -atan(log(1/x)) - atan(log(x)) · simplify → -atan(log(1/x)) - atan(log(x)) 0.027 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): Ne(-log(x), I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(-log(x), -I, evaluate=False)
# dropped (not a unary fact about one symbol): ~Q.zero(1 / x)
# dropped (not a unary fact about one symbol): Ne(log(1 / x), I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(log(1 / x), -I, evaluate=False)
Residual = atan(-log(x)) - atan(log(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atan(-log(x)) - atan(log(1 / x))`	→	`-atan(log(1/x)) - atan(log(x))`
simplify	`simplify(Residual)`	→	`-atan(log(1/x)) - atan(log(x))`
answer			`null`

sp-acj4-442-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(x)) ∧ (~Q.zero(log(x))) ∧ (~Q.zero((1/log(x)))) ⊢ Eq((-log(log(x))), log((1/log(x)))) null difference → -log(1/log(x)) - log(log(x)) · simplify → -log(1/log(x)) - log(log(x)) 0.026 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(log(x))
# dropped (not a unary fact about one symbol): ~Q.zero(1 / log(x))
Residual = -log(log(x)) - log(1 / log(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-log(log(x)) - log(1 / log(x))`	→	`-log(1/log(x)) - log(log(x))`
simplify	`simplify(Residual)`	→	`-log(1/log(x)) - log(log(x))`
answer			`null`

sp-acj4-446-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ Ne(x, I) ∧ Ne(x, (-I)) ∧ (~Q.zero(cos(Abs(atan(x))))) ⊢ Eq(tan(Abs(atan(x))), Abs(x)) null difference → tan(Abs(atan(x))) - Abs(x) · simplify → tan(Abs(atan(x))) - Abs(x) 0.036 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): Ne(x, I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(x, -I, evaluate=False)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(Abs(atan(x))))
Residual = tan(Abs(atan(x))) - Abs(x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`tan(Abs(atan(x))) - Abs(x)`	→	`tan(Abs(atan(x))) - Abs(x)`
simplify	`simplify(Residual)`	→	`tan(Abs(atan(x))) - Abs(x)`
answer			`null`

sp-acj4-450-complex true simplipy-complex-branch solved Q.complex(x) ∧ (~Q.zero(x)) ⊢ Eq((x/x), 1) true difference → 0 · simplify → 0 0.006 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
Residual = x / x - 1
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`x / x - 1`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-451-complex true simplipy-complex-branch solved Q.complex(x) ∧ (~Q.zero(x)) ⊢ Eq((0/x), 0) true difference → 0 · simplify → 0 0.006 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
Residual = 0 / x - 0
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`0 / x - 0`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-50-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(Pow(6, x))) ⊢ Eq((log(6)*x), log(Pow(6, x))) null difference → x*log(6) - log(6**x) · simplify → x*log(6) - log(6**x) 0.027 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): ~Q.zero(Pow(6, x))
Residual = log(6) * x - log(Pow(6, x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`log(6) * x - log(Pow(6, x))`	→	`xlog(6) - log(6*x)`
simplify	`simplify(Residual)`	→	`xlog(6) - log(6*x)`
answer			`null`

sp-acj4-51-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(Pow(7, x))) ⊢ Eq((log(7)*x), log(Pow(7, x))) null difference → x*log(7) - log(7**x) · simplify → x*log(7) - log(7**x) 0.027 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): ~Q.zero(Pow(7, x))
Residual = log(7) * x - log(Pow(7, x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`log(7) * x - log(Pow(7, x))`	→	`xlog(7) - log(7*x)`
simplify	`simplify(Residual)`	→	`xlog(7) - log(7*x)`
answer			`null`

sp-acj4-55-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(x)) ∧ Or((~Q.zero(x)), (re(exp(1)) > 0)) ∧ (~Q.zero(Pow(x, exp(1)))) ⊢ Eq((log(x)*exp(1)), log(Pow(x, exp(1)))) null difference → E*log(x) - log(x**E) · simplify → E*log(x) - log(x**E) 0.027 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): Or(~Q.zero(x), re(exp(1)) > 0)
# dropped (not a unary fact about one symbol): ~Q.zero(Pow(x, exp(1)))
Residual = log(x) * exp(1) - log(Pow(x, exp(1)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`log(x) * exp(1) - log(Pow(x, exp(1)))`	→	`Elog(x) - log(x*E)`
simplify	`simplify(Residual)`	→	`Elog(x) - log(x*E)`
answer			`null`

sp-acj4-56-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(x)) ∧ Or((~Q.zero(x)), (re(pi) > 0)) ∧ (~Q.zero(Pow(x, pi))) ⊢ Eq((log(x)*pi), log(Pow(x, pi))) null difference → pi*log(x) - log(x**pi) · simplify → pi*log(x) - log(x**pi) 0.026 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): Or(~Q.zero(x), re(pi) > 0)
# dropped (not a unary fact about one symbol): ~Q.zero(Pow(x, pi))
Residual = log(x) * pi - log(Pow(x, pi))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`log(x) * pi - log(Pow(x, pi))`	→	`pilog(x) - log(x*pi)`
simplify	`simplify(Residual)`	→	`pilog(x) - log(x*pi)`
answer			`null`

sp-acj4-6-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(cosh(x))) ∧ Ne(tanh(x), 1) ∧ Ne(tanh(x), (-1)) ⊢ Eq(atanh(tanh(x)), x) null difference → -x + atanh(tanh(x)) · simplify → -x + atanh(tanh(x)) 0.076 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(x))
# dropped (not a unary fact about one symbol): Ne(tanh(x), 1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(tanh(x), -1, evaluate=False)
Residual = atanh(tanh(x)) - x
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atanh(tanh(x)) - x`	→	`-x + atanh(tanh(x))`
simplify	`simplify(Residual)`	→	`-x + atanh(tanh(x))`
answer			`null`

sp-acj4-7-complex true simplipy-complex-branch solved Q.complex(x) ∧ (~Q.zero(Abs(x))) ∧ (~Q.zero(x)) ⊢ Eq((1/Abs(x)), Abs((1/x))) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(Abs(x))
Residual = 1 / Abs(x) - Abs(1 / x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`1 / Abs(x) - Abs(1 / x)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-9-complex contingent simplipy-complex-branch no verdict Q.complex(x) ∧ (~Q.zero(exp(x))) ⊢ Eq(log(exp(x)), x) null difference → -x + log(exp(x)) · simplify → -x + log(exp(x)) 0.038 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): ~Q.zero(exp(x))
Residual = log(exp(x)) - x
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`log(exp(x)) - x`	→	`-x + log(exp(x))`
simplify	`simplify(Residual)`	→	`-x + log(exp(x))`
answer			`null`

sp-acj4-90-complex true simplipy-complex-branch solved Q.complex(x) ∧ (~Q.zero(Abs(x))) ∧ (~Q.zero(x)) ⊢ Eq((3/Abs(x)), Abs(((-3)/x))) true difference → 0 · simplify → 0 0.008 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(Abs(x))
Residual = 3 / Abs(x) - Abs(-3 / x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`3 / Abs(x) - Abs(-3 / x)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-94-complex true simplipy-complex-branch solved Q.complex(x) ∧ (~Q.zero(Abs(x))) ∧ (~Q.zero(x)) ⊢ Eq((7/Abs(x)), Abs(((-7)/x))) true difference → 0 · simplify → 0 0.008 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(Abs(x))
Residual = 7 / Abs(x) - Abs(-7 / x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`7 / Abs(x) - Abs(-7 / x)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-99-complex true simplipy-complex-branch solved Q.complex(x) ⊢ Eq((Abs(x)/3), Abs((x/(-3)))) true difference → 0 · simplify → 0 0.009 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
Residual = Abs(x) / 3 - Abs(x / -3)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(x) / 3 - Abs(x / -3)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-1-cond true simplipy-conditional no verdict Q.real(x) ∧ (Abs(x) <= 1) ⊢ Eq(asin(Abs(x)), Abs(asin(x))) null difference → -Abs(asin(x)) + asin(Abs(x)) · simplify → -Abs(asin(x)) + asin(Abs(x)) 0.021 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Abs(x) <= 1
Residual = asin(Abs(x)) - Abs(asin(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`asin(Abs(x)) - Abs(asin(x))`	→	`-Abs(asin(x)) + asin(Abs(x))`
simplify	`simplify(Residual)`	→	`-Abs(asin(x)) + asin(Abs(x))`
answer			`null`

sp-acj4-108-condf false simplipy-conditional no verdict Q.complex(x) ∧ Q.imaginary(x) ∧ (~Q.zero(x)) ∧ (~Q.zero(Abs(x))) ⊢ Eq((Abs(x)/x), (x/Abs(x))) null difference → -x/Abs(x) + Abs(x)/x · simplify → -x/Abs(x) + Abs(x)/x 0.03 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, imaginary=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(Abs(x))
Residual = Abs(x) / x - (x / Abs(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(x) / x - (x / Abs(x))`	→	`-x/Abs(x) + Abs(x)/x`
simplify	`simplify(Residual)`	→	`-x/Abs(x) + Abs(x)/x`
answer			`null`

sp-acj4-124-condf contingent simplipy-conditional no verdict Q.complex(x) ∧ Q.imaginary(x) ∧ (~Q.zero(cosh(x))) ⊢ Eq(Abs(asin(tanh(x))), acos((1/cosh(x)))) null difference → Abs(asin(tanh(x))) - acos(1/cosh(x)) · simplify → Abs(asin(tanh(x))) - acos(1/cosh(x)) 0.103 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, imaginary=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(x))
Residual = Abs(asin(tanh(x))) - acos(1 / cosh(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(asin(tanh(x))) - acos(1 / cosh(x))`	→	`Abs(asin(tanh(x))) - acos(1/cosh(x))`
simplify	`simplify(Residual)`	→	`Abs(asin(tanh(x))) - acos(1/cosh(x))`
answer			`null`

sp-acj4-127-condf false simplipy-conditional no verdict Q.complex(x) ∧ (re(x) >= 0) ∧ Ne(exp(x), 1) ∧ Ne(exp(x), (-1)) ⊢ Eq(Abs(atanh(exp(x))), atanh(exp(x))) null difference → Abs(atanh(exp(x))) - atanh(exp(x)) · simplify → Abs(atanh(exp(x))) - atanh(exp(x)) 0.048 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): re(x) >= 0
# dropped (not a unary fact about one symbol): Ne(exp(x), 1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(exp(x), -1, evaluate=False)
Residual = Abs(atanh(exp(x))) - atanh(exp(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(atanh(exp(x))) - atanh(exp(x))`	→	`Abs(atanh(exp(x))) - atanh(exp(x))`
simplify	`simplify(Residual)`	→	`Abs(atanh(exp(x))) - atanh(exp(x))`
answer			`null`

sp-acj4-128-cond2 true simplipy-conditional no verdict Q.real(x) ∧ (Abs(x) <= 1) ⊢ Eq(Abs(cos(asin(x))), cos(asin(x))) null difference → -sqrt(1 - x**2) + Abs(sqrt(1 - x**2)) · simplify → -sqrt(1 - x**2) + Abs(sqrt(1 - x**2)) 0.037 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Abs(x) <= 1
Residual = Abs(cos(asin(x))) - cos(asin(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(cos(asin(x))) - cos(asin(x))`	→	`-sqrt(1 - x2) + Abs(sqrt(1 - x2))`
simplify	`simplify(Residual)`	→	`-sqrt(1 - x2) + Abs(sqrt(1 - x2))`
answer			`null`

sp-acj4-128-condf false simplipy-conditional no verdict Q.real(x) ∧ (x > 1) ⊢ Eq(Abs(cos(asin(x))), cos(asin(x))) null difference → -sqrt(1 - x**2) + Abs(sqrt(1 - x**2)) · simplify → -sqrt(1 - x**2) + Abs(sqrt(1 - x**2)) 0.037 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): x > 1
Residual = Abs(cos(asin(x))) - cos(asin(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(cos(asin(x))) - cos(asin(x))`	→	`-sqrt(1 - x2) + Abs(sqrt(1 - x2))`
simplify	`simplify(Residual)`	→	`-sqrt(1 - x2) + Abs(sqrt(1 - x2))`
answer			`null`

sp-acj4-129-cond contingent simplipy-conditional no verdict Q.complex(x) ∧ Q.imaginary(x) ∧ Ne(x, I) ∧ Ne(x, (-I)) ⊢ Eq(Abs(cos(atan(x))), cos(atan(x))) null difference → 1/Abs(sqrt(x**2 + 1)) - 1/sqrt(x**2 + 1) · simplify → 1/Abs(sqrt(x**2 + 1)) - 1/sqrt(x**2 + 1) 0.045 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, imaginary=True)
# dropped (not a unary fact about one symbol): Ne(x, I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(x, -I, evaluate=False)
Residual = Abs(cos(atan(x))) - cos(atan(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(cos(atan(x))) - cos(atan(x))`	→	`1/Abs(sqrt(x2 + 1)) - 1/sqrt(x2 + 1)`
simplify	`simplify(Residual)`	→	`1/Abs(sqrt(x2 + 1)) - 1/sqrt(x2 + 1)`
answer			`null`

sp-acj4-130-cond true simplipy-conditional no verdict Q.real(x) ∧ (Abs(x) < (pi/2)) ∧ (~Q.zero(cos(x))) ∧ (~Q.zero((1/cos(x)))) ⊢ Eq(Abs(log(cos(x))), log((1/cos(x)))) null difference → -log(1/cos(x)) + Abs(log(cos(x))) · simplify → -log(1/cos(x)) + Abs(log(cos(x))) 0.062 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Abs(x) < pi / 2
# dropped (not a unary fact about one symbol): ~Q.zero(cos(x))
# dropped (not a unary fact about one symbol): ~Q.zero(1 / cos(x))
Residual = Abs(log(cos(x))) - log(1 / cos(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(log(cos(x))) - log(1 / cos(x))`	→	`-log(1/cos(x)) + Abs(log(cos(x)))`
simplify	`simplify(Residual)`	→	`-log(1/cos(x)) + Abs(log(cos(x)))`
answer			`null`

sp-acj4-131-condf contingent simplipy-conditional no verdict Q.complex(x) ∧ Q.imaginary(x) ∧ (~Q.zero(cosh(x))) ⊢ Eq(Abs(log(cosh(x))), log(cosh(x))) null difference → -log(cosh(x)) + Abs(log(cosh(x))) · simplify → -log(cosh(x)) + Abs(log(cosh(x))) 0.07 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, imaginary=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(x))
Residual = Abs(log(cosh(x))) - log(cosh(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(log(cosh(x))) - log(cosh(x))`	→	`-log(cosh(x)) + Abs(log(cosh(x)))`
simplify	`simplify(Residual)`	→	`-log(cosh(x)) + Abs(log(cosh(x)))`
answer			`null`

sp-acj4-132-cond true simplipy-conditional no verdict Q.real(x) ∧ (x >= 0) ∧ (x <= pi) ∧ (~Q.zero(sin(x))) ⊢ Eq(Abs(log(sin(x))), (-log(sin(x)))) null difference → log(sin(x)) + Abs(log(sin(x))) · simplify → log(sin(x)) + Abs(log(sin(x))) 0.046 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): x >= 0
# dropped (not a unary fact about one symbol): x <= pi
# dropped (not a unary fact about one symbol): ~Q.zero(sin(x))
Residual = Abs(log(sin(x))) - (-log(sin(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(log(sin(x))) - (-log(sin(x)))`	→	`log(sin(x)) + Abs(log(sin(x)))`
simplify	`simplify(Residual)`	→	`log(sin(x)) + Abs(log(sin(x)))`
answer			`null`

sp-acj4-133-condf false simplipy-conditional no verdict Q.complex(x) ∧ Q.imaginary(x) ∧ (~Q.zero(cosh(x))) ∧ (~Q.zero(tanh(x))) ⊢ Eq(Abs(log(tanh(x))), (-log(tanh(x)))) null difference → log(tanh(x)) + Abs(log(tanh(x))) · simplify → log(tanh(x)) + Abs(log(tanh(x))) 0.078 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, imaginary=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(x))
# dropped (not a unary fact about one symbol): ~Q.zero(tanh(x))
Residual = Abs(log(tanh(x))) - (-log(tanh(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(log(tanh(x))) - (-log(tanh(x)))`	→	`log(tanh(x)) + Abs(log(tanh(x)))`
simplify	`simplify(Residual)`	→	`log(tanh(x)) + Abs(log(tanh(x)))`
answer			`null`

sp-acj4-136-cond true simplipy-conditional solved Q.real(x) ∧ Q.nonnegative(x) ∧ Or((~Q.zero(x)), (re(exp(1)) > 0)) ⊢ Eq(Abs(Pow(x, exp(1))), Pow(x, exp(1))) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, nonnegative=True)
# dropped (not a unary fact about one symbol): Or(~Q.zero(x), re(exp(1)) > 0)
Residual = Abs(Pow(x, exp(1))) - Pow(x, exp(1))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(Pow(x, exp(1))) - Pow(x, exp(1))`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-137-cond true simplipy-conditional solved Q.real(x) ∧ Q.nonnegative(x) ∧ Or((~Q.zero(x)), (re(pi) > 0)) ⊢ Eq(Abs(Pow(x, pi)), Pow(x, pi)) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, nonnegative=True)
# dropped (not a unary fact about one symbol): Or(~Q.zero(x), re(pi) > 0)
Residual = Abs(Pow(x, pi)) - Pow(x, pi)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(Pow(x, pi)) - Pow(x, pi)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-145-cond2 true simplipy-conditional no verdict Q.real(x) ∧ (Abs(x) <= 1) ⊢ Eq(Abs(sin(acos(x))), cos(asin(x))) null difference → -sqrt(1 - x**2) + Abs(sqrt(1 - x**2)) · simplify → -sqrt(1 - x**2) + Abs(sqrt(1 - x**2)) 0.04 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Abs(x) <= 1
Residual = Abs(sin(acos(x))) - cos(asin(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(sin(acos(x))) - cos(asin(x))`	→	`-sqrt(1 - x2) + Abs(sqrt(1 - x2))`
simplify	`simplify(Residual)`	→	`-sqrt(1 - x2) + Abs(sqrt(1 - x2))`
answer			`null`

sp-acj4-145-condf false simplipy-conditional no verdict Q.real(x) ∧ (x > 1) ⊢ Eq(Abs(sin(acos(x))), cos(asin(x))) null difference → -sqrt(1 - x**2) + Abs(sqrt(1 - x**2)) · simplify → -sqrt(1 - x**2) + Abs(sqrt(1 - x**2)) 0.037 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): x > 1
Residual = Abs(sin(acos(x))) - cos(asin(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(sin(acos(x))) - cos(asin(x))`	→	`-sqrt(1 - x2) + Abs(sqrt(1 - x2))`
simplify	`simplify(Residual)`	→	`-sqrt(1 - x2) + Abs(sqrt(1 - x2))`
answer			`null`

sp-acj4-147-cond contingent simplipy-conditional no verdict Q.complex(x) ∧ Q.imaginary(x) ∧ (~Q.zero(cosh(asinh(x)))) ∧ (~Q.zero(x)) ∧ Ne((1/x), I) ∧ Ne((1/x), (-I)) ⊢ Eq(Abs(tanh(asinh(x))), cos(atan((1/x)))) null difference → Abs(x)/Abs(sqrt(x**2 + 1)) - 1/sqrt(1 + x**(-2)) · simplify → -sqrt(-x**2)/sqrt(-x**2 - 1) + Abs(x/sqrt(x**2 + 1)) 0.095 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, imaginary=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(asinh(x)))
# dropped (not a unary fact about one symbol): Ne(1 / x, I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(1 / x, -I, evaluate=False)
Residual = Abs(tanh(asinh(x))) - cos(atan(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(tanh(asinh(x))) - cos(atan(1 / x))`	→	`Abs(x)/Abs(sqrt(x2 + 1)) - 1/sqrt(1 + x(-2))`
simplify	`simplify(Residual)`	→	`-sqrt(-x2)/sqrt(-x2 - 1) + Abs(x/sqrt(x**2 + 1))`
answer			`null`

sp-acj4-151-cond true simplipy-conditional no verdict Q.real(x) ∧ (Abs(x) <= 1) ⊢ Eq(acos(cos(asin(x))), Abs(asin(x))) null difference → -Abs(asin(x)) + acos(sqrt(1 - x**2)) · simplify → -Abs(asin(x)) + acos(sqrt(1 - x**2)) 0.034 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Abs(x) <= 1
Residual = acos(cos(asin(x))) - Abs(asin(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`acos(cos(asin(x))) - Abs(asin(x))`	→	`-Abs(asin(x)) + acos(sqrt(1 - x**2))`
simplify	`simplify(Residual)`	→	`-Abs(asin(x)) + acos(sqrt(1 - x**2))`
answer			`null`

sp-acj4-156-cond true simplipy-conditional no verdict Q.real(x) ∧ (Abs(x) <= 1) ⊢ Eq(acos(sin(acos(x))), Abs(asin(x))) null difference → -Abs(asin(x)) + acos(sqrt(1 - x**2)) · simplify → -Abs(asin(x)) + acos(sqrt(1 - x**2)) 0.034 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Abs(x) <= 1
Residual = acos(sin(acos(x))) - Abs(asin(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`acos(sin(acos(x))) - Abs(asin(x))`	→	`-Abs(asin(x)) + acos(sqrt(1 - x**2))`
simplify	`simplify(Residual)`	→	`-Abs(asin(x)) + acos(sqrt(1 - x**2))`
answer			`null`

sp-acj4-159-cond2 true simplipy-conditional no verdict Q.real(x) ∧ (x <= 1) ∧ (~Q.zero(cosh(x))) ⊢ Eq(acos(tanh(Abs(x))), asin((1/cosh(x)))) null difference → acos(tanh(Abs(x))) - asin(1/cosh(x)) · simplify → -asin(1/cosh(x)) - asin(tanh(Abs(x))) + pi/2 0.167 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): x <= 1
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(x))
Residual = acos(tanh(Abs(x))) - asin(1 / cosh(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`acos(tanh(Abs(x))) - asin(1 / cosh(x))`	→	`acos(tanh(Abs(x))) - asin(1/cosh(x))`
simplify	`simplify(Residual)`	→	`-asin(1/cosh(x)) - asin(tanh(Abs(x))) + pi/2`
answer			`null`

sp-acj4-159-cond3 true simplipy-conditional no verdict Q.real(x) ∧ (Abs(x) <= (pi/2)) ∧ (~Q.zero(cosh(x))) ⊢ Eq(acos(tanh(Abs(x))), asin((1/cosh(x)))) null difference → acos(tanh(Abs(x))) - asin(1/cosh(x)) · simplify → -asin(1/cosh(x)) - asin(tanh(Abs(x))) + pi/2 0.168 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Abs(x) <= pi / 2
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(x))
Residual = acos(tanh(Abs(x))) - asin(1 / cosh(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`acos(tanh(Abs(x))) - asin(1 / cosh(x))`	→	`acos(tanh(Abs(x))) - asin(1/cosh(x))`
simplify	`simplify(Residual)`	→	`-asin(1/cosh(x)) - asin(tanh(Abs(x))) + pi/2`
answer			`null`

sp-acj4-162-cond true simplipy-conditional no verdict Q.complex(x) ∧ (re(x) >= 0) ∧ Q.real(x) ⊢ Eq(acosh(real_root(x, 5)), acosh(Pow(x, Rational(1, 5)))) null difference → -acosh(x**(1/5)) + acosh(Abs(x)**(1/5)*sign(x)) · simplify → Piecewise((0, Eq(x, 0)), (-acosh(x**(1/5)) + acosh(x/Abs(x**(4/5))), True)) 0.076 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, real=True)
# dropped (not a unary fact about one symbol): re(x) >= 0
Residual = acosh(real_root(x, 5)) - acosh(Pow(x, Rational(1, 5)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`acosh(real_root(x, 5)) - acosh(Pow(x, Rational(1, 5)))`	→	`-acosh(x(1/5)) + acosh(Abs(x)(1/5)*sign(x))`
simplify	`simplify(Residual)`	→	`Piecewise((0, Eq(x, 0)), (-acosh(x(1/5)) + acosh(x/Abs(x(4/5))), True))`
answer			`null`

sp-acj4-162-condf false simplipy-conditional no verdict Q.real(x) ∧ Q.negative(x) ⊢ Eq(acosh(real_root(x, 5)), acosh(Pow(x, Rational(1, 5)))) null difference → -acosh(x**(1/5)) + acosh(-(-x)**(1/5)) · simplify → -acosh(x**(1/5)) + acosh(-(-x)**(1/5)) 0.032 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, negative=True)
Residual = acosh(real_root(x, 5)) - acosh(Pow(x, Rational(1, 5)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`acosh(real_root(x, 5)) - acosh(Pow(x, Rational(1, 5)))`	→	`-acosh(x(1/5)) + acosh(-(-x)(1/5))`
simplify	`simplify(Residual)`	→	`-acosh(x(1/5)) + acosh(-(-x)(1/5))`
answer			`null`

sp-acj4-171-cond contingent simplipy-conditional no verdict Q.complex(x) ∧ (Abs(im(x)) < pi) ∧ (~Q.zero(cosh(x))) ⊢ Eq(asin(sin(tanh(x))), tanh(x)) null difference → -tanh(x) + asin(sin(tanh(x))) · simplify → -tanh(x) + asin(sin(tanh(x))) 0.117 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): Abs(im(x)) < pi
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(x))
Residual = asin(sin(tanh(x))) - tanh(x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`asin(sin(tanh(x))) - tanh(x)`	→	`-tanh(x) + asin(sin(tanh(x)))`
simplify	`simplify(Residual)`	→	`-tanh(x) + asin(sin(tanh(x)))`
answer			`null`

sp-acj4-171-cond2 true simplipy-conditional no verdict Q.complex(x) ∧ Q.imaginary(x) ∧ (~Q.zero(cosh(x))) ⊢ Eq(asin(sin(tanh(x))), tanh(x)) null difference → -tanh(x) + asin(sin(tanh(x))) · simplify → -tanh(x) + asin(sin(tanh(x))) 0.12 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, imaginary=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(x))
Residual = asin(sin(tanh(x))) - tanh(x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`asin(sin(tanh(x))) - tanh(x)`	→	`-tanh(x) + asin(sin(tanh(x)))`
simplify	`simplify(Residual)`	→	`-tanh(x) + asin(sin(tanh(x)))`
answer			`null`

sp-acj4-179-cond true simplipy-conditional no verdict Q.real(x) ∧ (Abs(x) <= (pi/2)) ∧ Ne(sinh(acos(x)), I) ∧ Ne(sinh(acos(x)), (-I)) ∧ (~Q.zero(cosh(acos(x)))) ⊢ Eq(atan(sinh(acos(x))), asin(tanh(acos(x)))) null difference → -asin(tanh(acos(x))) + atan(sinh(acos(x))) · simplify → -asin(tanh(acos(x))) + atan(sinh(acos(x))) 0.081 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Abs(x) <= pi / 2
# dropped (not a unary fact about one symbol): Ne(sinh(acos(x)), I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(sinh(acos(x)), -I, evaluate=False)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(acos(x)))
Residual = atan(sinh(acos(x))) - asin(tanh(acos(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atan(sinh(acos(x))) - asin(tanh(acos(x)))`	→	`-asin(tanh(acos(x))) + atan(sinh(acos(x)))`
simplify	`simplify(Residual)`	→	`-asin(tanh(acos(x))) + atan(sinh(acos(x)))`
answer			`null`

sp-acj4-180-cond true simplipy-conditional no verdict Q.complex(x) ∧ (re(x) >= 0) ∧ Ne(sinh(acosh(x)), I) ∧ Ne(sinh(acosh(x)), (-I)) ∧ (~Q.zero(cosh(acosh(x)))) ⊢ Eq(atan(sinh(acosh(x))), asin(tanh(acosh(x)))) null difference → -asin(sqrt(x - 1)*sqrt(x + 1)/x) + atan(sqrt(x - 1)*sqrt(x + 1)) · simplify → -asin(sqrt(x - 1)*sqrt(x + 1)/x) + atan(sqrt(x - 1)*sqrt(x + 1)) 0.054 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): re(x) >= 0
# dropped (not a unary fact about one symbol): Ne(sinh(acosh(x)), I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(sinh(acosh(x)), -I, evaluate=False)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(acosh(x)))
Residual = atan(sinh(acosh(x))) - asin(tanh(acosh(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atan(sinh(acosh(x))) - asin(tanh(acosh(x)))`	→	`-asin(sqrt(x - 1)sqrt(x + 1)/x) + atan(sqrt(x - 1)sqrt(x + 1))`
simplify	`simplify(Residual)`	→	`-asin(sqrt(x - 1)sqrt(x + 1)/x) + atan(sqrt(x - 1)sqrt(x + 1))`
answer			`null`

sp-acj4-181-cond true simplipy-conditional no verdict Q.real(x) ∧ (Abs(x) <= (pi/2)) ∧ Ne(sinh(asin(x)), I) ∧ Ne(sinh(asin(x)), (-I)) ∧ (~Q.zero(cosh(asin(x)))) ⊢ Eq(atan(sinh(asin(x))), asin(tanh(asin(x)))) null difference → -asin(tanh(asin(x))) + atan(sinh(asin(x))) · simplify → -asin(tanh(asin(x))) + atan(sinh(asin(x))) 0.08 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Abs(x) <= pi / 2
# dropped (not a unary fact about one symbol): Ne(sinh(asin(x)), I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(sinh(asin(x)), -I, evaluate=False)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(asin(x)))
Residual = atan(sinh(asin(x))) - asin(tanh(asin(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atan(sinh(asin(x))) - asin(tanh(asin(x)))`	→	`-asin(tanh(asin(x))) + atan(sinh(asin(x)))`
simplify	`simplify(Residual)`	→	`-asin(tanh(asin(x))) + atan(sinh(asin(x)))`
answer			`null`

sp-acj4-183-cond true simplipy-conditional no verdict Q.complex(x) ∧ (re(x) >= 0) ∧ (~Q.zero(x)) ∧ Ne(sinh(log(x)), I) ∧ Ne(sinh(log(x)), (-I)) ∧ (~Q.zero(cosh(log(x)))) ⊢ Eq(atan(sinh(log(x))), asin(tanh(log(x)))) null difference → -asin(tanh(log(x))) + atan(sinh(log(x))) · simplify → -asin(tanh(log(x))) + atan(sinh(log(x))) 0.079 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): re(x) >= 0
# dropped (not a unary fact about one symbol): Ne(sinh(log(x)), I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(sinh(log(x)), -I, evaluate=False)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(log(x)))
Residual = atan(sinh(log(x))) - asin(tanh(log(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atan(sinh(log(x))) - asin(tanh(log(x)))`	→	`-asin(tanh(log(x))) + atan(sinh(log(x)))`
simplify	`simplify(Residual)`	→	`-asin(tanh(log(x))) + atan(sinh(log(x)))`
answer			`null`

sp-acj4-186-cond true simplipy-conditional no verdict Q.complex(x) ∧ Q.imaginary(x) ∧ (~Q.zero(cos(sin(x)))) ∧ Ne(tan(sin(x)), I) ∧ Ne(tan(sin(x)), (-I)) ⊢ Eq(atan(tan(sin(x))), sin(x)) null difference → -sin(x) + atan(tan(sin(x))) · simplify → -sin(x) + atan(tan(sin(x))) 0.068 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, imaginary=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(sin(x)))
# dropped (not a unary fact about one symbol): Ne(tan(sin(x)), I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(tan(sin(x)), -I, evaluate=False)
Residual = atan(tan(sin(x))) - sin(x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atan(tan(sin(x))) - sin(x)`	→	`-sin(x) + atan(tan(sin(x)))`
simplify	`simplify(Residual)`	→	`-sin(x) + atan(tan(sin(x)))`
answer			`null`

sp-acj4-187-cond true simplipy-conditional no verdict Q.complex(x) ∧ Q.imaginary(x) ∧ (~Q.zero(cosh(x))) ∧ (~Q.zero(cos(tanh(x)))) ∧ Ne(tan(tanh(x)), I) ∧ Ne(tan(tanh(x)), (-I)) ⊢ Eq(atan(tan(tanh(x))), tanh(x)) null difference → -tanh(x) + atan(tan(tanh(x))) · simplify → -tanh(x) + atan(tan(tanh(x))) 0.124 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, imaginary=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(x))
# dropped (not a unary fact about one symbol): ~Q.zero(cos(tanh(x)))
# dropped (not a unary fact about one symbol): Ne(tan(tanh(x)), I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(tan(tanh(x)), -I, evaluate=False)
Residual = atan(tan(tanh(x))) - tanh(x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atan(tan(tanh(x))) - tanh(x)`	→	`-tanh(x) + atan(tan(tanh(x)))`
simplify	`simplify(Residual)`	→	`-tanh(x) + atan(tan(tanh(x)))`
answer			`null`

sp-acj4-190-condf false simplipy-conditional no verdict Q.complex(x) ∧ Q.imaginary(x) ∧ Ne(x, I) ∧ Ne(x, (-I)) ∧ Ne(cos(atan(x)), 1) ∧ Ne(cos(atan(x)), (-1)) ∧ (~Q.zero(x)) ⊢ Eq(atanh(cos(atan(x))), Abs(asinh((1/x)))) null difference → -Abs(asinh(1/x)) + atanh(1/sqrt(x**2 + 1)) · simplify → -Abs(asinh(1/x)) + atanh(1/sqrt(x**2 + 1)) 0.038 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, imaginary=True, zero=False)
# dropped (not a unary fact about one symbol): Ne(x, I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(x, -I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(cos(atan(x)), 1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(cos(atan(x)), -1, evaluate=False)
Residual = atanh(cos(atan(x))) - Abs(asinh(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atanh(cos(atan(x))) - Abs(asinh(1 / x))`	→	`-Abs(asinh(1/x)) + atanh(1/sqrt(x**2 + 1))`
simplify	`simplify(Residual)`	→	`-Abs(asinh(1/x)) + atanh(1/sqrt(x**2 + 1))`
answer			`null`

sp-acj4-191-condf false simplipy-conditional no verdict Q.complex(x) ∧ Q.imaginary(x) ∧ Ne(sin(acos(x)), 1) ∧ Ne(sin(acos(x)), (-1)) ∧ (~Q.zero(x)) ⊢ Eq(atanh(sin(acos(x))), acosh(Abs((1/x)))) null difference → -acosh(1/Abs(x)) + atanh(sqrt(1 - x**2)) · simplify → -acosh(1/Abs(x)) + atanh(sqrt(1 - x**2)) 0.054 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, imaginary=True, zero=False)
# dropped (not a unary fact about one symbol): Ne(sin(acos(x)), 1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(sin(acos(x)), -1, evaluate=False)
Residual = atanh(sin(acos(x))) - acosh(Abs(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atanh(sin(acos(x))) - acosh(Abs(1 / x))`	→	`-acosh(1/Abs(x)) + atanh(sqrt(1 - x**2))`
simplify	`simplify(Residual)`	→	`-acosh(1/Abs(x)) + atanh(sqrt(1 - x**2))`
answer			`null`

sp-acj4-196-cond2 true simplipy-conditional no verdict Q.complex(x) ∧ Q.imaginary(x) ∧ (~Q.zero(cosh(x))) ∧ Ne(sin(tanh(x)), 1) ∧ Ne(sin(tanh(x)), (-1)) ∧ (~Q.zero(cos(tanh(x)))) ⊢ Eq(atanh(sin(tanh(x))), asinh(tan(tanh(x)))) null difference → -asinh(tan(tanh(x))) + atanh(sin(tanh(x))) · simplify → -asinh(tan(tanh(x))) + atanh(sin(tanh(x))) 0.078 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, imaginary=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(x))
# dropped (not a unary fact about one symbol): Ne(sin(tanh(x)), 1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(sin(tanh(x)), -1, evaluate=False)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(tanh(x)))
Residual = atanh(sin(tanh(x))) - asinh(tan(tanh(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atanh(sin(tanh(x))) - asinh(tan(tanh(x)))`	→	`-asinh(tan(tanh(x))) + atanh(sin(tanh(x)))`
simplify	`simplify(Residual)`	→	`-asinh(tan(tanh(x))) + atanh(sin(tanh(x)))`
answer			`null`

sp-acj4-20-condf false simplipy-conditional no verdict Q.complex(x) ∧ Q.imaginary(x) ⊢ Eq(sinh(Abs(x)), Abs(sinh(x))) null difference → sinh(Abs(x)) - Abs(sinh(x)) · simplify → sinh(Abs(x)) - Abs(sinh(x)) 0.083 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, imaginary=True)
Residual = sinh(Abs(x)) - Abs(sinh(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`sinh(Abs(x)) - Abs(sinh(x))`	→	`sinh(Abs(x)) - Abs(sinh(x))`
simplify	`simplify(Residual)`	→	`sinh(Abs(x)) - Abs(sinh(x))`
answer			`null`

sp-acj4-200-cond true simplipy-conditional solved Q.complex(x) ∧ Q.imaginary(x) ⊢ Eq(cos(asin(sin(x))), Abs(cos(x))) true difference → sqrt(1 - sin(x)**2) - Abs(cos(x)) · simplify → 0 0.075 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, imaginary=True)
Residual = cos(asin(sin(x))) - Abs(cos(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`cos(asin(sin(x))) - Abs(cos(x))`	→	`sqrt(1 - sin(x)**2) - Abs(cos(x))`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-202-cond true simplipy-conditional solved Q.complex(x) ∧ Q.imaginary(x) ∧ (~Q.zero(cos(x))) ∧ Ne(tan(x), I) ∧ Ne(tan(x), (-I)) ⊢ Eq(cos(atan(tan(x))), Abs(cos(x))) true difference → -Abs(cos(x)) + 1/sqrt(tan(x)**2 + 1) · simplify → 0 0.12 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, imaginary=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(x))
# dropped (not a unary fact about one symbol): Ne(tan(x), I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(tan(x), -I, evaluate=False)
Residual = cos(atan(tan(x))) - Abs(cos(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`cos(atan(tan(x))) - Abs(cos(x))`	→	`-Abs(cos(x)) + 1/sqrt(tan(x)**2 + 1)`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-203-cond true simplipy-conditional no verdict Q.complex(x) ∧ (re(x) >= 0) ∧ (~Q.zero(x)) ∧ (~Q.zero((1/x))) ⊢ Eq(cos(log((1/x))), cos(log(x))) null difference → cos(log(1/x)) - cos(log(x)) · simplify → cos(log(1/x)) - cos(log(x)) 0.05 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): re(x) >= 0
# dropped (not a unary fact about one symbol): ~Q.zero(1 / x)
Residual = cos(log(1 / x)) - cos(log(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`cos(log(1 / x)) - cos(log(x))`	→	`cos(log(1/x)) - cos(log(x))`
simplify	`simplify(Residual)`	→	`cos(log(1/x)) - cos(log(x))`
answer			`null`

sp-acj4-205-cond true simplipy-conditional solved Q.complex(x) ∧ Q.imaginary(x) ∧ (~Q.zero(cos(x))) ⊢ Eq(cosh(asinh(tan(x))), Abs((1/cos(x)))) true difference → sqrt(tan(x)**2 + 1) - 1/Abs(cos(x)) · simplify → 0 0.12 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, imaginary=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(x))
Residual = cosh(asinh(tan(x))) - Abs(1 / cos(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`cosh(asinh(tan(x))) - Abs(1 / cos(x))`	→	`sqrt(tan(x)**2 + 1) - 1/Abs(cos(x))`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-234-cond true simplipy-conditional no verdict Q.complex(x) ∧ (re(x) >= 0) ∧ Or((~Q.zero(x)), (re(x) > 0)) ∧ (~Q.zero(Pow(x, x))) ∧ (~Q.zero(x)) ∧ Or((~Q.zero((1/x))), (re(x) > 0)) ⊢ Eq((1/Pow(x, x)), Pow((1/x), x)) null difference → -(1/x)**x + x**(-x) · simplify → -(1/x)**x + x**(-x) 0.028 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): re(x) >= 0
# dropped (not a unary fact about one symbol): Or(~Q.zero(x), re(x) > 0)
# dropped (not a unary fact about one symbol): ~Q.zero(Pow(x, x))
# dropped (not a unary fact about one symbol): Or(~Q.zero(1 / x), re(x) > 0)
Residual = 1 / Pow(x, x) - Pow(1 / x, x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`1 / Pow(x, x) - Pow(1 / x, x)`	→	`-(1/x)x + x(-x)`
simplify	`simplify(Residual)`	→	`-(1/x)x + x(-x)`
answer			`null`

sp-acj4-234-cond2 true simplipy-conditional solved Q.integer(x) ∧ Or((~Q.zero(x)), (re(x) > 0)) ∧ (~Q.zero(Pow(x, x))) ∧ (~Q.zero(x)) ∧ Or((~Q.zero((1/x))), (re(x) > 0)) ⊢ Eq((1/Pow(x, x)), Pow((1/x), x)) true difference → 0 · simplify → 0 0.008 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', integer=True, zero=False)
# dropped (not a unary fact about one symbol): Or(~Q.zero(x), re(x) > 0)
# dropped (not a unary fact about one symbol): ~Q.zero(Pow(x, x))
# dropped (not a unary fact about one symbol): Or(~Q.zero(1 / x), re(x) > 0)
Residual = 1 / Pow(x, x) - Pow(1 / x, x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`1 / Pow(x, x) - Pow(1 / x, x)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-243-cond true simplipy-conditional no verdict Q.complex(x) ∧ (re(x) > 0) ∧ Q.real(x) ∧ (~Q.zero(real_root(x, 5))) ∧ (~Q.zero(x)) ⊢ Eq(log(real_root(x, 5)), (log(x)/5)) null difference → -log(x)/5 + log(Abs(x)**(1/5)*sign(x)) · simplify → 4*log(x/Abs(x))/5 0.042 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, real=True, zero=False)
# dropped (not a unary fact about one symbol): re(x) > 0
# dropped (not a unary fact about one symbol): ~Q.zero(real_root(x, 5))
Residual = log(real_root(x, 5)) - (log(x) / 5)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`log(real_root(x, 5)) - (log(x) / 5)`	→	`-log(x)/5 + log(Abs(x)*(1/5)sign(x))`
simplify	`simplify(Residual)`	→	`4*log(x/Abs(x))/5`
answer			`null`

sp-acj4-245-cond true simplipy-conditional no verdict Q.complex(x) ∧ (re(x) > 0) ∧ Q.real(x) ∧ (~Q.zero(real_root(x, 7))) ∧ (~Q.zero(x)) ⊢ Eq(log(real_root(x, 7)), (log(x)/7)) null difference → -log(x)/7 + log(Abs(x)**(1/7)*sign(x)) · simplify → 6*log(x/Abs(x))/7 0.042 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, real=True, zero=False)
# dropped (not a unary fact about one symbol): re(x) > 0
# dropped (not a unary fact about one symbol): ~Q.zero(real_root(x, 7))
Residual = log(real_root(x, 7)) - (log(x) / 7)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`log(real_root(x, 7)) - (log(x) / 7)`	→	`-log(x)/7 + log(Abs(x)*(1/7)sign(x))`
simplify	`simplify(Residual)`	→	`6*log(x/Abs(x))/7`
answer			`null`

sp-acj4-248-cond true simplipy-conditional no verdict Q.real(x) ∧ (Abs(x) <= 1) ⊢ Eq((-Abs(asin(x))), asin((-Abs(x)))) null difference → -Abs(asin(x)) + asin(Abs(x)) · simplify → -Abs(asin(x)) + asin(Abs(x)) 0.021 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Abs(x) <= 1
Residual = -Abs(asin(x)) - asin(-Abs(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-Abs(asin(x)) - asin(-Abs(x))`	→	`-Abs(asin(x)) + asin(Abs(x))`
simplify	`simplify(Residual)`	→	`-Abs(asin(x)) + asin(Abs(x))`
answer			`null`

sp-acj4-251-cond true simplipy-conditional no verdict Q.real(x) ∧ (Abs(x) < 1) ∧ Ne(x, 1) ∧ Ne(x, (-1)) ∧ Ne((-Abs(x)), 1) ∧ Ne((-Abs(x)), (-1)) ⊢ Eq((-Abs(atanh(x))), atanh((-Abs(x)))) null difference → -Abs(atanh(x)) + atanh(Abs(x)) · simplify → -Abs(atanh(x)) + atanh(Abs(x)) 0.023 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Abs(x) < 1
# dropped (not a unary fact about one symbol): Ne(x, 1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(x, -1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(-Abs(x), 1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(-Abs(x), -1, evaluate=False)
Residual = -Abs(atanh(x)) - atanh(-Abs(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-Abs(atanh(x)) - atanh(-Abs(x))`	→	`-Abs(atanh(x)) + atanh(Abs(x))`
simplify	`simplify(Residual)`	→	`-Abs(atanh(x)) + atanh(Abs(x))`
answer			`null`

sp-acj4-260-cond true simplipy-conditional no verdict Q.complex(x) ∧ (Abs(re(x)) < (pi/2)) ∧ (~Q.zero(cos(x))) ∧ (~Q.zero((1/cos(x)))) ⊢ Eq((-log(cos(x))), log((1/cos(x)))) null difference → -log(1/cos(x)) - log(cos(x)) · simplify → -log(1/cos(x)) - log(cos(x)) 0.06 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): Abs(re(x)) < pi / 2
# dropped (not a unary fact about one symbol): ~Q.zero(cos(x))
# dropped (not a unary fact about one symbol): ~Q.zero(1 / cos(x))
Residual = -log(cos(x)) - log(1 / cos(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-log(cos(x)) - log(1 / cos(x))`	→	`-log(1/cos(x)) - log(cos(x))`
simplify	`simplify(Residual)`	→	`-log(1/cos(x)) - log(cos(x))`
answer			`null`

sp-acj4-261-cond contingent simplipy-conditional no verdict Q.complex(x) ∧ (re(x) > 0) ∧ (~Q.zero(cosh(x))) ∧ (~Q.zero((1/cosh(x)))) ⊢ Eq((-log(cosh(x))), log((1/cosh(x)))) null difference → -log(1/cosh(x)) - log(cosh(x)) · simplify → -log(1/cosh(x)) - log(cosh(x)) 0.085 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): re(x) > 0
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(x))
# dropped (not a unary fact about one symbol): ~Q.zero(1 / cosh(x))
Residual = -log(cosh(x)) - log(1 / cosh(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-log(cosh(x)) - log(1 / cosh(x))`	→	`-log(1/cosh(x)) - log(cosh(x))`
simplify	`simplify(Residual)`	→	`-log(1/cosh(x)) - log(cosh(x))`
answer			`null`

sp-acj4-266-cond true simplipy-conditional no verdict Q.complex(x) ∧ (re(x) >= 0) ∧ (~Q.zero(x)) ∧ (~Q.zero((1/x))) ⊢ Eq((-sin(log(x))), sin(log((1/x)))) null difference → -sin(log(1/x)) - sin(log(x)) · simplify → -sin(log(1/x)) - sin(log(x)) 0.051 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): re(x) >= 0
# dropped (not a unary fact about one symbol): ~Q.zero(1 / x)
Residual = -sin(log(x)) - sin(log(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-sin(log(x)) - sin(log(1 / x))`	→	`-sin(log(1/x)) - sin(log(x))`
simplify	`simplify(Residual)`	→	`-sin(log(1/x)) - sin(log(x))`
answer			`null`

sp-acj4-266-condf contingent simplipy-conditional no verdict Q.real(x) ∧ Q.negative(x) ∧ (~Q.zero(x)) ∧ (~Q.zero((1/x))) ⊢ Eq((-sin(log(x))), sin(log((1/x)))) null difference → -sin(log(1/x)) - sin(log(x)) · simplify → -sin(log(1/x)) - sin(log(x)) 0.052 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, negative=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(1 / x)
Residual = -sin(log(x)) - sin(log(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-sin(log(x)) - sin(log(1 / x))`	→	`-sin(log(1/x)) - sin(log(x))`
simplify	`simplify(Residual)`	→	`-sin(log(1/x)) - sin(log(x))`
answer			`null`

sp-acj4-267-cond true simplipy-conditional no verdict Q.complex(x) ∧ (re(x) >= 0) ∧ (~Q.zero(x)) ∧ (~Q.zero(cos(log(x)))) ∧ (~Q.zero((1/x))) ∧ (~Q.zero(cos(log((1/x))))) ⊢ Eq((-tan(log(x))), tan(log((1/x)))) null difference → -tan(log(1/x)) - tan(log(x)) · simplify → -tan(log(1/x)) - tan(log(x)) 0.055 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): re(x) >= 0
# dropped (not a unary fact about one symbol): ~Q.zero(cos(log(x)))
# dropped (not a unary fact about one symbol): ~Q.zero(1 / x)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(log(1 / x)))
Residual = -tan(log(x)) - tan(log(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-tan(log(x)) - tan(log(1 / x))`	→	`-tan(log(1/x)) - tan(log(x))`
simplify	`simplify(Residual)`	→	`-tan(log(1/x)) - tan(log(x))`
answer			`null`

sp-acj4-267-condf false simplipy-conditional no verdict Q.real(x) ∧ Q.negative(x) ∧ (~Q.zero(x)) ∧ (~Q.zero(cos(log(x)))) ∧ (~Q.zero((1/x))) ∧ (~Q.zero(cos(log((1/x))))) ⊢ Eq((-tan(log(x))), tan(log((1/x)))) null difference → -tan(log(1/x)) - tan(log(x)) · simplify → -tan(log(1/x)) - tan(log(x)) 0.055 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, negative=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(log(x)))
# dropped (not a unary fact about one symbol): ~Q.zero(1 / x)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(log(1 / x)))
Residual = -tan(log(x)) - tan(log(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-tan(log(x)) - tan(log(1 / x))`	→	`-tan(log(1/x)) - tan(log(x))`
simplify	`simplify(Residual)`	→	`-tan(log(1/x)) - tan(log(x))`
answer			`null`

sp-acj4-283-condf false simplipy-conditional no verdict Q.complex(x) ∧ Q.imaginary(x) ⊢ Eq(Pow(Abs(x), 2), (x*x)) null difference → -x**2 + Abs(x)**2 · simplify → -x**2 + Abs(x)**2 0.022 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, imaginary=True)
Residual = Pow(Abs(x), 2) - (x * x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(Abs(x), 2) - (x * x)`	→	`-x2 + Abs(x)2`
simplify	`simplify(Residual)`	→	`-x2 + Abs(x)2`
answer			`null`

sp-acj4-287-condf false simplipy-conditional no verdict Q.complex(x) ∧ Q.imaginary(x) ⊢ Eq(Pow(Abs(x), 6), Pow(x, 6)) null difference → -x**6 + Abs(x)**6 · simplify → -x**6 + Abs(x)**6 0.022 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, imaginary=True)
Residual = Pow(Abs(x), 6) - Pow(x, 6)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(Abs(x), 6) - Pow(x, 6)`	→	`-x6 + Abs(x)6`
simplify	`simplify(Residual)`	→	`-x6 + Abs(x)6`
answer			`null`

sp-acj4-289-cond true simplipy-conditional no verdict Q.complex(x) ∧ Q.imaginary(x) ⊢ Eq(Pow(Abs(x), 8), Pow(x, 8)) null difference → -x**8 + Abs(x)**8 · simplify → -x**8 + Abs(x)**8 0.022 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, imaginary=True)
Residual = Pow(Abs(x), 8) - Pow(x, 8)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(Abs(x), 8) - Pow(x, 8)`	→	`-x8 + Abs(x)8`
simplify	`simplify(Residual)`	→	`-x8 + Abs(x)8`
answer			`null`

sp-acj4-29-cond true simplipy-conditional solved Q.real(x) ∧ Q.positive(x) ∧ (~Q.zero(x)) ∧ (~Q.zero(Pow(x, 3))) ⊢ Eq((3*log(x)), log(Pow(x, 3))) true difference → 3*log(x) - log(x**3) · simplify → 0 0.029 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, positive=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(Pow(x, 3))
Residual = 3 * log(x) - log(Pow(x, 3))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`3 * log(x) - log(Pow(x, 3))`	→	`3log(x) - log(x*3)`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-29-condf false simplipy-conditional no verdict Q.complex(x) ∧ Q.imaginary(x) ∧ (~Q.zero(x)) ∧ (~Q.zero(Pow(x, 3))) ⊢ Eq((3*log(x)), log(Pow(x, 3))) null difference → 3*log(x) - log(x**3) · simplify → 3*log(x) - log(x**3) 0.022 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, imaginary=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(Pow(x, 3))
Residual = 3 * log(x) - log(Pow(x, 3))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`3 * log(x) - log(Pow(x, 3))`	→	`3log(x) - log(x*3)`
simplify	`simplify(Residual)`	→	`3log(x) - log(x*3)`
answer			`null`

sp-acj4-334-cond true simplipy-conditional no verdict Q.complex(x) ∧ And((im(x) > (-pi)), (im(x) <= pi)) ∧ Or((~Q.zero(exp(x))), (re(exp(1)) > 0)) ⊢ Eq(Pow(exp(x), exp(1)), exp((exp(1)*x))) null difference → exp(x)**E - exp(E*x) · simplify → exp(x)**E - exp(E*x) 0.035 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): And(im(x) > -pi, im(x) <= pi)
# dropped (not a unary fact about one symbol): Or(~Q.zero(exp(x)), re(exp(1)) > 0)
Residual = Pow(exp(x), exp(1)) - exp(exp(1) * x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(exp(x), exp(1)) - exp(exp(1) * x)`	→	`exp(x)*E - exp(Ex)`
simplify	`simplify(Residual)`	→	`exp(x)*E - exp(Ex)`
answer			`null`

sp-acj4-335-cond true simplipy-conditional no verdict Q.complex(x) ∧ And((im(x) > (-pi)), (im(x) <= pi)) ∧ Or((~Q.zero(exp(x))), (re(pi) > 0)) ⊢ Eq(Pow(exp(x), pi), exp((pi*x))) null difference → exp(x)**pi - exp(pi*x) · simplify → exp(x)**pi - exp(pi*x) 0.032 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): And(im(x) > -pi, im(x) <= pi)
# dropped (not a unary fact about one symbol): Or(~Q.zero(exp(x)), re(pi) > 0)
Residual = Pow(exp(x), pi) - exp(pi * x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(exp(x), pi) - exp(pi * x)`	→	`exp(x)*pi - exp(pix)`
simplify	`simplify(Residual)`	→	`exp(x)*pi - exp(pix)`
answer			`null`

sp-acj4-336-cond true simplipy-conditional no verdict Q.complex(x) ∧ And((im(x) > (-pi)), (im(x) <= pi)) ∧ Or((~Q.zero(exp(x))), (re(x) > 0)) ⊢ Eq(Pow(exp(x), x), exp((x*x))) null difference → exp(x)**x - exp(x**2) · simplify → exp(x)**x - exp(x**2) 0.031 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): And(im(x) > -pi, im(x) <= pi)
# dropped (not a unary fact about one symbol): Or(~Q.zero(exp(x)), re(x) > 0)
Residual = Pow(exp(x), x) - exp(x * x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(exp(x), x) - exp(x * x)`	→	`exp(x)x - exp(x2)`
simplify	`simplify(Residual)`	→	`exp(x)x - exp(x2)`
answer			`null`

sp-acj4-344-cond true simplipy-conditional no verdict Q.complex(x) ∧ (re(x) >= 0) ∧ (~Q.zero(x)) ∧ Or((~Q.zero((1/x))), (re(x) > 0)) ∧ Or((~Q.zero(x)), (re((-x)) > 0)) ⊢ Eq(Pow((1/x), x), Pow(x, (-x))) null difference → (1/x)**x - 1/x**x · simplify → (1/x)**x - 1/x**x 0.028 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): re(x) >= 0
# dropped (not a unary fact about one symbol): Or(~Q.zero(1 / x), re(x) > 0)
# dropped (not a unary fact about one symbol): Or(~Q.zero(x), re(-x) > 0)
Residual = Pow(1 / x, x) - Pow(x, -x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(1 / x, x) - Pow(x, -x)`	→	`(1/x)x - 1/xx`
simplify	`simplify(Residual)`	→	`(1/x)x - 1/xx`
answer			`null`

sp-acj4-344-cond2 true simplipy-conditional solved Q.integer(x) ∧ (~Q.zero(x)) ∧ Or((~Q.zero((1/x))), (re(x) > 0)) ∧ Or((~Q.zero(x)), (re((-x)) > 0)) ⊢ Eq(Pow((1/x), x), Pow(x, (-x))) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', integer=True, zero=False)
# dropped (not a unary fact about one symbol): Or(~Q.zero(1 / x), re(x) > 0)
# dropped (not a unary fact about one symbol): Or(~Q.zero(x), re(-x) > 0)
Residual = Pow(1 / x, x) - Pow(x, -x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(1 / x, x) - Pow(x, -x)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-372-cond contingent simplipy-conditional no verdict Q.complex(x) ∧ (re(x) > 0) ∧ Q.real(cosh(x)) ∧ (~Q.zero(cosh(x))) ⊢ Eq(real_root(cosh(x), (-5)), Pow(cosh(x), Rational(-1, 5))) null difference → Piecewise((sign(cosh(x))/Abs(cosh(x))**(1/5), Eq(sin(im(x))*sinh(re(x)), 0)), (cosh(x)**(… · simplify → Piecewise((-1/cosh(x)**(1/5), Eq(cosh(x), 0) & Eq(sin(im(x))*sinh(re(x)), 0)), (cosh(x)/A… 0.371 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): re(x) > 0
# dropped (not a unary fact about one symbol): Q.real(cosh(x))
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(x))
Residual = real_root(cosh(x), -5) - Pow(cosh(x), Rational(-1, 5))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`real_root(cosh(x), -5) - Pow(cosh(x), Rational(-1, 5))`	→	`Piecewise((sign(cosh(x))/Abs(cosh(x))*(1/5), Eq(sin(im(x))sinh(re(x)), 0)), (cosh(x)(-1/5), True)) - 1/cosh(x)(1/5)`
simplify	`simplify(Residual)`	→	`Piecewise((-1/cosh(x)*(1/5), Eq(cosh(x), 0) & Eq(sin(im(x))sinh(re(x)), 0)), (cosh(x)/Abs(cosh(x)(6/5)) - 1/cosh(x)(1/5), Eq(sin(im(x))*sinh(re(x)), 0)), (0, True))`
answer			`null`

sp-acj4-373-cond contingent simplipy-conditional no verdict Q.complex(x) ∧ (re(x) > 0) ∧ Q.real(cosh(x)) ⊢ Eq(real_root(cosh(x), 5), Pow(cosh(x), Rational(1, 5))) null difference → Piecewise((Abs(cosh(x))**(1/5)*sign(cosh(x)), Eq(sin(im(x))*sinh(re(x)), 0)), (cosh(x)**(… · simplify → Piecewise((-cosh(x)**(1/5), Eq(cosh(x), 0) & Eq(sin(im(x))*sinh(re(x)), 0)), (-cosh(x)**(… 0.347 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): re(x) > 0
# dropped (not a unary fact about one symbol): Q.real(cosh(x))
Residual = real_root(cosh(x), 5) - Pow(cosh(x), Rational(1, 5))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`real_root(cosh(x), 5) - Pow(cosh(x), Rational(1, 5))`	→	`Piecewise((Abs(cosh(x))*(1/5)sign(cosh(x)), Eq(sin(im(x))sinh(re(x)), 0)), (cosh(x)(1/5), True)) - cosh(x)*(1/5)`
simplify	`simplify(Residual)`	→	`Piecewise((-cosh(x)*(1/5), Eq(cosh(x), 0) & Eq(sin(im(x))sinh(re(x)), 0)), (-cosh(x)(1/5) + cosh(x)/Abs(cosh(x)(4/5)), Eq(sin(im(x))*sinh(re(x)), 0)), (0, True))`
answer			`null`

sp-acj4-376-cond2 true simplipy-conditional no verdict Q.complex(x) ∧ (Abs(im(x)) < pi) ∧ Q.real(exp(x)) ∧ (~Q.zero(exp(x))) ⊢ Eq(real_root(exp(x), (-3)), exp((x/(-3)))) null difference → Piecewise((exp(-re(x)/3)*sign(exp(x)), Eq(exp(re(x))*sin(im(x)), 0)), (exp(x)**(-1/3), Tr… · simplify → Piecewise((exp(x - 4*re(x)/3) - exp(-x/3), Eq(exp(re(x))*sin(im(x)), 0)), (exp(x)**(-1/3)… 0.191 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): Abs(im(x)) < pi
# dropped (not a unary fact about one symbol): Q.real(exp(x))
# dropped (not a unary fact about one symbol): ~Q.zero(exp(x))
Residual = real_root(exp(x), -3) - exp(x / -3)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`real_root(exp(x), -3) - exp(x / -3)`	→	`Piecewise((exp(-re(x)/3)sign(exp(x)), Eq(exp(re(x))sin(im(x)), 0)), (exp(x)**(-1/3), True)) - exp(-x/3)`
simplify	`simplify(Residual)`	→	`Piecewise((exp(x - 4re(x)/3) - exp(-x/3), Eq(exp(re(x))sin(im(x)), 0)), (exp(x)**(-1/3) - exp(-x/3), True))`
answer			`null`

sp-acj4-385-cond contingent simplipy-conditional no verdict Q.complex(x) ∧ (re(x) > 0) ∧ Q.real(exp(x)) ⊢ Eq(real_root(exp(x), 3), exp((x/3))) null difference → Piecewise((exp(re(x)/3)*sign(exp(x)), Eq(exp(re(x))*sin(im(x)), 0)), (exp(x)**(1/3), True… · simplify → Piecewise((-exp(x/3) + exp(x - 2*re(x)/3), Eq(exp(re(x))*sin(im(x)), 0)), (-exp(x/3) + ex… 0.151 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): re(x) > 0
# dropped (not a unary fact about one symbol): Q.real(exp(x))
Residual = real_root(exp(x), 3) - exp(x / 3)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`real_root(exp(x), 3) - exp(x / 3)`	→	`Piecewise((exp(re(x)/3)sign(exp(x)), Eq(exp(re(x))sin(im(x)), 0)), (exp(x)**(1/3), True)) - exp(x/3)`
simplify	`simplify(Residual)`	→	`Piecewise((-exp(x/3) + exp(x - 2re(x)/3), Eq(exp(re(x))sin(im(x)), 0)), (-exp(x/3) + exp(x)**(1/3), True))`
answer			`null`

sp-acj4-392-cond true simplipy-conditional no verdict Q.real(x) ∧ (Abs(x) <= 1) ⊢ Eq(sin(Abs(asin(x))), Abs(cos(acos(x)))) null difference → sin(Abs(asin(x))) - Abs(x) · simplify → sin(Abs(asin(x))) - Abs(x) 0.034 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Abs(x) <= 1
Residual = sin(Abs(asin(x))) - Abs(cos(acos(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`sin(Abs(asin(x))) - Abs(cos(acos(x)))`	→	`sin(Abs(asin(x))) - Abs(x)`
simplify	`simplify(Residual)`	→	`sin(Abs(asin(x))) - Abs(x)`
answer			`null`

sp-acj4-394-cond contingent simplipy-conditional no verdict Q.real(x) ∧ (Abs(x) < 1) ∧ Ne(x, 1) ∧ Ne(x, (-1)) ⊢ Eq(sin(Abs(atanh(x))), Abs(sin(atanh(x)))) null difference → sin(Abs(atanh(x))) - Abs(sin(atanh(x))) · simplify → sin(Abs(atanh(x))) - Abs(sin(atanh(x))) 0.055 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Abs(x) < 1
# dropped (not a unary fact about one symbol): Ne(x, 1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(x, -1, evaluate=False)
Residual = sin(Abs(atanh(x))) - Abs(sin(atanh(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`sin(Abs(atanh(x))) - Abs(sin(atanh(x)))`	→	`sin(Abs(atanh(x))) - Abs(sin(atanh(x)))`
simplify	`simplify(Residual)`	→	`sin(Abs(atanh(x))) - Abs(sin(atanh(x)))`
answer			`null`

sp-acj4-399-cond true simplipy-conditional solved Q.complex(x) ∧ Q.imaginary(x) ⊢ Eq(sin(acos(sin(x))), Abs(cos(x))) true difference → sqrt(1 - sin(x)**2) - Abs(cos(x)) · simplify → 0 0.075 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, imaginary=True)
Residual = sin(acos(sin(x))) - Abs(cos(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`sin(acos(sin(x))) - Abs(cos(x))`	→	`sqrt(1 - sin(x)**2) - Abs(cos(x))`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-402-cond contingent simplipy-conditional no verdict Q.real(x) ∧ (Abs(x) < 1) ∧ Ne(Abs(x), 1) ∧ Ne(x, 1) ∧ Ne(x, (-1)) ⊢ Eq(sin(atanh(Abs(x))), Abs(sin(atanh(x)))) null difference → sin(atanh(Abs(x))) - Abs(sin(atanh(x))) · simplify → sin(atanh(Abs(x))) - Abs(sin(atanh(x))) 0.058 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Abs(x) < 1
# dropped (not a unary fact about one symbol): Ne(Abs(x), 1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(x, 1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(x, -1, evaluate=False)
Residual = sin(atanh(Abs(x))) - Abs(sin(atanh(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`sin(atanh(Abs(x))) - Abs(sin(atanh(x)))`	→	`sin(atanh(Abs(x))) - Abs(sin(atanh(x)))`
simplify	`simplify(Residual)`	→	`sin(atanh(Abs(x))) - Abs(sin(atanh(x)))`
answer			`null`

sp-acj4-403-cond true simplipy-conditional no verdict Q.complex(x) ∧ (re(x) >= 0) ∧ (~Q.zero(x)) ∧ (~Q.zero((1/x))) ⊢ Eq(sin((-log(x))), sin(log((1/x)))) null difference → -sin(log(1/x)) - sin(log(x)) · simplify → -sin(log(1/x)) - sin(log(x)) 0.052 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): re(x) >= 0
# dropped (not a unary fact about one symbol): ~Q.zero(1 / x)
Residual = sin(-log(x)) - sin(log(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`sin(-log(x)) - sin(log(1 / x))`	→	`-sin(log(1/x)) - sin(log(x))`
simplify	`simplify(Residual)`	→	`-sin(log(1/x)) - sin(log(x))`
answer			`null`

sp-acj4-403-condf contingent simplipy-conditional no verdict Q.real(x) ∧ Q.negative(x) ∧ (~Q.zero(x)) ∧ (~Q.zero((1/x))) ⊢ Eq(sin((-log(x))), sin(log((1/x)))) null difference → -sin(log(1/x)) - sin(log(x)) · simplify → -sin(log(1/x)) - sin(log(x)) 0.076 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, negative=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(1 / x)
Residual = sin(-log(x)) - sin(log(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`sin(-log(x)) - sin(log(1 / x))`	→	`-sin(log(1/x)) - sin(log(x))`
simplify	`simplify(Residual)`	→	`-sin(log(1/x)) - sin(log(x))`
answer			`null`

sp-acj4-412-cond true simplipy-conditional no verdict Q.real(x) ∧ (Abs(x) < 1) ∧ (~Q.zero(cos(Abs(asin(x))))) ∧ (~Q.zero(cos(asin(x)))) ⊢ Eq(tan(Abs(asin(x))), Abs(tan(asin(x)))) null difference → tan(Abs(asin(x))) - Abs(x)/Abs(sqrt(1 - x**2)) · simplify → tan(Abs(asin(x))) - Abs(x/sqrt(1 - x**2)) 0.083 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Abs(x) < 1
# dropped (not a unary fact about one symbol): ~Q.zero(cos(Abs(asin(x))))
# dropped (not a unary fact about one symbol): ~Q.zero(cos(asin(x)))
Residual = tan(Abs(asin(x))) - Abs(tan(asin(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`tan(Abs(asin(x))) - Abs(tan(asin(x)))`	→	`tan(Abs(asin(x))) - Abs(x)/Abs(sqrt(1 - x**2))`
simplify	`simplify(Residual)`	→	`tan(Abs(asin(x))) - Abs(x/sqrt(1 - x**2))`
answer			`null`

sp-acj4-416-cond true simplipy-conditional no verdict Q.real(x) ∧ (Abs(x) <= 1) ∧ (~Q.zero(cos(acos(Abs(x))))) ∧ (~Q.zero(cos(acos(x)))) ⊢ Eq(tan(acos(Abs(x))), Abs(tan(acos(x)))) null difference → sqrt(1 - x**2)/Abs(x) - Abs(sqrt(1 - x**2)/x) · simplify → sqrt(1 - x**2)/Abs(x) - Abs(sqrt(1 - x**2)/x) 0.052 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Abs(x) <= 1
# dropped (not a unary fact about one symbol): ~Q.zero(cos(acos(Abs(x))))
# dropped (not a unary fact about one symbol): ~Q.zero(cos(acos(x)))
Residual = tan(acos(Abs(x))) - Abs(tan(acos(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`tan(acos(Abs(x))) - Abs(tan(acos(x)))`	→	`sqrt(1 - x2)/Abs(x) - Abs(sqrt(1 - x2)/x)`
simplify	`simplify(Residual)`	→	`sqrt(1 - x2)/Abs(x) - Abs(sqrt(1 - x2)/x)`
answer			`null`

sp-acj4-417-cond true simplipy-conditional no verdict Q.real(x) ∧ (Abs(x) < 1) ∧ (~Q.zero(cos(asin(Abs(x))))) ∧ (~Q.zero(cos(asin(x)))) ⊢ Eq(tan(asin(Abs(x))), Abs(tan(asin(x)))) null difference → -Abs(x)/Abs(sqrt(1 - x**2)) + Abs(x)/sqrt(1 - x**2) · simplify → -Abs(x/sqrt(1 - x**2)) + Abs(x)/sqrt(1 - x**2) 0.059 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Abs(x) < 1
# dropped (not a unary fact about one symbol): ~Q.zero(cos(asin(Abs(x))))
# dropped (not a unary fact about one symbol): ~Q.zero(cos(asin(x)))
Residual = tan(asin(Abs(x))) - Abs(tan(asin(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`tan(asin(Abs(x))) - Abs(tan(asin(x)))`	→	`-Abs(x)/Abs(sqrt(1 - x2)) + Abs(x)/sqrt(1 - x2)`
simplify	`simplify(Residual)`	→	`-Abs(x/sqrt(1 - x2)) + Abs(x)/sqrt(1 - x2)`
answer			`null`

sp-acj4-420-cond true simplipy-conditional no verdict Q.complex(x) ∧ (re(x) >= 0) ∧ (~Q.zero(x)) ∧ (~Q.zero(cos((-log(x))))) ∧ (~Q.zero((1/x))) ∧ (~Q.zero(cos(log((1/x))))) ⊢ Eq(tan((-log(x))), tan(log((1/x)))) null difference → -tan(log(1/x)) - tan(log(x)) · simplify → -tan(log(1/x)) - tan(log(x)) 0.055 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): re(x) >= 0
# dropped (not a unary fact about one symbol): ~Q.zero(cos(-log(x)))
# dropped (not a unary fact about one symbol): ~Q.zero(1 / x)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(log(1 / x)))
Residual = tan(-log(x)) - tan(log(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`tan(-log(x)) - tan(log(1 / x))`	→	`-tan(log(1/x)) - tan(log(x))`
simplify	`simplify(Residual)`	→	`-tan(log(1/x)) - tan(log(x))`
answer			`null`

sp-acj4-420-condf false simplipy-conditional no verdict Q.real(x) ∧ Q.negative(x) ∧ (~Q.zero(x)) ∧ (~Q.zero(cos((-log(x))))) ∧ (~Q.zero((1/x))) ∧ (~Q.zero(cos(log((1/x))))) ⊢ Eq(tan((-log(x))), tan(log((1/x)))) null difference → -tan(log(1/x)) - tan(log(x)) · simplify → -tan(log(1/x)) - tan(log(x)) 0.055 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, negative=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(-log(x)))
# dropped (not a unary fact about one symbol): ~Q.zero(1 / x)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(log(1 / x)))
Residual = tan(-log(x)) - tan(log(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`tan(-log(x)) - tan(log(1 / x))`	→	`-tan(log(1/x)) - tan(log(x))`
simplify	`simplify(Residual)`	→	`-tan(log(1/x)) - tan(log(x))`
answer			`null`

sp-acj4-422-condf false simplipy-conditional no verdict Q.complex(x) ∧ Q.imaginary(x) ∧ (~Q.zero(x)) ∧ Ne((1/x), I) ∧ Ne((1/x), (-I)) ⊢ Eq(tanh(Abs(asinh(x))), cos(atan((1/x)))) null difference → tanh(Abs(asinh(x))) - 1/sqrt(1 + x**(-2)) · simplify → -sqrt(-x**2)/sqrt(-x**2 - 1) + tanh(Abs(asinh(x))) 0.175 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, imaginary=True, zero=False)
# dropped (not a unary fact about one symbol): Ne(1 / x, I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(1 / x, -I, evaluate=False)
Residual = tanh(Abs(asinh(x))) - cos(atan(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`tanh(Abs(asinh(x))) - cos(atan(1 / x))`	→	`tanh(Abs(asinh(x))) - 1/sqrt(1 + x**(-2))`
simplify	`simplify(Residual)`	→	`-sqrt(-x2)/sqrt(-x2 - 1) + tanh(Abs(asinh(x)))`
answer			`null`

sp-acj4-424-condf false simplipy-conditional no verdict Q.complex(x) ∧ Q.imaginary(x) ∧ (~Q.zero(x)) ∧ Ne((1/x), I) ∧ Ne((1/x), (-I)) ⊢ Eq(tanh(asinh(Abs(x))), cos(atan((1/x)))) null difference → Abs(x)/sqrt(Abs(x)**2 + 1) - 1/sqrt(1 + x**(-2)) · simplify → -sqrt(-x**2)/sqrt(-x**2 - 1) + Abs(x)/sqrt(Abs(x)**2 + 1) 0.087 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, imaginary=True, zero=False)
# dropped (not a unary fact about one symbol): Ne(1 / x, I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(1 / x, -I, evaluate=False)
Residual = tanh(asinh(Abs(x))) - cos(atan(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`tanh(asinh(Abs(x))) - cos(atan(1 / x))`	→	`Abs(x)/sqrt(Abs(x)2 + 1) - 1/sqrt(1 + x(-2))`
simplify	`simplify(Residual)`	→	`-sqrt(-x2)/sqrt(-x2 - 1) + Abs(x)/sqrt(Abs(x)**2 + 1)`
answer			`null`

sp-acj4-428-cond true simplipy-conditional no verdict Q.real(x) ∧ (x <= 1) ⊢ Eq(atan(sinh(x)), asin(tanh(x))) null difference → -asin(tanh(x)) + atan(sinh(x)) · simplify → -asin(tanh(x)) + atan(sinh(x)) 0.069 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): x <= 1
Residual = atan(sinh(x)) - asin(tanh(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atan(sinh(x)) - asin(tanh(x))`	→	`-asin(tanh(x)) + atan(sinh(x))`
simplify	`simplify(Residual)`	→	`-asin(tanh(x)) + atan(sinh(x))`
answer			`null`

sp-acj4-428-cond3 true simplipy-conditional no verdict Q.real(x) ∧ (x >= 0) ∧ (x <= pi) ⊢ Eq(atan(sinh(x)), asin(tanh(x))) null difference → -asin(tanh(x)) + atan(sinh(x)) · simplify → -asin(tanh(x)) + atan(sinh(x)) 0.07 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): x >= 0
# dropped (not a unary fact about one symbol): x <= pi
Residual = atan(sinh(x)) - asin(tanh(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atan(sinh(x)) - asin(tanh(x))`	→	`-asin(tanh(x)) + atan(sinh(x))`
simplify	`simplify(Residual)`	→	`-asin(tanh(x)) + atan(sinh(x))`
answer			`null`

sp-acj4-430-cond true simplipy-conditional solved Q.real(x) ∧ Q.positive(x) ∧ (~Q.zero(x)) ∧ Or((~Q.zero(x)), (re(x) > 0)) ∧ (~Q.zero(Pow(x, x))) ⊢ Eq((log(x)*x), log(Pow(x, x))) true difference → x*log(x) - log(x**x) · simplify → 0 0.024 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, positive=True, zero=False)
# dropped (not a unary fact about one symbol): Or(~Q.zero(x), re(x) > 0)
# dropped (not a unary fact about one symbol): ~Q.zero(Pow(x, x))
Residual = log(x) * x - log(Pow(x, x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`log(x) * x - log(Pow(x, x))`	→	`xlog(x) - log(x*x)`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-430-cond2 true simplipy-conditional no verdict Q.real(x) ∧ (Abs(x) < 1) ∧ (~Q.zero(x)) ∧ Or((~Q.zero(x)), (re(x) > 0)) ∧ (~Q.zero(Pow(x, x))) ⊢ Eq((log(x)*x), log(Pow(x, x))) null difference → x*log(x) - log(x**x) · simplify → x*log(x) - log(x**x) 0.026 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): Abs(x) < 1
# dropped (not a unary fact about one symbol): Or(~Q.zero(x), re(x) > 0)
# dropped (not a unary fact about one symbol): ~Q.zero(Pow(x, x))
Residual = log(x) * x - log(Pow(x, x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`log(x) * x - log(Pow(x, x))`	→	`xlog(x) - log(x*x)`
simplify	`simplify(Residual)`	→	`xlog(x) - log(x*x)`
answer			`null`

sp-acj4-432-cond3 true simplipy-conditional no verdict Q.real(x) ∧ (Abs(x) <= (pi/2)) ∧ (~Q.zero(cosh(x))) ⊢ Eq(acos(Abs(tanh(x))), asin((1/cosh(x)))) null difference → acos(Abs(tanh(x))) - asin(1/cosh(x)) · simplify → acos(Abs(tanh(x))) - asin(1/cosh(x)) 0.097 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Abs(x) <= pi / 2
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(x))
Residual = acos(Abs(tanh(x))) - asin(1 / cosh(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`acos(Abs(tanh(x))) - asin(1 / cosh(x))`	→	`acos(Abs(tanh(x))) - asin(1/cosh(x))`
simplify	`simplify(Residual)`	→	`acos(Abs(tanh(x))) - asin(1/cosh(x))`
answer			`null`

sp-acj4-433-cond true simplipy-conditional no verdict Q.complex(x) ∧ (re(x) >= 0) ∧ (~Q.zero(x)) ∧ Ne((-log(x)), I) ∧ Ne((-log(x)), (-I)) ∧ (~Q.zero((1/x))) ∧ Ne(log((1/x)), I) ∧ Ne(log((1/x)), (-I)) ⊢ Eq(atan((-log(x))), atan(log((1/x)))) null difference → -atan(log(1/x)) - atan(log(x)) · simplify → -atan(log(1/x)) - atan(log(x)) 0.027 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, zero=False)
# dropped (not a unary fact about one symbol): re(x) >= 0
# dropped (not a unary fact about one symbol): Ne(-log(x), I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(-log(x), -I, evaluate=False)
# dropped (not a unary fact about one symbol): ~Q.zero(1 / x)
# dropped (not a unary fact about one symbol): Ne(log(1 / x), I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(log(1 / x), -I, evaluate=False)
Residual = atan(-log(x)) - atan(log(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atan(-log(x)) - atan(log(1 / x))`	→	`-atan(log(1/x)) - atan(log(x))`
simplify	`simplify(Residual)`	→	`-atan(log(1/x)) - atan(log(x))`
answer			`null`

sp-acj4-433-condf false simplipy-conditional no verdict Q.real(x) ∧ Q.negative(x) ∧ (~Q.zero(x)) ∧ Ne((-log(x)), I) ∧ Ne((-log(x)), (-I)) ∧ (~Q.zero((1/x))) ∧ Ne(log((1/x)), I) ∧ Ne(log((1/x)), (-I)) ⊢ Eq(atan((-log(x))), atan(log((1/x)))) null difference → -atan(log(1/x)) - atan(log(x)) · simplify → -atan(log(1/x)) - atan(log(x)) 0.029 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, negative=True, zero=False)
# dropped (not a unary fact about one symbol): Ne(-log(x), I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(-log(x), -I, evaluate=False)
# dropped (not a unary fact about one symbol): ~Q.zero(1 / x)
# dropped (not a unary fact about one symbol): Ne(log(1 / x), I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(log(1 / x), -I, evaluate=False)
Residual = atan(-log(x)) - atan(log(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atan(-log(x)) - atan(log(1 / x))`	→	`-atan(log(1/x)) - atan(log(x))`
simplify	`simplify(Residual)`	→	`-atan(log(1/x)) - atan(log(x))`
answer			`null`

sp-acj4-442-cond true simplipy-conditional no verdict Q.complex(x) ∧ Q.imaginary(x) ∧ (~Q.zero(x)) ∧ (~Q.zero(log(x))) ∧ (~Q.zero((1/log(x)))) ⊢ Eq((-log(log(x))), log((1/log(x)))) null difference → -log(1/log(x)) - log(log(x)) · simplify → -log(1/log(x)) - log(log(x)) 0.027 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, imaginary=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(log(x))
# dropped (not a unary fact about one symbol): ~Q.zero(1 / log(x))
Residual = -log(log(x)) - log(1 / log(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-log(log(x)) - log(1 / log(x))`	→	`-log(1/log(x)) - log(log(x))`
simplify	`simplify(Residual)`	→	`-log(1/log(x)) - log(log(x))`
answer			`null`

sp-acj4-442-cond4 true simplipy-conditional no verdict Q.integer(x) ∧ (~Q.zero(x)) ∧ (~Q.zero(log(x))) ∧ (~Q.zero((1/log(x)))) ⊢ Eq((-log(log(x))), log((1/log(x)))) null difference → -log(1/log(x)) - log(log(x)) · simplify → -log(1/log(x)) - log(log(x)) 0.025 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', integer=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(log(x))
# dropped (not a unary fact about one symbol): ~Q.zero(1 / log(x))
Residual = -log(log(x)) - log(1 / log(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-log(log(x)) - log(1 / log(x))`	→	`-log(1/log(x)) - log(log(x))`
simplify	`simplify(Residual)`	→	`-log(1/log(x)) - log(log(x))`
answer			`null`

sp-acj4-46-cond true simplipy-conditional no verdict Q.complex(x) ∧ And((im(x) > (-pi)), (im(x) <= pi)) ∧ (~Q.zero(Pow(2, x))) ⊢ Eq((log(2)*x), log(Pow(2, x))) null difference → x*log(2) - log(2**x) · simplify → x*log(2) - log(2**x) 0.027 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): And(im(x) > -pi, im(x) <= pi)
# dropped (not a unary fact about one symbol): ~Q.zero(Pow(2, x))
Residual = log(2) * x - log(Pow(2, x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`log(2) * x - log(Pow(2, x))`	→	`xlog(2) - log(2*x)`
simplify	`simplify(Residual)`	→	`xlog(2) - log(2*x)`
answer			`null`

sp-acj4-5-cond true simplipy-conditional no verdict Q.real(x) ∧ (Abs(x) < 1) ∧ Ne(Abs(x), 1) ∧ Ne(x, 1) ∧ Ne(x, (-1)) ⊢ Eq(atanh(Abs(x)), Abs(atanh(x))) null difference → -Abs(atanh(x)) + atanh(Abs(x)) · simplify → -Abs(atanh(x)) + atanh(Abs(x)) 0.022 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Abs(x) < 1
# dropped (not a unary fact about one symbol): Ne(Abs(x), 1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(x, 1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(x, -1, evaluate=False)
Residual = atanh(Abs(x)) - Abs(atanh(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atanh(Abs(x)) - Abs(atanh(x))`	→	`-Abs(atanh(x)) + atanh(Abs(x))`
simplify	`simplify(Residual)`	→	`-Abs(atanh(x)) + atanh(Abs(x))`
answer			`null`

sp-acj4-55-cond true simplipy-conditional solved Q.real(x) ∧ Q.positive(x) ∧ (~Q.zero(x)) ∧ Or((~Q.zero(x)), (re(exp(1)) > 0)) ∧ (~Q.zero(Pow(x, exp(1)))) ⊢ Eq((log(x)*exp(1)), log(Pow(x, exp(1)))) true difference → E*log(x) - log(x**E) · simplify → 0 0.025 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, positive=True, zero=False)
# dropped (not a unary fact about one symbol): Or(~Q.zero(x), re(exp(1)) > 0)
# dropped (not a unary fact about one symbol): ~Q.zero(Pow(x, exp(1)))
Residual = log(x) * exp(1) - log(Pow(x, exp(1)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`log(x) * exp(1) - log(Pow(x, exp(1)))`	→	`Elog(x) - log(x*E)`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-56-cond true simplipy-conditional solved Q.real(x) ∧ Q.positive(x) ∧ (~Q.zero(x)) ∧ Or((~Q.zero(x)), (re(pi) > 0)) ∧ (~Q.zero(Pow(x, pi))) ⊢ Eq((log(x)*pi), log(Pow(x, pi))) true difference → pi*log(x) - log(x**pi) · simplify → 0 0.024 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, positive=True, zero=False)
# dropped (not a unary fact about one symbol): Or(~Q.zero(x), re(pi) > 0)
# dropped (not a unary fact about one symbol): ~Q.zero(Pow(x, pi))
Residual = log(x) * pi - log(Pow(x, pi))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`log(x) * pi - log(Pow(x, pi))`	→	`pilog(x) - log(x*pi)`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-56-condf false simplipy-conditional no verdict Q.complex(x) ∧ Q.imaginary(x) ∧ (~Q.zero(x)) ∧ Or((~Q.zero(x)), (re(pi) > 0)) ∧ (~Q.zero(Pow(x, pi))) ⊢ Eq((log(x)*pi), log(Pow(x, pi))) null difference → pi*log(x) - log(x**pi) · simplify → pi*log(x) - log(x**pi) 0.026 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True, imaginary=True, zero=False)
# dropped (not a unary fact about one symbol): Or(~Q.zero(x), re(pi) > 0)
# dropped (not a unary fact about one symbol): ~Q.zero(Pow(x, pi))
Residual = log(x) * pi - log(Pow(x, pi))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`log(x) * pi - log(Pow(x, pi))`	→	`pilog(x) - log(x*pi)`
simplify	`simplify(Residual)`	→	`pilog(x) - log(x*pi)`
answer			`null`

sp-acj4-9-cond true simplipy-conditional no verdict Q.complex(x) ∧ And((im(x) > (-pi)), (im(x) <= pi)) ∧ (~Q.zero(exp(x))) ⊢ Eq(log(exp(x)), x) null difference → -x + log(exp(x)) · simplify → -x + log(exp(x)) 0.038 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', complex=True)
# dropped (not a unary fact about one symbol): And(im(x) > -pi, im(x) <= pi)
# dropped (not a unary fact about one symbol): ~Q.zero(exp(x))
Residual = log(exp(x)) - x
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`log(exp(x)) - x`	→	`-x + log(exp(x))`
simplify	`simplify(Residual)`	→	`-x + log(exp(x))`
answer			`null`

sp-acj4-0-real true simplipy-f64-edge no verdict Q.real(x) ⊢ Eq(acosh(cosh(x)), Abs(x)) null difference → -Abs(x) + acosh(cosh(x)) · simplify → -Abs(x) + acosh(cosh(x)) 0.042 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = acosh(cosh(x)) - Abs(x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`acosh(cosh(x)) - Abs(x)`	→	`-Abs(x) + acosh(cosh(x))`
simplify	`simplify(Residual)`	→	`-Abs(x) + acosh(cosh(x))`
answer			`null`

sp-acj4-115-real true simplipy-f64-edge solved Q.real(x) ∧ (~Q.zero(x)) ∧ (x > 0) ∧ (~Q.zero(real_root(x, (-4)))) ⊢ Eq((log(x)/(-4)), log(real_root(x, (-4)))) true difference → -log(x**(-1/4)) - log(x)/4 · simplify → 0 0.025 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): x > 0
# dropped (not a unary fact about one symbol): ~Q.zero(real_root(x, -4))
Residual = log(x) / -4 - log(real_root(x, -4))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`log(x) / -4 - log(real_root(x, -4))`	→	`-log(x**(-1/4)) - log(x)/4`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-116-real true simplipy-f64-edge solved Q.real(x) ∧ (~Q.zero(x)) ∧ (x > 0) ∧ (~Q.zero(real_root(x, (-6)))) ⊢ Eq((log(x)/(-6)), log(real_root(x, (-6)))) true difference → -log(x**(-1/6)) - log(x)/6 · simplify → 0 0.025 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): x > 0
# dropped (not a unary fact about one symbol): ~Q.zero(real_root(x, -6))
Residual = log(x) / -6 - log(real_root(x, -6))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`log(x) / -6 - log(real_root(x, -6))`	→	`-log(x**(-1/6)) - log(x)/6`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-130-real contingent simplipy-f64-edge no verdict Q.real(x) ∧ (~Q.zero(cos(x))) ∧ (~Q.zero((1/cos(x)))) ⊢ Eq(Abs(log(cos(x))), log((1/cos(x)))) null difference → -log(1/cos(x)) + Abs(log(cos(x))) · simplify → -log(1/cos(x)) + Abs(log(cos(x))) 0.062 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(x))
# dropped (not a unary fact about one symbol): ~Q.zero(1 / cos(x))
Residual = Abs(log(cos(x))) - log(1 / cos(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(log(cos(x))) - log(1 / cos(x))`	→	`-log(1/cos(x)) + Abs(log(cos(x)))`
simplify	`simplify(Residual)`	→	`-log(1/cos(x)) + Abs(log(cos(x)))`
answer			`null`

sp-acj4-151-real contingent simplipy-f64-edge no verdict Q.real(x) ⊢ Eq(acos(cos(asin(x))), Abs(asin(x))) null difference → -Abs(asin(x)) + acos(sqrt(1 - x**2)) · simplify → -Abs(asin(x)) + acos(sqrt(1 - x**2)) 0.033 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = acos(cos(asin(x))) - Abs(asin(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`acos(cos(asin(x))) - Abs(asin(x))`	→	`-Abs(asin(x)) + acos(sqrt(1 - x**2))`
simplify	`simplify(Residual)`	→	`-Abs(asin(x)) + acos(sqrt(1 - x**2))`
answer			`null`

sp-acj4-154-real true simplipy-f64-edge no verdict Q.real(x) ⊢ Eq(acos(cos(sin(x))), Abs(sin(x))) null difference → -Abs(sin(x)) + acos(cos(sin(x))) · simplify → -Abs(sin(x)) + acos(cos(sin(x))) 0.059 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = acos(cos(sin(x))) - Abs(sin(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`acos(cos(sin(x))) - Abs(sin(x))`	→	`-Abs(sin(x)) + acos(cos(sin(x)))`
simplify	`simplify(Residual)`	→	`-Abs(sin(x)) + acos(cos(sin(x)))`
answer			`null`

sp-acj4-156-real contingent simplipy-f64-edge no verdict Q.real(x) ⊢ Eq(acos(sin(acos(x))), Abs(asin(x))) null difference → -Abs(asin(x)) + acos(sqrt(1 - x**2)) · simplify → -Abs(asin(x)) + acos(sqrt(1 - x**2)) 0.033 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = acos(sin(acos(x))) - Abs(asin(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`acos(sin(acos(x))) - Abs(asin(x))`	→	`-Abs(asin(x)) + acos(sqrt(1 - x**2))`
simplify	`simplify(Residual)`	→	`-Abs(asin(x)) + acos(sqrt(1 - x**2))`
answer			`null`

sp-acj4-180-real contingent simplipy-f64-edge no verdict Q.real(x) ∧ Ne(sinh(acosh(x)), I) ∧ Ne(sinh(acosh(x)), (-I)) ∧ (~Q.zero(cosh(acosh(x)))) ⊢ Eq(atan(sinh(acosh(x))), asin(tanh(acosh(x)))) null difference → -asin(sqrt(x - 1)*sqrt(x + 1)/x) + atan(sqrt(x - 1)*sqrt(x + 1)) · simplify → -asin(sqrt(x - 1)*sqrt(x + 1)/x) + atan(sqrt(x - 1)*sqrt(x + 1)) 0.052 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Ne(sinh(acosh(x)), I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(sinh(acosh(x)), -I, evaluate=False)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(acosh(x)))
Residual = atan(sinh(acosh(x))) - asin(tanh(acosh(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atan(sinh(acosh(x))) - asin(tanh(acosh(x)))`	→	`-asin(sqrt(x - 1)sqrt(x + 1)/x) + atan(sqrt(x - 1)sqrt(x + 1))`
simplify	`simplify(Residual)`	→	`-asin(sqrt(x - 1)sqrt(x + 1)/x) + atan(sqrt(x - 1)sqrt(x + 1))`
answer			`null`

sp-acj4-183-real contingent simplipy-f64-edge no verdict Q.real(x) ∧ (~Q.zero(x)) ∧ Ne(sinh(log(x)), I) ∧ Ne(sinh(log(x)), (-I)) ∧ (~Q.zero(cosh(log(x)))) ⊢ Eq(atan(sinh(log(x))), asin(tanh(log(x)))) null difference → -asin(tanh(log(x))) + atan(sinh(log(x))) · simplify → -asin(tanh(log(x))) + atan(sinh(log(x))) 0.079 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): Ne(sinh(log(x)), I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(sinh(log(x)), -I, evaluate=False)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(log(x)))
Residual = atan(sinh(log(x))) - asin(tanh(log(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atan(sinh(log(x))) - asin(tanh(log(x)))`	→	`-asin(tanh(log(x))) + atan(sinh(log(x)))`
simplify	`simplify(Residual)`	→	`-asin(tanh(log(x))) + atan(sinh(log(x)))`
answer			`null`

sp-acj4-189-real true simplipy-f64-edge no verdict Q.real(x) ∧ Ne(cos(asin(x)), 1) ∧ Ne(cos(asin(x)), (-1)) ∧ (~Q.zero(x)) ⊢ Eq(atanh(cos(asin(x))), acosh(Abs((1/x)))) null difference → -acosh(1/Abs(x)) + atanh(sqrt(1 - x**2)) · simplify → -acosh(1/Abs(x)) + atanh(sqrt(1 - x**2)) 0.055 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): Ne(cos(asin(x)), 1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(cos(asin(x)), -1, evaluate=False)
Residual = atanh(cos(asin(x))) - acosh(Abs(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atanh(cos(asin(x))) - acosh(Abs(1 / x))`	→	`-acosh(1/Abs(x)) + atanh(sqrt(1 - x**2))`
simplify	`simplify(Residual)`	→	`-acosh(1/Abs(x)) + atanh(sqrt(1 - x**2))`
answer			`null`

sp-acj4-190-real true simplipy-f64-edge no verdict Q.real(x) ∧ Ne(cos(atan(x)), 1) ∧ Ne(cos(atan(x)), (-1)) ∧ (~Q.zero(x)) ⊢ Eq(atanh(cos(atan(x))), Abs(asinh((1/x)))) null difference → -Abs(asinh(1/x)) + atanh(1/sqrt(x**2 + 1)) · simplify → -Abs(asinh(1/x)) + atanh(1/sqrt(x**2 + 1)) 0.043 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): Ne(cos(atan(x)), 1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(cos(atan(x)), -1, evaluate=False)
Residual = atanh(cos(atan(x))) - Abs(asinh(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atanh(cos(atan(x))) - Abs(asinh(1 / x))`	→	`-Abs(asinh(1/x)) + atanh(1/sqrt(x**2 + 1))`
simplify	`simplify(Residual)`	→	`-Abs(asinh(1/x)) + atanh(1/sqrt(x**2 + 1))`
answer			`null`

sp-acj4-191-real true simplipy-f64-edge no verdict Q.real(x) ∧ Ne(sin(acos(x)), 1) ∧ Ne(sin(acos(x)), (-1)) ∧ (~Q.zero(x)) ⊢ Eq(atanh(sin(acos(x))), acosh(Abs((1/x)))) null difference → -acosh(1/Abs(x)) + atanh(sqrt(1 - x**2)) · simplify → -acosh(1/Abs(x)) + atanh(sqrt(1 - x**2)) 0.057 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): Ne(sin(acos(x)), 1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(sin(acos(x)), -1, evaluate=False)
Residual = atanh(sin(acos(x))) - acosh(Abs(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atanh(sin(acos(x))) - acosh(Abs(1 / x))`	→	`-acosh(1/Abs(x)) + atanh(sqrt(1 - x**2))`
simplify	`simplify(Residual)`	→	`-acosh(1/Abs(x)) + atanh(sqrt(1 - x**2))`
answer			`null`

sp-acj4-203-real contingent simplipy-f64-edge no verdict Q.real(x) ∧ (~Q.zero(x)) ∧ (~Q.zero((1/x))) ⊢ Eq(cos(log((1/x))), cos(log(x))) null difference → cos(log(1/x)) - cos(log(x)) · simplify → cos(log(1/x)) - cos(log(x)) 0.05 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(1 / x)
Residual = cos(log(1 / x)) - cos(log(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`cos(log(1 / x)) - cos(log(x))`	→	`cos(log(1/x)) - cos(log(x))`
simplify	`simplify(Residual)`	→	`cos(log(1/x)) - cos(log(x))`
answer			`null`

sp-acj4-229-real true simplipy-f64-edge solved Q.real(x) ∧ (~Q.zero(Pow(pi, x))) ⊢ Eq((1/Pow(pi, x)), Pow((1/pi), x)) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): ~Q.zero(Pow(pi, x))
Residual = 1 / Pow(pi, x) - Pow(1 / pi, x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`1 / Pow(pi, x) - Pow(1 / pi, x)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-234-real contingent simplipy-f64-edge no verdict Q.real(x) ∧ Or((~Q.zero(x)), (re(x) > 0)) ∧ (~Q.zero(Pow(x, x))) ∧ (~Q.zero(x)) ∧ Or((~Q.zero((1/x))), (re(x) > 0)) ⊢ Eq((1/Pow(x, x)), Pow((1/x), x)) null difference → -(1/x)**x + x**(-x) · simplify → -(1/x)**x + x**(-x) 0.028 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): Or(~Q.zero(x), re(x) > 0)
# dropped (not a unary fact about one symbol): ~Q.zero(Pow(x, x))
# dropped (not a unary fact about one symbol): Or(~Q.zero(1 / x), re(x) > 0)
Residual = 1 / Pow(x, x) - Pow(1 / x, x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`1 / Pow(x, x) - Pow(1 / x, x)`	→	`-(1/x)x + x(-x)`
simplify	`simplify(Residual)`	→	`-(1/x)x + x(-x)`
answer			`null`

sp-acj4-241-real contingent simplipy-f64-edge no verdict Q.real(x) ∧ (~Q.zero(real_root(x, 3))) ∧ (~Q.zero(x)) ⊢ Eq(log(real_root(x, 3)), (log(x)/3)) null difference → -log(x)/3 + log(Abs(x)**(1/3)*sign(x)) · simplify → 2*log(x/Abs(x))/3 0.042 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(real_root(x, 3))
Residual = log(real_root(x, 3)) - (log(x) / 3)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`log(real_root(x, 3)) - (log(x) / 3)`	→	`-log(x)/3 + log(Abs(x)*(1/3)sign(x))`
simplify	`simplify(Residual)`	→	`2*log(x/Abs(x))/3`
answer			`null`

sp-acj4-247-real contingent simplipy-f64-edge no verdict Q.real(x) ∧ (~Q.zero(real_root(x, 9))) ∧ (~Q.zero(x)) ⊢ Eq(log(real_root(x, 9)), (log(x)/9)) null difference → -log(x)/9 + log(Abs(x)**(1/9)*sign(x)) · simplify → 8*log(x/Abs(x))/9 0.054 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(real_root(x, 9))
Residual = log(real_root(x, 9)) - (log(x) / 9)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`log(real_root(x, 9)) - (log(x) / 9)`	→	`-log(x)/9 + log(Abs(x)*(1/9)sign(x))`
simplify	`simplify(Residual)`	→	`8*log(x/Abs(x))/9`
answer			`null`

sp-acj4-260-real contingent simplipy-f64-edge no verdict Q.real(x) ∧ (~Q.zero(cos(x))) ∧ (~Q.zero((1/cos(x)))) ⊢ Eq((-log(cos(x))), log((1/cos(x)))) null difference → -log(1/cos(x)) - log(cos(x)) · simplify → -log(1/cos(x)) - log(cos(x)) 0.083 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(x))
# dropped (not a unary fact about one symbol): ~Q.zero(1 / cos(x))
Residual = -log(cos(x)) - log(1 / cos(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-log(cos(x)) - log(1 / cos(x))`	→	`-log(1/cos(x)) - log(cos(x))`
simplify	`simplify(Residual)`	→	`-log(1/cos(x)) - log(cos(x))`
answer			`null`

sp-acj4-261-real true simplipy-f64-edge solved Q.real(x) ∧ (~Q.zero(cosh(x))) ∧ (~Q.zero((1/cosh(x)))) ⊢ Eq((-log(cosh(x))), log((1/cosh(x)))) true difference → -log(1/cosh(x)) - log(cosh(x)) · simplify → 0 0.049 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(x))
# dropped (not a unary fact about one symbol): ~Q.zero(1 / cosh(x))
Residual = -log(cosh(x)) - log(1 / cosh(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-log(cosh(x)) - log(1 / cosh(x))`	→	`-log(1/cosh(x)) - log(cosh(x))`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-266-real contingent simplipy-f64-edge no verdict Q.real(x) ∧ (~Q.zero(x)) ∧ (~Q.zero((1/x))) ⊢ Eq((-sin(log(x))), sin(log((1/x)))) null difference → -sin(log(1/x)) - sin(log(x)) · simplify → -sin(log(1/x)) - sin(log(x)) 0.051 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(1 / x)
Residual = -sin(log(x)) - sin(log(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-sin(log(x)) - sin(log(1 / x))`	→	`-sin(log(1/x)) - sin(log(x))`
simplify	`simplify(Residual)`	→	`-sin(log(1/x)) - sin(log(x))`
answer			`null`

sp-acj4-267-real contingent simplipy-f64-edge no verdict Q.real(x) ∧ (~Q.zero(x)) ∧ (~Q.zero(cos(log(x)))) ∧ (~Q.zero((1/x))) ∧ (~Q.zero(cos(log((1/x))))) ⊢ Eq((-tan(log(x))), tan(log((1/x)))) null difference → -tan(log(1/x)) - tan(log(x)) · simplify → -tan(log(1/x)) - tan(log(x)) 0.056 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(log(x)))
# dropped (not a unary fact about one symbol): ~Q.zero(1 / x)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(log(1 / x)))
Residual = -tan(log(x)) - tan(log(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-tan(log(x)) - tan(log(1 / x))`	→	`-tan(log(1/x)) - tan(log(x))`
simplify	`simplify(Residual)`	→	`-tan(log(1/x)) - tan(log(x))`
answer			`null`

sp-acj4-29-real contingent simplipy-f64-edge no verdict Q.real(x) ∧ (~Q.zero(x)) ∧ (~Q.zero(Pow(x, 3))) ⊢ Eq((3*log(x)), log(Pow(x, 3))) null difference → 3*log(x) - log(x**3) · simplify → 3*log(x) - log(x**3) 0.025 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(Pow(x, 3))
Residual = 3 * log(x) - log(Pow(x, 3))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`3 * log(x) - log(Pow(x, 3))`	→	`3log(x) - log(x*3)`
simplify	`simplify(Residual)`	→	`3log(x) - log(x*3)`
answer			`null`

sp-acj4-3-real true simplipy-f64-edge no verdict Q.real(x) ⊢ Eq(asinh(sinh(x)), x) null difference → -x + asinh(sinh(x)) · simplify → -x + asinh(sinh(x)) 0.063 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = asinh(sinh(x)) - x
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`asinh(sinh(x)) - x`	→	`-x + asinh(sinh(x))`
simplify	`simplify(Residual)`	→	`-x + asinh(sinh(x))`
answer			`null`

sp-acj4-343-real true simplipy-f64-edge solved Q.real(x) ⊢ Eq(Pow((1/pi), x), Pow(pi, (-x))) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = Pow(1 / pi, x) - Pow(pi, -x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(1 / pi, x) - Pow(pi, -x)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-344-real contingent simplipy-f64-edge no verdict Q.real(x) ∧ (~Q.zero(x)) ∧ Or((~Q.zero((1/x))), (re(x) > 0)) ∧ Or((~Q.zero(x)), (re((-x)) > 0)) ⊢ Eq(Pow((1/x), x), Pow(x, (-x))) null difference → (1/x)**x - 1/x**x · simplify → (1/x)**x - 1/x**x 0.027 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): Or(~Q.zero(1 / x), re(x) > 0)
# dropped (not a unary fact about one symbol): Or(~Q.zero(x), re(-x) > 0)
Residual = Pow(1 / x, x) - Pow(x, -x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(1 / x, x) - Pow(x, -x)`	→	`(1/x)x - 1/xx`
simplify	`simplify(Residual)`	→	`(1/x)x - 1/xx`
answer			`null`

sp-acj4-378-real true simplipy-f64-edge solved Q.real(x) ∧ (~Q.zero(exp(x))) ⊢ Eq(real_root(exp(x), (-5)), exp((x/(-5)))) true difference → 0 · simplify → 0 0.012 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): ~Q.zero(exp(x))
Residual = real_root(exp(x), -5) - exp(x / -5)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`real_root(exp(x), -5) - exp(x / -5)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-380-real true simplipy-f64-edge solved Q.real(x) ∧ (~Q.zero(exp(x))) ⊢ Eq(real_root(exp(x), (-7)), exp((x/(-7)))) true difference → 0 · simplify → 0 0.012 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): ~Q.zero(exp(x))
Residual = real_root(exp(x), -7) - exp(x / -7)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`real_root(exp(x), -7) - exp(x / -7)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-392-real contingent simplipy-f64-edge no verdict Q.real(x) ⊢ Eq(sin(Abs(asin(x))), Abs(cos(acos(x)))) null difference → sin(Abs(asin(x))) - Abs(x) · simplify → sin(Abs(asin(x))) - Abs(x) 0.034 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = sin(Abs(asin(x))) - Abs(cos(acos(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`sin(Abs(asin(x))) - Abs(cos(acos(x)))`	→	`sin(Abs(asin(x))) - Abs(x)`
simplify	`simplify(Residual)`	→	`sin(Abs(asin(x))) - Abs(x)`
answer			`null`

sp-acj4-403-real contingent simplipy-f64-edge no verdict Q.real(x) ∧ (~Q.zero(x)) ∧ (~Q.zero((1/x))) ⊢ Eq(sin((-log(x))), sin(log((1/x)))) null difference → -sin(log(1/x)) - sin(log(x)) · simplify → -sin(log(1/x)) - sin(log(x)) 0.051 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(1 / x)
Residual = sin(-log(x)) - sin(log(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`sin(-log(x)) - sin(log(1 / x))`	→	`-sin(log(1/x)) - sin(log(x))`
simplify	`simplify(Residual)`	→	`-sin(log(1/x)) - sin(log(x))`
answer			`null`

sp-acj4-410-real true simplipy-f64-edge solved Q.real(x) ∧ (~Q.zero(x)) ∧ (~Q.zero(sinh(x))) ⊢ Eq(sinh(exp(log(x))), exp(log(sinh(x)))) true difference → 0 · simplify → 0 0.008 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(sinh(x))
Residual = sinh(exp(log(x))) - exp(log(sinh(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`sinh(exp(log(x))) - exp(log(sinh(x)))`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-416-real contingent simplipy-f64-edge no verdict Q.real(x) ∧ (~Q.zero(cos(acos(Abs(x))))) ∧ (~Q.zero(cos(acos(x)))) ⊢ Eq(tan(acos(Abs(x))), Abs(tan(acos(x)))) null difference → sqrt(1 - x**2)/Abs(x) - Abs(sqrt(1 - x**2)/x) · simplify → sqrt(1 - x**2)/Abs(x) - Abs(sqrt(1 - x**2)/x) 0.051 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(acos(Abs(x))))
# dropped (not a unary fact about one symbol): ~Q.zero(cos(acos(x)))
Residual = tan(acos(Abs(x))) - Abs(tan(acos(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`tan(acos(Abs(x))) - Abs(tan(acos(x)))`	→	`sqrt(1 - x2)/Abs(x) - Abs(sqrt(1 - x2)/x)`
simplify	`simplify(Residual)`	→	`sqrt(1 - x2)/Abs(x) - Abs(sqrt(1 - x2)/x)`
answer			`null`

sp-acj4-420-real contingent simplipy-f64-edge no verdict Q.real(x) ∧ (~Q.zero(x)) ∧ (~Q.zero(cos((-log(x))))) ∧ (~Q.zero((1/x))) ∧ (~Q.zero(cos(log((1/x))))) ⊢ Eq(tan((-log(x))), tan(log((1/x)))) null difference → -tan(log(1/x)) - tan(log(x)) · simplify → -tan(log(1/x)) - tan(log(x)) 0.056 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(-log(x)))
# dropped (not a unary fact about one symbol): ~Q.zero(1 / x)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(log(1 / x)))
Residual = tan(-log(x)) - tan(log(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`tan(-log(x)) - tan(log(1 / x))`	→	`-tan(log(1/x)) - tan(log(x))`
simplify	`simplify(Residual)`	→	`-tan(log(1/x)) - tan(log(x))`
answer			`null`

sp-acj4-430-real contingent simplipy-f64-edge no verdict Q.real(x) ∧ (~Q.zero(x)) ∧ Or((~Q.zero(x)), (re(x) > 0)) ∧ (~Q.zero(Pow(x, x))) ⊢ Eq((log(x)*x), log(Pow(x, x))) null difference → x*log(x) - log(x**x) · simplify → x*log(x) - log(x**x) 0.026 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): Or(~Q.zero(x), re(x) > 0)
# dropped (not a unary fact about one symbol): ~Q.zero(Pow(x, x))
Residual = log(x) * x - log(Pow(x, x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`log(x) * x - log(Pow(x, x))`	→	`xlog(x) - log(x*x)`
simplify	`simplify(Residual)`	→	`xlog(x) - log(x*x)`
answer			`null`

sp-acj4-433-real contingent simplipy-f64-edge no verdict Q.real(x) ∧ (~Q.zero(x)) ∧ Ne((-log(x)), I) ∧ Ne((-log(x)), (-I)) ∧ (~Q.zero((1/x))) ∧ Ne(log((1/x)), I) ∧ Ne(log((1/x)), (-I)) ⊢ Eq(atan((-log(x))), atan(log((1/x)))) null difference → -atan(log(1/x)) - atan(log(x)) · simplify → -atan(log(1/x)) - atan(log(x)) 0.027 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): Ne(-log(x), I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(-log(x), -I, evaluate=False)
# dropped (not a unary fact about one symbol): ~Q.zero(1 / x)
# dropped (not a unary fact about one symbol): Ne(log(1 / x), I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(log(1 / x), -I, evaluate=False)
Residual = atan(-log(x)) - atan(log(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atan(-log(x)) - atan(log(1 / x))`	→	`-atan(log(1/x)) - atan(log(x))`
simplify	`simplify(Residual)`	→	`-atan(log(1/x)) - atan(log(x))`
answer			`null`

sp-acj4-442-real contingent simplipy-f64-edge no verdict Q.real(x) ∧ (~Q.zero(x)) ∧ (~Q.zero(log(x))) ∧ (~Q.zero((1/log(x)))) ⊢ Eq((-log(log(x))), log((1/log(x)))) null difference → -log(1/log(x)) - log(log(x)) · simplify → -log(1/log(x)) - log(log(x)) 0.026 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(log(x))
# dropped (not a unary fact about one symbol): ~Q.zero(1 / log(x))
Residual = -log(log(x)) - log(1 / log(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-log(log(x)) - log(1 / log(x))`	→	`-log(1/log(x)) - log(log(x))`
simplify	`simplify(Residual)`	→	`-log(1/log(x)) - log(log(x))`
answer			`null`

sp-acj4-449-real true simplipy-f64-edge no verdict Q.real(x) ∧ (~Q.zero(x)) ∧ (~Q.zero(cosh((-log(x))))) ∧ (~Q.zero((1/x))) ∧ (~Q.zero(cosh(log((1/x))))) ⊢ Eq(tanh((-log(x))), tanh(log((1/x)))) null difference → -tanh(log(1/x)) - tanh(log(x)) · simplify → -tanh(log(1/x)) - tanh(log(x)) 0.089 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(-log(x)))
# dropped (not a unary fact about one symbol): ~Q.zero(1 / x)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(log(1 / x)))
Residual = tanh(-log(x)) - tanh(log(1 / x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`tanh(-log(x)) - tanh(log(1 / x))`	→	`-tanh(log(1/x)) - tanh(log(x))`
simplify	`simplify(Residual)`	→	`-tanh(log(1/x)) - tanh(log(x))`
answer			`null`

sp-acj4-450-real true simplipy-f64-edge solved Q.real(x) ∧ (~Q.zero(x)) ⊢ Eq((x/x), 1) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
Residual = x / x - 1
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`x / x - 1`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-451-real true simplipy-f64-edge solved Q.real(x) ∧ (~Q.zero(x)) ⊢ Eq((0/x), 0) true difference → 0 · simplify → 0 0.006 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
Residual = 0 / x - 0
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`0 / x - 0`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-50-real true simplipy-f64-edge solved Q.real(x) ∧ (~Q.zero(Pow(6, x))) ⊢ Eq((log(6)*x), log(Pow(6, x))) true difference → x*log(6) - log(6**x) · simplify → 0 0.024 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): ~Q.zero(Pow(6, x))
Residual = log(6) * x - log(Pow(6, x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`log(6) * x - log(Pow(6, x))`	→	`xlog(6) - log(6*x)`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-55-real contingent simplipy-f64-edge no verdict Q.real(x) ∧ (~Q.zero(x)) ∧ Or((~Q.zero(x)), (re(exp(1)) > 0)) ∧ (~Q.zero(Pow(x, exp(1)))) ⊢ Eq((log(x)*exp(1)), log(Pow(x, exp(1)))) null difference → E*log(x) - log(x**E) · simplify → E*log(x) - log(x**E) 0.027 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): Or(~Q.zero(x), re(exp(1)) > 0)
# dropped (not a unary fact about one symbol): ~Q.zero(Pow(x, exp(1)))
Residual = log(x) * exp(1) - log(Pow(x, exp(1)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`log(x) * exp(1) - log(Pow(x, exp(1)))`	→	`Elog(x) - log(x*E)`
simplify	`simplify(Residual)`	→	`Elog(x) - log(x*E)`
answer			`null`

sp-acj4-56-real contingent simplipy-f64-edge no verdict Q.real(x) ∧ (~Q.zero(x)) ∧ Or((~Q.zero(x)), (re(pi) > 0)) ∧ (~Q.zero(Pow(x, pi))) ⊢ Eq((log(x)*pi), log(Pow(x, pi))) null difference → pi*log(x) - log(x**pi) · simplify → pi*log(x) - log(x**pi) 0.026 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): Or(~Q.zero(x), re(pi) > 0)
# dropped (not a unary fact about one symbol): ~Q.zero(Pow(x, pi))
Residual = log(x) * pi - log(Pow(x, pi))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`log(x) * pi - log(Pow(x, pi))`	→	`pilog(x) - log(x*pi)`
simplify	`simplify(Residual)`	→	`pilog(x) - log(x*pi)`
answer			`null`

sp-acj4-6-real true simplipy-f64-edge no verdict Q.real(x) ∧ Ne(tanh(x), 1) ∧ Ne(tanh(x), (-1)) ⊢ Eq(atanh(tanh(x)), x) null difference → -x + atanh(tanh(x)) · simplify → -x + atanh(tanh(x)) 0.072 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Ne(tanh(x), 1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(tanh(x), -1, evaluate=False)
Residual = atanh(tanh(x)) - x
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atanh(tanh(x)) - x`	→	`-x + atanh(tanh(x))`
simplify	`simplify(Residual)`	→	`-x + atanh(tanh(x))`
answer			`null`

sp-acj4-806-ground true simplipy-f64-edge solved Eq(cosh(0), 1) true difference → 0 · simplify → 0 0.005 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Residual = cosh(0) - 1
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`cosh(0) - 1`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-813-ground true simplipy-f64-edge solved Eq(sinh(0), 0) true difference → 0 · simplify → 0 0.005 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Residual = sinh(0) - 0
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`sinh(0) - 0`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-816-ground true simplipy-f64-edge solved Eq(tanh(0), 0) true difference → 0 · simplify → 0 0.005 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Residual = tanh(0) - 0
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`tanh(0) - 0`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-1007-ground true simplipy-ground solved Eq((0/sin(5)), 0) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Residual = 0 / sin(5) - 0
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`0 / sin(5) - 0`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-1107-ground true simplipy-ground solved Eq(asin(sin((1/10))), Rational(1, 10)) true difference → 0 · simplify → 0 0.017 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Residual = asin(sin(Integer(1) / 10)) - Rational(1, 10)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`asin(sin(Integer(1) / 10)) - Rational(1, 10)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-1148-ground true simplipy-ground solved Eq(cosh(log((1/4))), Rational(17, 8)) true difference → -17/8 + cosh(log(4)) · simplify → 0 0.047 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Residual = cosh(log(Integer(1) / 4)) - Rational(17, 8)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`cosh(log(Integer(1) / 4)) - Rational(17, 8)`	→	`-17/8 + cosh(log(4))`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-1149-ground true simplipy-ground solved Eq(exp(Abs(log(2))), 2) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Residual = exp(Abs(log(2))) - 2
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`exp(Abs(log(2))) - 2`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-1177-ground true simplipy-ground solved Eq(Pow(0, asinh(10)), 0) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Residual = Pow(0, asinh(10)) - 0
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(0, asinh(10)) - 0`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-1195-ground true simplipy-ground solved Eq(Pow(0, atan(7)), 0) true difference → 0 · simplify → 0 0.01 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Residual = Pow(0, atan(7)) - 0
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(0, atan(7)) - 0`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-1217-ground true simplipy-ground solved Eq(Pow(0, exp((-1))), 0) true difference → 0 · simplify → 0 0.006 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Residual = Pow(0, exp(-1)) - 0
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(0, exp(-1)) - 0`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-1238-ground true simplipy-ground solved Eq(Pow(0, (1/pi)), 0) true difference → 0 · simplify → 0 0.006 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Residual = Pow(0, 1 / pi) - 0
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(0, 1 / pi) - 0`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-1247-ground true simplipy-ground solved Eq(Pow(0, log(9)), 0) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Residual = Pow(0, log(9)) - 0
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(0, log(9)) - 0`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-1254-ground true simplipy-ground solved Eq(Pow(0, sin(2)), 0) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Residual = Pow(0, sin(2)) - 0
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(0, sin(2)) - 0`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-1258-ground true simplipy-ground solved Eq(Pow(0, sin(9)), 0) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Residual = Pow(0, sin(9)) - 0
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(0, sin(9)) - 0`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-5372-ground true simplipy-ground solved Eq(sin(asin((1/(-4)))), Rational(-1, 4)) true difference → 0 · simplify → 0 0.013 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Residual = sin(asin(Integer(1) / -4)) - Rational(-1, 4)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`sin(asin(Integer(1) / -4)) - Rational(-1, 4)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-5382-ground true simplipy-ground solved Eq(sinh(log((1/4))), Rational(-15, 8)) true difference → 15/8 - sinh(log(4)) · simplify → 0 0.094 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Residual = sinh(log(Integer(1) / 4)) - Rational(-15, 8)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`sinh(log(Integer(1) / 4)) - Rational(-15, 8)`	→	`15/8 - sinh(log(4))`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-5385-ground true simplipy-ground solved Eq(sinh((-log(4))), Rational(-15, 8)) true difference → 15/8 - sinh(log(4)) · simplify → 0 0.093 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Residual = sinh(-log(4)) - Rational(-15, 8)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`sinh(-log(4)) - Rational(-15, 8)`	→	`15/8 - sinh(log(4))`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-819-ground true simplipy-ground solved Eq((0/pi), 0) true difference → 0 · simplify → 0 0.006 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Residual = 0 / pi - 0
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`0 / pi - 0`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-837-ground true simplipy-ground solved Eq(Pow(0, pi), 0) true difference → 0 · simplify → 0 0.006 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Residual = Pow(0, pi) - 0
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(0, pi) - 0`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-848-ground true simplipy-ground solved Eq(sinh(log(4)), Rational(15, 8)) true difference → -15/8 + sinh(log(4)) · simplify → 0 0.102 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Residual = sinh(log(4)) - Rational(15, 8)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`sinh(log(4)) - Rational(15, 8)`	→	`-15/8 + sinh(log(4))`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-868-ground true simplipy-ground solved Eq((0*acosh(7)), 0) true difference → 0 · simplify → 0 0.014 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Residual = 0 * acosh(7) - 0
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`0 * acosh(7) - 0`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-911-ground true simplipy-ground solved Eq((0/asin((-1))), 0) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Residual = 0 / asin(-1) - 0
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`0 / asin(-1) - 0`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-927-ground true simplipy-ground solved Eq((0/asinh(4)), 0) true difference → 0 · simplify → 0 0.006 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Residual = 0 / asinh(4) - 0
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`0 / asinh(4) - 0`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-1-real contingent simplipy-real no verdict Q.real(x) ⊢ Eq(asin(Abs(x)), Abs(asin(x))) null difference → -Abs(asin(x)) + asin(Abs(x)) · simplify → -Abs(asin(x)) + asin(Abs(x)) 0.021 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = asin(Abs(x)) - Abs(asin(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`asin(Abs(x)) - Abs(asin(x))`	→	`-Abs(asin(x)) + asin(Abs(x))`
simplify	`simplify(Residual)`	→	`-Abs(asin(x)) + asin(Abs(x))`
answer			`null`

sp-acj4-102-real true simplipy-real solved Q.real(x) ⊢ Eq((Abs(x)/6), Abs((x/(-6)))) true difference → 0 · simplify → 0 0.008 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = Abs(x) / 6 - Abs(x / -6)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(x) / 6 - Abs(x / -6)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-108-real true simplipy-real solved Q.real(x) ∧ (~Q.zero(x)) ∧ (~Q.zero(Abs(x))) ⊢ Eq((Abs(x)/x), (x/Abs(x))) true difference → -x/Abs(x) + Abs(x)/x · simplify → 0 0.016 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(Abs(x))
Residual = Abs(x) / x - (x / Abs(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(x) / x - (x / Abs(x))`	→	`-x/Abs(x) + Abs(x)/x`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-120-real true simplipy-real solved Q.real(x) ∧ (~Q.zero(Abs(x))) ∧ (~Q.zero(x)) ⊢ Eq((pi/Abs(x)), Abs((pi/x))) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(Abs(x))
Residual = pi / Abs(x) - Abs(pi / x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`pi / Abs(x) - Abs(pi / x)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-127-real contingent simplipy-real no verdict Q.real(x) ∧ Ne(exp(x), 1) ∧ Ne(exp(x), (-1)) ⊢ Eq(Abs(atanh(exp(x))), atanh(exp(x))) null difference → Abs(atanh(exp(x))) - atanh(exp(x)) · simplify → Abs(atanh(exp(x))) - atanh(exp(x)) 0.042 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Ne(exp(x), 1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(exp(x), -1, evaluate=False)
Residual = Abs(atanh(exp(x))) - atanh(exp(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(atanh(exp(x))) - atanh(exp(x))`	→	`Abs(atanh(exp(x))) - atanh(exp(x))`
simplify	`simplify(Residual)`	→	`Abs(atanh(exp(x))) - atanh(exp(x))`
answer			`null`

sp-acj4-128-real contingent simplipy-real no verdict Q.real(x) ⊢ Eq(Abs(cos(asin(x))), cos(asin(x))) null difference → -sqrt(1 - x**2) + Abs(sqrt(1 - x**2)) · simplify → -sqrt(1 - x**2) + Abs(sqrt(1 - x**2)) 0.036 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = Abs(cos(asin(x))) - cos(asin(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(cos(asin(x))) - cos(asin(x))`	→	`-sqrt(1 - x2) + Abs(sqrt(1 - x2))`
simplify	`simplify(Residual)`	→	`-sqrt(1 - x2) + Abs(sqrt(1 - x2))`
answer			`null`

sp-acj4-131-real true simplipy-real no verdict Q.real(x) ∧ (~Q.zero(cosh(x))) ⊢ Eq(Abs(log(cosh(x))), log(cosh(x))) null difference → -log(cosh(x)) + Abs(log(cosh(x))) · simplify → -log(cosh(x)) + Abs(log(cosh(x))) 0.064 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(x))
Residual = Abs(log(cosh(x))) - log(cosh(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(log(cosh(x))) - log(cosh(x))`	→	`-log(cosh(x)) + Abs(log(cosh(x)))`
simplify	`simplify(Residual)`	→	`-log(cosh(x)) + Abs(log(cosh(x)))`
answer			`null`

sp-acj4-132-real contingent simplipy-real no verdict Q.real(x) ∧ (~Q.zero(sin(x))) ⊢ Eq(Abs(log(sin(x))), (-log(sin(x)))) null difference → log(sin(x)) + Abs(log(sin(x))) · simplify → log(sin(x)) + Abs(log(sin(x))) 0.048 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): ~Q.zero(sin(x))
Residual = Abs(log(sin(x))) - (-log(sin(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(log(sin(x))) - (-log(sin(x)))`	→	`log(sin(x)) + Abs(log(sin(x)))`
simplify	`simplify(Residual)`	→	`log(sin(x)) + Abs(log(sin(x)))`
answer			`null`

sp-acj4-133-real contingent simplipy-real no verdict Q.real(x) ∧ (~Q.zero(tanh(x))) ⊢ Eq(Abs(log(tanh(x))), (-log(tanh(x)))) null difference → log(tanh(x)) + Abs(log(tanh(x))) · simplify → log(tanh(x)) + Abs(log(tanh(x))) 0.09 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): ~Q.zero(tanh(x))
Residual = Abs(log(tanh(x))) - (-log(tanh(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(log(tanh(x))) - (-log(tanh(x)))`	→	`log(tanh(x)) + Abs(log(tanh(x)))`
simplify	`simplify(Residual)`	→	`log(tanh(x)) + Abs(log(tanh(x)))`
answer			`null`

sp-acj4-136-real contingent simplipy-real no verdict Q.real(x) ∧ Or((~Q.zero(x)), (re(exp(1)) > 0)) ⊢ Eq(Abs(Pow(x, exp(1))), Pow(x, exp(1))) null difference → -x**E + Abs(x**E) · simplify → -x**E + Abs(x**E) 0.022 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Or(~Q.zero(x), re(exp(1)) > 0)
Residual = Abs(Pow(x, exp(1))) - Pow(x, exp(1))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(Pow(x, exp(1))) - Pow(x, exp(1))`	→	`-xE + Abs(xE)`
simplify	`simplify(Residual)`	→	`-xE + Abs(xE)`
answer			`null`

sp-acj4-137-real contingent simplipy-real no verdict Q.real(x) ∧ Or((~Q.zero(x)), (re(pi) > 0)) ⊢ Eq(Abs(Pow(x, pi)), Pow(x, pi)) null difference → -x**pi + Abs(x**pi) · simplify → -x**pi + Abs(x**pi) 0.022 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Or(~Q.zero(x), re(pi) > 0)
Residual = Abs(Pow(x, pi)) - Pow(x, pi)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(Pow(x, pi)) - Pow(x, pi)`	→	`-xpi + Abs(xpi)`
simplify	`simplify(Residual)`	→	`-xpi + Abs(xpi)`
answer			`null`

sp-acj4-14-real true simplipy-real solved Q.real(x) ⊢ Eq((-sin(x)), sin((-x))) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = -sin(x) - sin(-x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-sin(x) - sin(-x)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-145-real contingent simplipy-real no verdict Q.real(x) ⊢ Eq(Abs(sin(acos(x))), cos(asin(x))) null difference → -sqrt(1 - x**2) + Abs(sqrt(1 - x**2)) · simplify → -sqrt(1 - x**2) + Abs(sqrt(1 - x**2)) 0.037 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = Abs(sin(acos(x))) - cos(asin(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(sin(acos(x))) - cos(asin(x))`	→	`-sqrt(1 - x2) + Abs(sqrt(1 - x2))`
simplify	`simplify(Residual)`	→	`-sqrt(1 - x2) + Abs(sqrt(1 - x2))`
answer			`null`

sp-acj4-162-real contingent simplipy-real no verdict Q.real(x) ⊢ Eq(acosh(real_root(x, 5)), acosh(Pow(x, Rational(1, 5)))) null difference → -acosh(x**(1/5)) + acosh(Abs(x)**(1/5)*sign(x)) · simplify → Piecewise((0, Eq(x, 0)), (-acosh(x**(1/5)) + acosh(x/Abs(x**(4/5))), True)) 0.076 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = acosh(real_root(x, 5)) - acosh(Pow(x, Rational(1, 5)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`acosh(real_root(x, 5)) - acosh(Pow(x, Rational(1, 5)))`	→	`-acosh(x(1/5)) + acosh(Abs(x)(1/5)*sign(x))`
simplify	`simplify(Residual)`	→	`Piecewise((0, Eq(x, 0)), (-acosh(x(1/5)) + acosh(x/Abs(x(4/5))), True))`
answer			`null`

sp-acj4-179-real contingent simplipy-real no verdict Q.real(x) ∧ Ne(sinh(acos(x)), I) ∧ Ne(sinh(acos(x)), (-I)) ∧ (~Q.zero(cosh(acos(x)))) ⊢ Eq(atan(sinh(acos(x))), asin(tanh(acos(x)))) null difference → -asin(tanh(acos(x))) + atan(sinh(acos(x))) · simplify → -asin(tanh(acos(x))) + atan(sinh(acos(x))) 0.08 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Ne(sinh(acos(x)), I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(sinh(acos(x)), -I, evaluate=False)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(acos(x)))
Residual = atan(sinh(acos(x))) - asin(tanh(acos(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atan(sinh(acos(x))) - asin(tanh(acos(x)))`	→	`-asin(tanh(acos(x))) + atan(sinh(acos(x)))`
simplify	`simplify(Residual)`	→	`-asin(tanh(acos(x))) + atan(sinh(acos(x)))`
answer			`null`

sp-acj4-181-real contingent simplipy-real no verdict Q.real(x) ∧ Ne(sinh(asin(x)), I) ∧ Ne(sinh(asin(x)), (-I)) ∧ (~Q.zero(cosh(asin(x)))) ⊢ Eq(atan(sinh(asin(x))), asin(tanh(asin(x)))) null difference → -asin(tanh(asin(x))) + atan(sinh(asin(x))) · simplify → -asin(tanh(asin(x))) + atan(sinh(asin(x))) 0.081 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Ne(sinh(asin(x)), I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(sinh(asin(x)), -I, evaluate=False)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(asin(x)))
Residual = atan(sinh(asin(x))) - asin(tanh(asin(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atan(sinh(asin(x))) - asin(tanh(asin(x)))`	→	`-asin(tanh(asin(x))) + atan(sinh(asin(x)))`
simplify	`simplify(Residual)`	→	`-asin(tanh(asin(x))) + atan(sinh(asin(x)))`
answer			`null`

sp-acj4-185-real true simplipy-real no verdict Q.real(x) ∧ (~Q.zero(cos(cos(x)))) ∧ Ne(tan(cos(x)), I) ∧ Ne(tan(cos(x)), (-I)) ⊢ Eq(atan(tan(cos(x))), cos(x)) null difference → -cos(x) + atan(tan(cos(x))) · simplify → -cos(x) + atan(tan(cos(x))) 0.064 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(cos(x)))
# dropped (not a unary fact about one symbol): Ne(tan(cos(x)), I, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(tan(cos(x)), -I, evaluate=False)
Residual = atan(tan(cos(x))) - cos(x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atan(tan(cos(x))) - cos(x)`	→	`-cos(x) + atan(tan(cos(x)))`
simplify	`simplify(Residual)`	→	`-cos(x) + atan(tan(cos(x)))`
answer			`null`

sp-acj4-194-real true simplipy-real no verdict Q.real(x) ∧ Ne(sin(cos(x)), 1) ∧ Ne(sin(cos(x)), (-1)) ∧ (~Q.zero(cos(cos(x)))) ⊢ Eq(atanh(sin(cos(x))), asinh(tan(cos(x)))) null difference → -asinh(tan(cos(x))) + atanh(sin(cos(x))) · simplify → -asinh(tan(cos(x))) + atanh(sin(cos(x))) 0.081 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Ne(sin(cos(x)), 1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(sin(cos(x)), -1, evaluate=False)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(cos(x)))
Residual = atanh(sin(cos(x))) - asinh(tan(cos(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atanh(sin(cos(x))) - asinh(tan(cos(x)))`	→	`-asinh(tan(cos(x))) + atanh(sin(cos(x)))`
simplify	`simplify(Residual)`	→	`-asinh(tan(cos(x))) + atanh(sin(cos(x)))`
answer			`null`

sp-acj4-195-real true simplipy-real no verdict Q.real(x) ∧ Ne(sin(sin(x)), 1) ∧ Ne(sin(sin(x)), (-1)) ∧ (~Q.zero(cos(sin(x)))) ⊢ Eq(atanh(sin(sin(x))), asinh(tan(sin(x)))) null difference → -asinh(tan(sin(x))) + atanh(sin(sin(x))) · simplify → -asinh(tan(sin(x))) + atanh(sin(sin(x))) 0.083 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Ne(sin(sin(x)), 1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(sin(sin(x)), -1, evaluate=False)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(sin(x)))
Residual = atanh(sin(sin(x))) - asinh(tan(sin(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atanh(sin(sin(x))) - asinh(tan(sin(x)))`	→	`-asinh(tan(sin(x))) + atanh(sin(sin(x)))`
simplify	`simplify(Residual)`	→	`-asinh(tan(sin(x))) + atanh(sin(sin(x)))`
answer			`null`

sp-acj4-196-real true simplipy-real no verdict Q.real(x) ∧ Ne(sin(tanh(x)), 1) ∧ Ne(sin(tanh(x)), (-1)) ∧ (~Q.zero(cos(tanh(x)))) ⊢ Eq(atanh(sin(tanh(x))), asinh(tan(tanh(x)))) null difference → -asinh(tan(tanh(x))) + atanh(sin(tanh(x))) · simplify → -asinh(tan(tanh(x))) + atanh(sin(tanh(x))) 0.071 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Ne(sin(tanh(x)), 1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(sin(tanh(x)), -1, evaluate=False)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(tanh(x)))
Residual = atanh(sin(tanh(x))) - asinh(tan(tanh(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atanh(sin(tanh(x))) - asinh(tan(tanh(x)))`	→	`-asinh(tan(tanh(x))) + atanh(sin(tanh(x)))`
simplify	`simplify(Residual)`	→	`-asinh(tan(tanh(x))) + atanh(sin(tanh(x)))`
answer			`null`

sp-acj4-218-real true simplipy-real solved Q.real(x) ∧ (~Q.zero(x)) ∧ (~Q.zero(((-6)/x))) ⊢ Eq((1/((-6)/x)), (x/(-6))) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(-6 / x)
Residual = 1 / (-6 / x) - (x / -6)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`1 / (-6 / x) - (x / -6)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-22-real true simplipy-real no verdict Q.real(x) ⊢ Eq(tanh(Abs(x)), Abs(tanh(x))) null difference → tanh(Abs(x)) - Abs(tanh(x)) · simplify → tanh(Abs(x)) - Abs(tanh(x)) 0.082 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = tanh(Abs(x)) - Abs(tanh(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`tanh(Abs(x)) - Abs(tanh(x))`	→	`tanh(Abs(x)) - Abs(tanh(x))`
simplify	`simplify(Residual)`	→	`tanh(Abs(x)) - Abs(tanh(x))`
answer			`null`

sp-acj4-220-real true simplipy-real solved Q.real(x) ∧ (~Q.zero(x)) ∧ (~Q.zero(((-8)/x))) ⊢ Eq((1/((-8)/x)), (x/(-8))) true difference → 0 · simplify → 0 0.008 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(-8 / x)
Residual = 1 / (-8 / x) - (x / -8)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`1 / (-8 / x) - (x / -8)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-233-real true simplipy-real solved Q.real(x) ∧ Or((~Q.zero(x)), (re(pi) > 0)) ∧ (~Q.zero(Pow(x, pi))) ∧ Or((~Q.zero(x)), (re((-pi)) > 0)) ⊢ Eq((1/Pow(x, pi)), Pow(x, (-pi))) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Or(~Q.zero(x), re(pi) > 0)
# dropped (not a unary fact about one symbol): ~Q.zero(Pow(x, pi))
# dropped (not a unary fact about one symbol): Or(~Q.zero(x), re(-pi) > 0)
Residual = 1 / Pow(x, pi) - Pow(x, -pi)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`1 / Pow(x, pi) - Pow(x, -pi)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-248-real contingent simplipy-real no verdict Q.real(x) ⊢ Eq((-Abs(asin(x))), asin((-Abs(x)))) null difference → -Abs(asin(x)) + asin(Abs(x)) · simplify → -Abs(asin(x)) + asin(Abs(x)) 0.021 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = -Abs(asin(x)) - asin(-Abs(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-Abs(asin(x)) - asin(-Abs(x))`	→	`-Abs(asin(x)) + asin(Abs(x))`
simplify	`simplify(Residual)`	→	`-Abs(asin(x)) + asin(Abs(x))`
answer			`null`

sp-acj4-249-real true simplipy-real no verdict Q.real(x) ⊢ Eq((-Abs(asinh(x))), asinh((-Abs(x)))) null difference → -Abs(asinh(x)) + asinh(Abs(x)) · simplify → -Abs(asinh(x)) + asinh(Abs(x)) 0.019 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = -Abs(asinh(x)) - asinh(-Abs(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-Abs(asinh(x)) - asinh(-Abs(x))`	→	`-Abs(asinh(x)) + asinh(Abs(x))`
simplify	`simplify(Residual)`	→	`-Abs(asinh(x)) + asinh(Abs(x))`
answer			`null`

sp-acj4-251-real contingent simplipy-real no verdict Q.real(x) ∧ Ne(x, 1) ∧ Ne(x, (-1)) ∧ Ne((-Abs(x)), 1) ∧ Ne((-Abs(x)), (-1)) ⊢ Eq((-Abs(atanh(x))), atanh((-Abs(x)))) null difference → -Abs(atanh(x)) + atanh(Abs(x)) · simplify → -Abs(atanh(x)) + atanh(Abs(x)) 0.023 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Ne(x, 1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(x, -1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(-Abs(x), 1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(-Abs(x), -1, evaluate=False)
Residual = -Abs(atanh(x)) - atanh(-Abs(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-Abs(atanh(x)) - atanh(-Abs(x))`	→	`-Abs(atanh(x)) + atanh(Abs(x))`
simplify	`simplify(Residual)`	→	`-Abs(atanh(x)) + atanh(Abs(x))`
answer			`null`

sp-acj4-252-real true simplipy-real no verdict Q.real(x) ⊢ Eq((-Abs(sinh(x))), sinh((-Abs(x)))) null difference → sinh(Abs(x)) - Abs(sinh(x)) · simplify → sinh(Abs(x)) - Abs(sinh(x)) 0.077 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = -Abs(sinh(x)) - sinh(-Abs(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-Abs(sinh(x)) - sinh(-Abs(x))`	→	`sinh(Abs(x)) - Abs(sinh(x))`
simplify	`simplify(Residual)`	→	`sinh(Abs(x)) - Abs(sinh(x))`
answer			`null`

sp-acj4-253-real true simplipy-real no verdict Q.real(x) ⊢ Eq((-Abs(tanh(x))), tanh((-Abs(x)))) null difference → tanh(Abs(x)) - Abs(tanh(x)) · simplify → tanh(Abs(x)) - Abs(tanh(x)) 0.082 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = -Abs(tanh(x)) - tanh(-Abs(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-Abs(tanh(x)) - tanh(-Abs(x))`	→	`tanh(Abs(x)) - Abs(tanh(x))`
simplify	`simplify(Residual)`	→	`tanh(Abs(x)) - Abs(tanh(x))`
answer			`null`

sp-acj4-256-real true simplipy-real solved Q.real(x) ∧ (~Q.zero((-exp(x)))) ⊢ Eq((-exp((-x))), (1/(-exp(x)))) true difference → 0 · simplify → 0 0.009 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): ~Q.zero(-exp(x))
Residual = -exp(-x) - (1 / -exp(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-exp(-x) - (1 / -exp(x))`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-275-real true simplipy-real solved Q.real(x) ∧ (~Q.zero(Abs(x))) ∧ (~Q.zero(x)) ⊢ Eq(Pow(Abs(x), (-3)), Abs(Pow(x, (-3)))) true difference → -1/(x**2*Abs(x)) + Abs(x)/x**4 · simplify → 0 0.024 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(Abs(x))
Residual = Pow(Abs(x), -3) - Abs(Pow(x, -3))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(Abs(x), -3) - Abs(Pow(x, -3))`	→	`-1/(x*2Abs(x)) + Abs(x)/x**4`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-276-real true simplipy-real solved Q.real(x) ∧ (~Q.zero(Abs(x))) ∧ (~Q.zero(x)) ⊢ Eq(Pow(Abs(x), (-4)), Pow(x, (-4))) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(Abs(x))
Residual = Pow(Abs(x), -4) - Pow(x, -4)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(Abs(x), -4) - Pow(x, -4)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-283-real true simplipy-real solved Q.real(x) ⊢ Eq(Pow(Abs(x), 2), (x*x)) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = Pow(Abs(x), 2) - (x * x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(Abs(x), 2) - (x * x)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-286-real true simplipy-real solved Q.real(x) ⊢ Eq(Pow(Abs(x), 5), Abs(Pow(x, 5))) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = Pow(Abs(x), 5) - Abs(Pow(x, 5))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(Abs(x), 5) - Abs(Pow(x, 5))`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-289-real true simplipy-real solved Q.real(x) ⊢ Eq(Pow(Abs(x), 8), Pow(x, 8)) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = Pow(Abs(x), 8) - Pow(x, 8)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(Abs(x), 8) - Pow(x, 8)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-31-real true simplipy-real solved Q.real(x) ⊢ Eq((5*Abs(x)), Abs(((-5)*x))) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = 5 * Abs(x) - Abs(-5 * x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`5 * Abs(x) - Abs(-5 * x)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-326-real true simplipy-real solved Q.real(x) ⊢ Eq(Pow(exp(x), 2), exp((2*x))) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = Pow(exp(x), 2) - exp(2 * x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(exp(x), 2) - exp(2 * x)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-33-real true simplipy-real solved Q.real(x) ⊢ Eq((6*Abs(x)), Abs(((-6)*x))) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = 6 * Abs(x) - Abs(-6 * x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`6 * Abs(x) - Abs(-6 * x)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-35-real contingent simplipy-real no verdict Q.real(x) ∧ (~Q.zero(x)) ∧ (~Q.zero(Pow(x, 7))) ⊢ Eq((7*log(x)), log(Pow(x, 7))) null difference → 7*log(x) - log(x**7) · simplify → 7*log(x) - log(x**7) 0.025 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(Pow(x, 7))
Residual = 7 * log(x) - log(Pow(x, 7))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`7 * log(x) - log(Pow(x, 7))`	→	`7log(x) - log(x*7)`
simplify	`simplify(Residual)`	→	`7log(x) - log(x*7)`
answer			`null`

sp-acj4-354-real true simplipy-real no verdict Q.real(x) ∧ Or((~Q.zero(x)), (re(log(5)) > 0)) ∧ (~Q.zero(x)) ⊢ Eq(Pow(x, log(5)), Pow(5, log(x))) null difference → -5**log(x) + x**log(5) · simplify → -5**log(x) + x**log(5) 0.023 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): Or(~Q.zero(x), re(log(5)) > 0)
Residual = Pow(x, log(5)) - Pow(5, log(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(x, log(5)) - Pow(5, log(x))`	→	`-5log(x) + xlog(5)`
simplify	`simplify(Residual)`	→	`-5log(x) + xlog(5)`
answer			`null`

sp-acj4-356-real true simplipy-real no verdict Q.real(x) ∧ Or((~Q.zero(x)), (re(log(7)) > 0)) ∧ (~Q.zero(x)) ⊢ Eq(Pow(x, log(7)), Pow(7, log(x))) null difference → -7**log(x) + x**log(7) · simplify → -7**log(x) + x**log(7) 0.023 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): Or(~Q.zero(x), re(log(7)) > 0)
Residual = Pow(x, log(7)) - Pow(7, log(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(x, log(7)) - Pow(7, log(x))`	→	`-7log(x) + xlog(7)`
simplify	`simplify(Residual)`	→	`-7log(x) + xlog(7)`
answer			`null`

sp-acj4-359-real true simplipy-real no verdict Q.real(x) ∧ Or((~Q.zero(x)), (re(log(pi)) > 0)) ∧ (~Q.zero(x)) ⊢ Eq(Pow(x, log(pi)), Pow(pi, log(x))) null difference → -pi**log(x) + x**log(pi) · simplify → -pi**log(x) + x**log(pi) 0.022 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): Or(~Q.zero(x), re(log(pi)) > 0)
Residual = Pow(x, log(pi)) - Pow(pi, log(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Pow(x, log(pi)) - Pow(pi, log(x))`	→	`-pilog(x) + xlog(pi)`
simplify	`simplify(Residual)`	→	`-pilog(x) + xlog(pi)`
answer			`null`

sp-acj4-364-real true simplipy-real no verdict Q.real(x) ⊢ Eq(real_root(Abs(x), 3), Abs(real_root(x, 3))) null difference → -Abs(x)**(1/3)*Abs(sign(x)) + Abs(x)**(1/3)*sign(Abs(x)) · simplify → Piecewise((0, Eq(x, 0)), (-Abs(x**(4/3)/Abs(x)), Eq(Abs(x), 0)), (Abs(x)**(1/3) - Abs(x**… 0.087 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = real_root(Abs(x), 3) - Abs(real_root(x, 3))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`real_root(Abs(x), 3) - Abs(real_root(x, 3))`	→	`-Abs(x)*(1/3)Abs(sign(x)) + Abs(x)*(1/3)sign(Abs(x))`
simplify	`simplify(Residual)`	→	`Piecewise((0, Eq(x, 0)), (-Abs(x(4/3)/Abs(x)), Eq(Abs(x), 0)), (Abs(x)(1/3) - Abs(x**(4/3)/Abs(x)), True))`
answer			`null`

sp-acj4-367-real true simplipy-real no verdict Q.real(x) ⊢ Eq(real_root(Abs(x), 9), Abs(real_root(x, 9))) null difference → -Abs(x)**(1/9)*Abs(sign(x)) + Abs(x)**(1/9)*sign(Abs(x)) · simplify → Piecewise((0, Eq(x, 0)), (-Abs(x**(10/9)/Abs(x)), Eq(Abs(x), 0)), (Abs(x)**(1/9) - Abs(x*… 0.087 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = real_root(Abs(x), 9) - Abs(real_root(x, 9))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`real_root(Abs(x), 9) - Abs(real_root(x, 9))`	→	`-Abs(x)*(1/9)Abs(sign(x)) + Abs(x)*(1/9)sign(Abs(x))`
simplify	`simplify(Residual)`	→	`Piecewise((0, Eq(x, 0)), (-Abs(x(10/9)/Abs(x)), Eq(Abs(x), 0)), (Abs(x)(1/9) - Abs(x**(10/9)/Abs(x)), True))`
answer			`null`

sp-acj4-368-real true simplipy-real no verdict Q.real(x) ∧ Q.real(acos(x)) ∧ (~Q.zero(acos(x))) ⊢ Eq(real_root(acos(x), (-5)), Pow(acos(x), Rational(-1, 5))) null difference → Piecewise((sign(acos(x))/Abs(acos(x))**(1/5), Eq(im(acos(x)), 0)), (acos(x)**(-1/5), True… · simplify → Piecewise((-1/acos(x)**(1/5), Eq(acos(x), 0) & Eq(im(acos(x)), 0)), (-1/acos(x)**(1/5) + … 0.108 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Q.real(acos(x))
# dropped (not a unary fact about one symbol): ~Q.zero(acos(x))
Residual = real_root(acos(x), -5) - Pow(acos(x), Rational(-1, 5))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`real_root(acos(x), -5) - Pow(acos(x), Rational(-1, 5))`	→	`Piecewise((sign(acos(x))/Abs(acos(x))(1/5), Eq(im(acos(x)), 0)), (acos(x)(-1/5), True)) - 1/acos(x)**(1/5)`
simplify	`simplify(Residual)`	→	`Piecewise((-1/acos(x)(1/5), Eq(acos(x), 0) & Eq(im(acos(x)), 0)), (-1/acos(x)(1/5) + acos(x)/Abs(acos(x)**(6/5)), Eq(im(acos(x)), 0)), (0, True))`
answer			`null`

sp-acj4-369-real true simplipy-real no verdict Q.real(x) ∧ Q.real(acos(x)) ⊢ Eq(real_root(acos(x), 5), Pow(acos(x), Rational(1, 5))) null difference → Piecewise((Abs(acos(x))**(1/5)*sign(acos(x)), Eq(im(acos(x)), 0)), (acos(x)**(1/5), True)… · simplify → Piecewise((-acos(x)**(1/5), Eq(acos(x), 0) & Eq(im(acos(x)), 0)), (-acos(x)**(1/5) + acos… 0.095 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Q.real(acos(x))
Residual = real_root(acos(x), 5) - Pow(acos(x), Rational(1, 5))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`real_root(acos(x), 5) - Pow(acos(x), Rational(1, 5))`	→	`Piecewise((Abs(acos(x))*(1/5)sign(acos(x)), Eq(im(acos(x)), 0)), (acos(x)(1/5), True)) - acos(x)(1/5)`
simplify	`simplify(Residual)`	→	`Piecewise((-acos(x)(1/5), Eq(acos(x), 0) & Eq(im(acos(x)), 0)), (-acos(x)(1/5) + acos(x)/Abs(acos(x)**(4/5)), Eq(im(acos(x)), 0)), (0, True))`
answer			`null`

sp-acj4-370-real true simplipy-real no verdict Q.real(x) ∧ Q.real(acosh(x)) ∧ (~Q.zero(acosh(x))) ⊢ Eq(real_root(acosh(x), (-5)), Pow(acosh(x), Rational(-1, 5))) null difference → Piecewise((sign(acosh(x))/Abs(acosh(x))**(1/5), Eq(im(acosh(x)), 0)), (acosh(x)**(-1/5), … · simplify → Piecewise((-1/acosh(x)**(1/5), Eq(acosh(x), 0) & Eq(im(acosh(x)), 0)), (-1/acosh(x)**(1/5… 0.105 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Q.real(acosh(x))
# dropped (not a unary fact about one symbol): ~Q.zero(acosh(x))
Residual = real_root(acosh(x), -5) - Pow(acosh(x), Rational(-1, 5))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`real_root(acosh(x), -5) - Pow(acosh(x), Rational(-1, 5))`	→	`Piecewise((sign(acosh(x))/Abs(acosh(x))(1/5), Eq(im(acosh(x)), 0)), (acosh(x)(-1/5), True)) - 1/acosh(x)**(1/5)`
simplify	`simplify(Residual)`	→	`Piecewise((-1/acosh(x)(1/5), Eq(acosh(x), 0) & Eq(im(acosh(x)), 0)), (-1/acosh(x)(1/5) + acosh(x)/Abs(acosh(x)**(6/5)), Eq(im(acosh(x)), 0)), (0, True))`
answer			`null`

sp-acj4-371-real true simplipy-real no verdict Q.real(x) ∧ Q.real(acosh(x)) ⊢ Eq(real_root(acosh(x), 5), Pow(acosh(x), Rational(1, 5))) null difference → Piecewise((Abs(acosh(x))**(1/5)*sign(acosh(x)), Eq(im(acosh(x)), 0)), (acosh(x)**(1/5), T… · simplify → Piecewise((-acosh(x)**(1/5), Eq(acosh(x), 0) & Eq(im(acosh(x)), 0)), (-acosh(x)**(1/5) + … 0.092 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Q.real(acosh(x))
Residual = real_root(acosh(x), 5) - Pow(acosh(x), Rational(1, 5))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`real_root(acosh(x), 5) - Pow(acosh(x), Rational(1, 5))`	→	`Piecewise((Abs(acosh(x))*(1/5)sign(acosh(x)), Eq(im(acosh(x)), 0)), (acosh(x)(1/5), True)) - acosh(x)(1/5)`
simplify	`simplify(Residual)`	→	`Piecewise((-acosh(x)(1/5), Eq(acosh(x), 0) & Eq(im(acosh(x)), 0)), (-acosh(x)(1/5) + acosh(x)/Abs(acosh(x)**(4/5)), Eq(im(acosh(x)), 0)), (0, True))`
answer			`null`

sp-acj4-372-real true simplipy-real solved Q.real(x) ∧ (~Q.zero(cosh(x))) ⊢ Eq(real_root(cosh(x), (-5)), Pow(cosh(x), Rational(-1, 5))) true difference → 0 · simplify → 0 0.01 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cosh(x))
Residual = real_root(cosh(x), -5) - Pow(cosh(x), Rational(-1, 5))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`real_root(cosh(x), -5) - Pow(cosh(x), Rational(-1, 5))`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-373-real true simplipy-real solved Q.real(x) ⊢ Eq(real_root(cosh(x), 5), Pow(cosh(x), Rational(1, 5))) true difference → 0 · simplify → 0 0.01 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = real_root(cosh(x), 5) - Pow(cosh(x), Rational(1, 5))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`real_root(cosh(x), 5) - Pow(cosh(x), Rational(1, 5))`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-38-real contingent simplipy-real no verdict Q.real(x) ∧ (~Q.zero(x)) ∧ (~Q.zero(Pow(x, 9))) ⊢ Eq((9*log(x)), log(Pow(x, 9))) null difference → 9*log(x) - log(x**9) · simplify → 9*log(x) - log(x**9) 0.025 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(Pow(x, 9))
Residual = 9 * log(x) - log(Pow(x, 9))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`9 * log(x) - log(Pow(x, 9))`	→	`9log(x) - log(x*9)`
simplify	`simplify(Residual)`	→	`9log(x) - log(x*9)`
answer			`null`

sp-acj4-394-real contingent simplipy-real no verdict Q.real(x) ∧ Ne(x, 1) ∧ Ne(x, (-1)) ⊢ Eq(sin(Abs(atanh(x))), Abs(sin(atanh(x)))) null difference → sin(Abs(atanh(x))) - Abs(sin(atanh(x))) · simplify → sin(Abs(atanh(x))) - Abs(sin(atanh(x))) 0.055 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Ne(x, 1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(x, -1, evaluate=False)
Residual = sin(Abs(atanh(x))) - Abs(sin(atanh(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`sin(Abs(atanh(x))) - Abs(sin(atanh(x)))`	→	`sin(Abs(atanh(x))) - Abs(sin(atanh(x)))`
simplify	`simplify(Residual)`	→	`sin(Abs(atanh(x))) - Abs(sin(atanh(x)))`
answer			`null`

sp-acj4-395-real true simplipy-real no verdict Q.real(x) ⊢ Eq(sin(Abs(cos(x))), Abs(sin(cos(x)))) null difference → sin(Abs(cos(x))) - Abs(sin(cos(x))) · simplify → sin(Abs(cos(x))) - Abs(sin(cos(x))) 0.074 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = sin(Abs(cos(x))) - Abs(sin(cos(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`sin(Abs(cos(x))) - Abs(sin(cos(x)))`	→	`sin(Abs(cos(x))) - Abs(sin(cos(x)))`
simplify	`simplify(Residual)`	→	`sin(Abs(cos(x))) - Abs(sin(cos(x)))`
answer			`null`

sp-acj4-396-real true simplipy-real no verdict Q.real(x) ⊢ Eq(sin(Abs(sin(x))), Abs(sin(sin(x)))) null difference → sin(Abs(sin(x))) - Abs(sin(sin(x))) · simplify → sin(Abs(sin(x))) - Abs(sin(sin(x))) 0.077 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = sin(Abs(sin(x))) - Abs(sin(sin(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`sin(Abs(sin(x))) - Abs(sin(sin(x)))`	→	`sin(Abs(sin(x))) - Abs(sin(sin(x)))`
simplify	`simplify(Residual)`	→	`sin(Abs(sin(x))) - Abs(sin(sin(x)))`
answer			`null`

sp-acj4-397-real true simplipy-real no verdict Q.real(x) ⊢ Eq(sin(Abs(tanh(x))), Abs(sin(tanh(x)))) null difference → sin(Abs(tanh(x))) - Abs(sin(tanh(x))) · simplify → sin(Abs(tanh(x))) - Abs(sin(tanh(x))) 0.065 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = sin(Abs(tanh(x))) - Abs(sin(tanh(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`sin(Abs(tanh(x))) - Abs(sin(tanh(x)))`	→	`sin(Abs(tanh(x))) - Abs(sin(tanh(x)))`
simplify	`simplify(Residual)`	→	`sin(Abs(tanh(x))) - Abs(sin(tanh(x)))`
answer			`null`

sp-acj4-402-real contingent simplipy-real no verdict Q.real(x) ∧ Ne(Abs(x), 1) ∧ Ne(x, 1) ∧ Ne(x, (-1)) ⊢ Eq(sin(atanh(Abs(x))), Abs(sin(atanh(x)))) null difference → sin(atanh(Abs(x))) - Abs(sin(atanh(x))) · simplify → sin(atanh(Abs(x))) - Abs(sin(atanh(x))) 0.058 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Ne(Abs(x), 1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(x, 1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(x, -1, evaluate=False)
Residual = sin(atanh(Abs(x))) - Abs(sin(atanh(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`sin(atanh(Abs(x))) - Abs(sin(atanh(x)))`	→	`sin(atanh(Abs(x))) - Abs(sin(atanh(x)))`
simplify	`simplify(Residual)`	→	`sin(atanh(Abs(x))) - Abs(sin(atanh(x)))`
answer			`null`

sp-acj4-404-real true simplipy-real no verdict Q.real(x) ⊢ Eq(sin(tanh(Abs(x))), Abs(sin(tanh(x)))) null difference → sin(tanh(Abs(x))) - Abs(sin(tanh(x))) · simplify → sin(tanh(Abs(x))) - Abs(sin(tanh(x))) 0.069 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = sin(tanh(Abs(x))) - Abs(sin(tanh(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`sin(tanh(Abs(x))) - Abs(sin(tanh(x)))`	→	`sin(tanh(Abs(x))) - Abs(sin(tanh(x)))`
simplify	`simplify(Residual)`	→	`sin(tanh(Abs(x))) - Abs(sin(tanh(x)))`
answer			`null`

sp-acj4-412-real contingent simplipy-real no verdict Q.real(x) ∧ (~Q.zero(cos(Abs(asin(x))))) ∧ (~Q.zero(cos(asin(x)))) ⊢ Eq(tan(Abs(asin(x))), Abs(tan(asin(x)))) null difference → tan(Abs(asin(x))) - Abs(x)/Abs(sqrt(1 - x**2)) · simplify → tan(Abs(asin(x))) - Abs(x/sqrt(1 - x**2)) 0.082 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(Abs(asin(x))))
# dropped (not a unary fact about one symbol): ~Q.zero(cos(asin(x)))
Residual = tan(Abs(asin(x))) - Abs(tan(asin(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`tan(Abs(asin(x))) - Abs(tan(asin(x)))`	→	`tan(Abs(asin(x))) - Abs(x)/Abs(sqrt(1 - x**2))`
simplify	`simplify(Residual)`	→	`tan(Abs(asin(x))) - Abs(x/sqrt(1 - x**2))`
answer			`null`

sp-acj4-413-real true simplipy-real no verdict Q.real(x) ∧ (~Q.zero(cos(Abs(cos(x))))) ∧ (~Q.zero(cos(cos(x)))) ⊢ Eq(tan(Abs(cos(x))), Abs(tan(cos(x)))) null difference → tan(Abs(cos(x))) - Abs(tan(cos(x))) · simplify → tan(Abs(cos(x))) - Abs(tan(cos(x))) 0.095 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(Abs(cos(x))))
# dropped (not a unary fact about one symbol): ~Q.zero(cos(cos(x)))
Residual = tan(Abs(cos(x))) - Abs(tan(cos(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`tan(Abs(cos(x))) - Abs(tan(cos(x)))`	→	`tan(Abs(cos(x))) - Abs(tan(cos(x)))`
simplify	`simplify(Residual)`	→	`tan(Abs(cos(x))) - Abs(tan(cos(x)))`
answer			`null`

sp-acj4-414-real true simplipy-real no verdict Q.real(x) ∧ (~Q.zero(cos(Abs(sin(x))))) ∧ (~Q.zero(cos(sin(x)))) ⊢ Eq(tan(Abs(sin(x))), Abs(tan(sin(x)))) null difference → tan(Abs(sin(x))) - Abs(tan(sin(x))) · simplify → tan(Abs(sin(x))) - Abs(tan(sin(x))) 0.096 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(Abs(sin(x))))
# dropped (not a unary fact about one symbol): ~Q.zero(cos(sin(x)))
Residual = tan(Abs(sin(x))) - Abs(tan(sin(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`tan(Abs(sin(x))) - Abs(tan(sin(x)))`	→	`tan(Abs(sin(x))) - Abs(tan(sin(x)))`
simplify	`simplify(Residual)`	→	`tan(Abs(sin(x))) - Abs(tan(sin(x)))`
answer			`null`

sp-acj4-415-real true simplipy-real no verdict Q.real(x) ∧ (~Q.zero(cos(Abs(tanh(x))))) ∧ (~Q.zero(cos(tanh(x)))) ⊢ Eq(tan(Abs(tanh(x))), Abs(tan(tanh(x)))) null difference → tan(Abs(tanh(x))) - Abs(tan(tanh(x))) · simplify → tan(Abs(tanh(x))) - Abs(tan(tanh(x))) 0.082 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(Abs(tanh(x))))
# dropped (not a unary fact about one symbol): ~Q.zero(cos(tanh(x)))
Residual = tan(Abs(tanh(x))) - Abs(tan(tanh(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`tan(Abs(tanh(x))) - Abs(tan(tanh(x)))`	→	`tan(Abs(tanh(x))) - Abs(tan(tanh(x)))`
simplify	`simplify(Residual)`	→	`tan(Abs(tanh(x))) - Abs(tan(tanh(x)))`
answer			`null`

sp-acj4-417-real contingent simplipy-real no verdict Q.real(x) ∧ (~Q.zero(cos(asin(Abs(x))))) ∧ (~Q.zero(cos(asin(x)))) ⊢ Eq(tan(asin(Abs(x))), Abs(tan(asin(x)))) null difference → -Abs(x)/Abs(sqrt(1 - x**2)) + Abs(x)/sqrt(1 - x**2) · simplify → -Abs(x/sqrt(1 - x**2)) + Abs(x)/sqrt(1 - x**2) 0.059 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(asin(Abs(x))))
# dropped (not a unary fact about one symbol): ~Q.zero(cos(asin(x)))
Residual = tan(asin(Abs(x))) - Abs(tan(asin(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`tan(asin(Abs(x))) - Abs(tan(asin(x)))`	→	`-Abs(x)/Abs(sqrt(1 - x2)) + Abs(x)/sqrt(1 - x2)`
simplify	`simplify(Residual)`	→	`-Abs(x/sqrt(1 - x2)) + Abs(x)/sqrt(1 - x2)`
answer			`null`

sp-acj4-421-real true simplipy-real no verdict Q.real(x) ∧ (~Q.zero(cos(tanh(Abs(x))))) ∧ (~Q.zero(cos(tanh(x)))) ⊢ Eq(tan(tanh(Abs(x))), Abs(tan(tanh(x)))) null difference → tan(tanh(Abs(x))) - Abs(tan(tanh(x))) · simplify → tan(tanh(Abs(x))) - Abs(tan(tanh(x))) 0.088 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(tanh(Abs(x))))
# dropped (not a unary fact about one symbol): ~Q.zero(cos(tanh(x)))
Residual = tan(tanh(Abs(x))) - Abs(tan(tanh(x)))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`tan(tanh(Abs(x))) - Abs(tan(tanh(x)))`	→	`tan(tanh(Abs(x))) - Abs(tan(tanh(x)))`
simplify	`simplify(Residual)`	→	`tan(tanh(Abs(x))) - Abs(tan(tanh(x)))`
answer			`null`

sp-acj4-5-real contingent simplipy-real no verdict Q.real(x) ∧ Ne(Abs(x), 1) ∧ Ne(x, 1) ∧ Ne(x, (-1)) ⊢ Eq(atanh(Abs(x)), Abs(atanh(x))) null difference → -Abs(atanh(x)) + atanh(Abs(x)) · simplify → -Abs(atanh(x)) + atanh(Abs(x)) 0.022 null

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): Ne(Abs(x), 1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(x, 1, evaluate=False)
# dropped (not a unary fact about one symbol): Ne(x, -1, evaluate=False)
Residual = atanh(Abs(x)) - Abs(atanh(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`atanh(Abs(x)) - Abs(atanh(x))`	→	`-Abs(atanh(x)) + atanh(Abs(x))`
simplify	`simplify(Residual)`	→	`-Abs(atanh(x)) + atanh(Abs(x))`
answer			`null`

sp-acj4-73-real true simplipy-real solved Q.real(x) ∧ (~Q.zero(Abs(x))) ∧ (~Q.zero((-Abs(x)))) ⊢ Eq(((-1)/Abs(x)), (1/(-Abs(x)))) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): ~Q.zero(Abs(x))
# dropped (not a unary fact about one symbol): ~Q.zero(-Abs(x))
Residual = -1 / Abs(x) - (1 / -Abs(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-1 / Abs(x) - (1 / -Abs(x))`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-80-real true simplipy-real solved Q.real(x) ∧ (~Q.zero(cos(x))) ∧ (~Q.zero((-cos(x)))) ⊢ Eq(((-1)/cos(x)), (1/(-cos(x)))) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(x))
# dropped (not a unary fact about one symbol): ~Q.zero(-cos(x))
Residual = -1 / cos(x) - (1 / -cos(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-1 / cos(x) - (1 / -cos(x))`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-83-real true simplipy-real solved Q.real(x) ∧ (~Q.zero(x)) ∧ (~Q.zero(log(x))) ∧ (~Q.zero((-log(x)))) ⊢ Eq(((-1)/log(x)), (1/(-log(x)))) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(log(x))
# dropped (not a unary fact about one symbol): ~Q.zero(-log(x))
Residual = -1 / log(x) - (1 / -log(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-1 / log(x) - (1 / -log(x))`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-86-real true simplipy-real solved Q.real(x) ∧ (~Q.zero(cos(x))) ∧ (~Q.zero(tan(x))) ∧ (~Q.zero((-tan(x)))) ⊢ Eq(((-1)/tan(x)), (1/(-tan(x)))) true difference → 0 · simplify → 0 0.007 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
# dropped (not a unary fact about one symbol): ~Q.zero(cos(x))
# dropped (not a unary fact about one symbol): ~Q.zero(tan(x))
# dropped (not a unary fact about one symbol): ~Q.zero(-tan(x))
Residual = -1 / tan(x) - (1 / -tan(x))
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`-1 / tan(x) - (1 / -tan(x))`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-90-real true simplipy-real solved Q.real(x) ∧ (~Q.zero(Abs(x))) ∧ (~Q.zero(x)) ⊢ Eq((3/Abs(x)), Abs(((-3)/x))) true difference → 0 · simplify → 0 0.008 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True, zero=False)
# dropped (not a unary fact about one symbol): ~Q.zero(Abs(x))
Residual = 3 / Abs(x) - Abs(-3 / x)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`3 / Abs(x) - Abs(-3 / x)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`

sp-acj4-99-real true simplipy-real solved Q.real(x) ⊢ Eq((Abs(x)/3), Abs((x/(-3)))) true difference → 0 · simplify → 0 0.008 true

code

setup — not timed

from sympy import *
import sympy

SympyVersion = sympy.__version__
# warm-up: a fixed generic expression, never case content
W = Symbol('W')
Warmup = simplify(sin(W)**2 + cos(W)**2)
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

x = Symbol('x', real=True)
Residual = Abs(x) / 3 - Abs(x / -3)
Result = simplify(Residual)
# true iff the result is 0; false only if it is a definite nonzero number
Answer = True if Result == 0 else False if (Result.is_number and Result.is_finite and Result.is_zero is False) else None
print(Result, Answer, sep='\n')

difference	`Abs(x) / 3 - Abs(x / -3)`	→	`0`
simplify	`simplify(Residual)`	→	`0`
answer			`true`