sympy-ask

suite simplipy · 2026-10-12 21:54:02 · CAS sympy 1.15.0.dev, mode fork · machine pi5 · dialect sympy · case set ee702ae2fe06

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	2	90
simplipy-f64-edge	45	11	34
simplipy-ground	20	16	4
simplipy-real	70	22	48
total	307	64	243

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

measured setup time: 0.436 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in 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.15.0.dev`
warm-up	`ask(Q.positive(W**2 + 1), Q.real(W))`	→	`True`

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)) · ask → None 0.039 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x))
Residual = acosh(cosh(x)) - Abs(x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`acosh(cosh(x)) - Abs(x)`	→	`-Abs(x) + acosh(cosh(x))`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

sp-acj4-102-complex true simplipy-complex-branch solved Q.complex(x) ⊢ Eq((Abs(x)/6), Abs((x/(-6)))) true difference → 0 · ask → True 0.011 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x))
Residual = Abs(x) / 6 - Abs(x / -6)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(x) / 6 - Abs(x / -6)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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 · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(x), ~Q.zero(Abs(x)))
Residual = Abs(x) / x - (x / Abs(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(x) / x - (x / Abs(x))`	→	`-x/Abs(x) + Abs(x)/x`
ask	`Q.zero(Residual)`	→	`None`
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 · ask → True 0.011 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(Abs(x)), ~Q.zero(x))
Residual = pi / Abs(x) - Abs(pi / x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`pi / Abs(x) - Abs(pi / x)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(cos(x)), ~Q.zero(1 / cos(x)))
Residual = Abs(log(cos(x))) - log(1 / cos(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(log(cos(x))) - log(1 / cos(x))`	→	`-log(1/cos(x)) + Abs(log(cos(x)))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(cosh(x)))
Residual = Abs(log(cosh(x))) - log(cosh(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(log(cosh(x))) - log(cosh(x))`	→	`-log(cosh(x)) + Abs(log(cosh(x)))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(sin(x)))
Residual = Abs(log(sin(x))) - (-log(sin(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(log(sin(x))) - (-log(sin(x)))`	→	`log(sin(x)) + Abs(log(sin(x)))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(cosh(x)), ~Q.zero(tanh(x)))
Residual = Abs(log(tanh(x))) - (-log(tanh(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(log(tanh(x))) - (-log(tanh(x)))`	→	`log(tanh(x)) + Abs(log(tanh(x)))`
ask	`Q.zero(Residual)`	→	`None`
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) · ask → None 0.136 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Or(~Q.zero(x), re(pi) > 0))
Residual = Abs(Pow(x, pi)) - Pow(x, pi)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(Pow(x, pi)) - Pow(x, pi)`	→	`-xpi + Abs(xpi)`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(cosh(asinh(x))), ~Q.zero(x), Ne(1 / x, I, evaluate=False), Ne(1 / x, -I, evaluate=False))
Residual = Abs(tanh(asinh(x))) - cos(atan(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(tanh(asinh(x))) - cos(atan(1 / x))`	→	`Abs(x)/Abs(sqrt(x2 + 1)) - 1/sqrt(1 + x(-2))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x))
Residual = acos(cos(asin(x))) - Abs(asin(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`acos(cos(asin(x))) - Abs(asin(x))`	→	`-Abs(asin(x)) + acos(sqrt(1 - x**2))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x))
Residual = acos(cos(cos(x))) - Abs(cos(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`acos(cos(cos(x))) - Abs(cos(x))`	→	`-Abs(cos(x)) + acos(cos(cos(x)))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x))
Residual = acos(cos(sin(x))) - Abs(sin(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`acos(cos(sin(x))) - Abs(sin(x))`	→	`-Abs(sin(x)) + acos(cos(sin(x)))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Ne(x, I, evaluate=False), Ne(x, -I, evaluate=False), ~Q.zero(x), Ne(1 / x, I, evaluate=False), Ne(1 / x, -I, evaluate=False))
Residual = asin(cos(atan(x))) - Abs(atan(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`asin(cos(atan(x))) - Abs(atan(1 / x))`	→	`-Abs(atan(1/x)) + asin(1/sqrt(x**2 + 1))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 0.044 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(cosh(x)))
Residual = asin(tanh(Abs(x))) - acos(1 / cosh(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`asin(tanh(Abs(x))) - acos(1 / cosh(x))`	→	`-acos(1/cosh(x)) + asin(tanh(Abs(x)))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(cosh(x)))
Residual = atan(Abs(sinh(x))) - acos(1 / cosh(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atan(Abs(sinh(x))) - acos(1 / cosh(x))`	→	`-acos(1/cosh(x)) + atan(Abs(sinh(x)))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(cos(x)))
Residual = atan(Abs(tan(x))) - Abs(asin(sin(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atan(Abs(tan(x))) - Abs(asin(sin(x)))`	→	`-Abs(asin(sin(x))) + atan(Abs(tan(x)))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Ne(sinh(acosh(x)), I, evaluate=False), Ne(sinh(acosh(x)), -I, evaluate=False), ~Q.zero(cosh(acosh(x))))
Residual = atan(sinh(acosh(x))) - asin(tanh(acosh(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, 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))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(x), Ne(sinh(log(x)), I, evaluate=False), Ne(sinh(log(x)), -I, evaluate=False), ~Q.zero(cosh(log(x))))
Residual = atan(sinh(log(x))) - asin(tanh(log(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atan(sinh(log(x))) - asin(tanh(log(x)))`	→	`-asin(tanh(log(x))) + atan(sinh(log(x)))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Ne(cos(asin(x)), 1, evaluate=False), Ne(cos(asin(x)), -1, evaluate=False), ~Q.zero(x))
Residual = atanh(cos(asin(x))) - acosh(Abs(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atanh(cos(asin(x))) - acosh(Abs(1 / x))`	→	`-acosh(1/Abs(x)) + atanh(sqrt(1 - x**2))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Ne(x, I, evaluate=False), Ne(x, -I, evaluate=False), Ne(cos(atan(x)), 1, evaluate=False), Ne(cos(atan(x)), -1, evaluate=False), ~Q.zero(x))
Residual = atanh(cos(atan(x))) - Abs(asinh(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atanh(cos(atan(x))) - Abs(asinh(1 / x))`	→	`-Abs(asinh(1/x)) + atanh(1/sqrt(x**2 + 1))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Ne(sin(acos(x)), 1, evaluate=False), Ne(sin(acos(x)), -1, evaluate=False), ~Q.zero(x))
Residual = atanh(sin(acos(x))) - acosh(Abs(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atanh(sin(acos(x))) - acosh(Abs(1 / x))`	→	`-acosh(1/Abs(x)) + atanh(sqrt(1 - x**2))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x))
Residual = sinh(Abs(x)) - Abs(sinh(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`sinh(Abs(x)) - Abs(sinh(x))`	→	`sinh(Abs(x)) - Abs(sinh(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(x), ~Q.zero(1 / x))
Residual = cos(log(1 / x)) - cos(log(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`cos(log(1 / x)) - cos(log(x))`	→	`cos(log(1/x)) - cos(log(x))`
ask	`Q.zero(Residual)`	→	`None`
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 · ask → True 0.011 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(x), ~Q.zero(-10 / x))
Residual = 1 / (-10 / x) - (x / -10)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`1 / (-10 / x) - (x / -10)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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 · ask → True 0.011 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(x), ~Q.zero(-4 / x))
Residual = 1 / (-4 / x) - (x / -4)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`1 / (-4 / x) - (x / -4)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(cosh(x)))
Residual = tanh(Abs(x)) - Abs(tanh(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`tanh(Abs(x)) - Abs(tanh(x))`	→	`tanh(Abs(x)) - Abs(tanh(x))`
ask	`Q.zero(Residual)`	→	`None`
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) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(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))
Residual = 1 / Pow(x, x) - Pow(1 / x, x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`1 / Pow(x, x) - Pow(1 / x, x)`	→	`-(1/x)x + x(-x)`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x))
Residual = -Abs(sinh(x)) - sinh(-Abs(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-Abs(sinh(x)) - sinh(-Abs(x))`	→	`sinh(Abs(x)) - Abs(sinh(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(cosh(x)))
Residual = -Abs(tanh(x)) - tanh(-Abs(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-Abs(tanh(x)) - tanh(-Abs(x))`	→	`tanh(Abs(x)) - Abs(tanh(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(cos(x)), ~Q.zero(1 / cos(x)))
Residual = -log(cos(x)) - log(1 / cos(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-log(cos(x)) - log(1 / cos(x))`	→	`-log(1/cos(x)) - log(cos(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(cosh(x)), ~Q.zero(1 / cosh(x)))
Residual = -log(cosh(x)) - log(1 / cosh(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-log(cosh(x)) - log(1 / cosh(x))`	→	`-log(1/cosh(x)) - log(cosh(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(x), ~Q.zero(1 / x))
Residual = -sin(log(x)) - sin(log(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-sin(log(x)) - sin(log(1 / x))`	→	`-sin(log(1/x)) - sin(log(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(x), ~Q.zero(cos(log(x))), ~Q.zero(1 / x), ~Q.zero(cos(log(1 / x))))
Residual = -tan(log(x)) - tan(log(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-tan(log(x)) - tan(log(1 / x))`	→	`-tan(log(1/x)) - tan(log(x))`
ask	`Q.zero(Residual)`	→	`None`
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 · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(Abs(x)), ~Q.zero(x))
Residual = Pow(Abs(x), -2) - Pow(x, -2)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(Abs(x), -2) - Pow(x, -2)`	→	`Abs(x)(-2) - 1/x2`
ask	`Q.zero(Residual)`	→	`None`
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 · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(Abs(x)), ~Q.zero(x))
Residual = Pow(Abs(x), -6) - Pow(x, -6)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(Abs(x), -6) - Pow(x, -6)`	→	`Abs(x)(-6) - 1/x6`
ask	`Q.zero(Residual)`	→	`None`
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 · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x))
Residual = Pow(Abs(x), 2) - (x * x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(Abs(x), 2) - (x * x)`	→	`-x2 + Abs(x)2`
ask	`Q.zero(Residual)`	→	`None`
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) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x))
Residual = Pow(Abs(x), 3) - Abs(Pow(x, 3))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(Abs(x), 3) - Abs(Pow(x, 3))`	→	`Abs(x)3 - Abs(x3)`
ask	`Q.zero(Residual)`	→	`None`
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) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x))
Residual = Pow(Abs(x), 7) - Abs(Pow(x, 7))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(Abs(x), 7) - Abs(Pow(x, 7))`	→	`Abs(x)7 - Abs(x7)`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

sp-acj4-30-complex true simplipy-complex-branch solved Q.complex(x) ⊢ Eq((4*Abs(x)), Abs(((-4)*x))) true difference → 0 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x))
Residual = 4 * Abs(x) - Abs(-4 * x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`4 * Abs(x) - Abs(-4 * x)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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) · ask → None 0.134 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Or(~Q.zero(exp(x)), re(exp(1)) > 0))
Residual = Pow(exp(x), exp(1)) - exp(exp(1) * x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(exp(x), exp(1)) - exp(exp(1) * x)`	→	`exp(x)*E - exp(Ex)`
ask	`Q.zero(Residual)`	→	`None`
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) · ask → None 0.134 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Or(~Q.zero(exp(x)), re(pi) > 0))
Residual = Pow(exp(x), pi) - exp(pi * x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(exp(x), pi) - exp(pi * x)`	→	`exp(x)*pi - exp(pix)`
ask	`Q.zero(Residual)`	→	`None`
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) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Or(~Q.zero(exp(x)), re(x) > 0))
Residual = Pow(exp(x), x) - exp(x * x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(exp(x), x) - exp(x * x)`	→	`exp(x)x - exp(x2)`
ask	`Q.zero(Residual)`	→	`None`
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 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x))
Residual = Pow(1 / pi, x) - Pow(pi, -x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(1 / pi, x) - Pow(pi, -x)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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 · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(x), Or(~Q.zero(1 / x), re(x) > 0), Or(~Q.zero(x), re(-x) > 0))
Residual = Pow(1 / x, x) - Pow(x, -x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(1 / x, x) - Pow(x, -x)`	→	`(1/x)x - 1/xx`
ask	`Q.zero(Residual)`	→	`None`
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… · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.real(acos(x)), ~Q.zero(acos(x)))
Residual = real_root(acos(x), -5) - Pow(acos(x), Rational(-1, 5))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, 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)`
ask	`Q.zero(Residual)`	→	`None`
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)… · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.real(acos(x)))
Residual = real_root(acos(x), 5) - Pow(acos(x), Rational(1, 5))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, 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)`
ask	`Q.zero(Residual)`	→	`None`
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), … · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.real(acosh(x)), ~Q.zero(acosh(x)))
Residual = real_root(acosh(x), -5) - Pow(acosh(x), Rational(-1, 5))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, 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)`
ask	`Q.zero(Residual)`	→	`None`
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… · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.real(acosh(x)))
Residual = real_root(acosh(x), 5) - Pow(acosh(x), Rational(1, 5))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, 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)`
ask	`Q.zero(Residual)`	→	`None`
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)**(… · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.real(cosh(x)), ~Q.zero(cosh(x)))
Residual = real_root(cosh(x), -5) - Pow(cosh(x), Rational(-1, 5))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, 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)`
ask	`Q.zero(Residual)`	→	`None`
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)**(… · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.real(cosh(x)))
Residual = real_root(cosh(x), 5) - Pow(cosh(x), Rational(1, 5))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, 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)`
ask	`Q.zero(Residual)`	→	`None`
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… · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.real(exp(x)))
Residual = real_root(exp(x), 5) - exp(x / 5)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, 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)`
ask	`Q.zero(Residual)`	→	`None`
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… · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.real(exp(x)))
Residual = real_root(exp(x), 7) - exp(x / 7)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, 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)`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x))
Residual = sin(Abs(sin(x))) - Abs(sin(sin(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`sin(Abs(sin(x))) - Abs(sin(sin(x)))`	→	`sin(Abs(sin(x))) - Abs(sin(sin(x)))`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

sp-acj4-40-complex true simplipy-complex-branch solved Q.complex(x) ⊢ Eq((Abs(x)*pi), Abs((pi*x))) true difference → 0 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x))
Residual = Abs(x) * pi - Abs(pi * x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(x) * pi - Abs(pi * x)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(x), ~Q.zero(1 / x))
Residual = sin(-log(x)) - sin(log(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`sin(-log(x)) - sin(log(1 / x))`	→	`-sin(log(1/x)) - sin(log(x))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(cosh(x)))
Residual = sin(tanh(Abs(x))) - Abs(sin(tanh(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`sin(tanh(Abs(x))) - Abs(sin(tanh(x)))`	→	`sin(tanh(Abs(x))) - Abs(sin(tanh(x)))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(cos(Abs(sin(x)))), ~Q.zero(cos(sin(x))))
Residual = tan(Abs(sin(x))) - Abs(tan(sin(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`tan(Abs(sin(x))) - Abs(tan(sin(x)))`	→	`tan(Abs(sin(x))) - Abs(tan(sin(x)))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(cosh(x)), ~Q.zero(cos(Abs(tanh(x)))), ~Q.zero(cos(tanh(x))))
Residual = tan(Abs(tanh(x))) - Abs(tan(tanh(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`tan(Abs(tanh(x))) - Abs(tan(tanh(x)))`	→	`tan(Abs(tanh(x))) - Abs(tan(tanh(x)))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 0.039 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(x), ~Q.zero(cos(-log(x))), ~Q.zero(1 / x), ~Q.zero(cos(log(1 / x))))
Residual = tan(-log(x)) - tan(log(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`tan(-log(x)) - tan(log(1 / x))`	→	`-tan(log(1/x)) - tan(log(x))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(cos(tanh(Abs(x)))), ~Q.zero(cosh(x)), ~Q.zero(cos(tanh(x))))
Residual = tan(tanh(Abs(x))) - Abs(tan(tanh(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`tan(tanh(Abs(x))) - Abs(tan(tanh(x)))`	→	`tan(tanh(Abs(x))) - Abs(tan(tanh(x)))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(x), Ne(1 / x, I, evaluate=False), Ne(1 / x, -I, evaluate=False))
Residual = tanh(Abs(asinh(x))) - cos(atan(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`tanh(Abs(asinh(x))) - cos(atan(1 / x))`	→	`tanh(Abs(asinh(x))) - 1/sqrt(1 + x**(-2))`
ask	`Q.zero(Residual)`	→	`None`
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) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(cosh(acosh(Abs(x)))), ~Q.zero(x))
Residual = tanh(acosh(Abs(x))) - cos(asin(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, 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)`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(x), Ne(1 / x, I, evaluate=False), Ne(1 / x, -I, evaluate=False))
Residual = tanh(asinh(Abs(x))) - cos(atan(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`tanh(asinh(Abs(x))) - cos(atan(1 / x))`	→	`Abs(x)/sqrt(Abs(x)2 + 1) - 1/sqrt(1 + x(-2))`
ask	`Q.zero(Residual)`	→	`None`
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) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(x), Or(~Q.zero(x), re(x) > 0), ~Q.zero(Pow(x, x)))
Residual = log(x) * x - log(Pow(x, x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`log(x) * x - log(Pow(x, x))`	→	`xlog(x) - log(x*x)`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(x), Ne(-log(x), I, evaluate=False), Ne(-log(x), -I, evaluate=False), ~Q.zero(1 / x), Ne(log(1 / x), I, evaluate=False), Ne(log(1 / x), -I, evaluate=False))
Residual = atan(-log(x)) - atan(log(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atan(-log(x)) - atan(log(1 / x))`	→	`-atan(log(1/x)) - atan(log(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 0.039 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(x), ~Q.zero(log(x)), ~Q.zero(1 / log(x)))
Residual = -log(log(x)) - log(1 / log(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-log(log(x)) - log(1 / log(x))`	→	`-log(1/log(x)) - log(log(x))`
ask	`Q.zero(Residual)`	→	`None`
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) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Ne(x, I, evaluate=False), Ne(x, -I, evaluate=False), ~Q.zero(cos(Abs(atan(x)))))
Residual = tan(Abs(atan(x))) - Abs(x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`tan(Abs(atan(x))) - Abs(x)`	→	`tan(Abs(atan(x))) - Abs(x)`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

sp-acj4-450-complex true simplipy-complex-branch solved Q.complex(x) ∧ (~Q.zero(x)) ⊢ Eq((x/x), 1) true difference → 0 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(x))
Residual = x / x - 1
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`x / x - 1`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-451-complex true simplipy-complex-branch solved Q.complex(x) ∧ (~Q.zero(x)) ⊢ Eq((0/x), 0) true difference → 0 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(x))
Residual = 0 / x - 0
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`0 / x - 0`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(Pow(6, x)))
Residual = log(6) * x - log(Pow(6, x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`log(6) * x - log(Pow(6, x))`	→	`xlog(6) - log(6*x)`
ask	`Q.zero(Residual)`	→	`None`
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) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(Pow(7, x)))
Residual = log(7) * x - log(Pow(7, x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`log(7) * x - log(Pow(7, x))`	→	`xlog(7) - log(7*x)`
ask	`Q.zero(Residual)`	→	`None`
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) · ask → None 0.141 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(x), Or(~Q.zero(x), re(exp(1)) > 0), ~Q.zero(Pow(x, exp(1))))
Residual = log(x) * exp(1) - log(Pow(x, exp(1)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`log(x) * exp(1) - log(Pow(x, exp(1)))`	→	`Elog(x) - log(x*E)`
ask	`Q.zero(Residual)`	→	`None`
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) · ask → None 0.14 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(x), Or(~Q.zero(x), re(pi) > 0), ~Q.zero(Pow(x, pi)))
Residual = log(x) * pi - log(Pow(x, pi))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`log(x) * pi - log(Pow(x, pi))`	→	`pilog(x) - log(x*pi)`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(cosh(x)), Ne(tanh(x), 1, evaluate=False), Ne(tanh(x), -1, evaluate=False))
Residual = atanh(tanh(x)) - x
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atanh(tanh(x)) - x`	→	`-x + atanh(tanh(x))`
ask	`Q.zero(Residual)`	→	`None`
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 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(Abs(x)), ~Q.zero(x))
Residual = 1 / Abs(x) - Abs(1 / x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`1 / Abs(x) - Abs(1 / x)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(exp(x)))
Residual = log(exp(x)) - x
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`log(exp(x)) - x`	→	`-x + log(exp(x))`
ask	`Q.zero(Residual)`	→	`None`
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 · ask → True 0.011 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(Abs(x)), ~Q.zero(x))
Residual = 3 / Abs(x) - Abs(-3 / x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`3 / Abs(x) - Abs(-3 / x)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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 · ask → True 0.011 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), ~Q.zero(Abs(x)), ~Q.zero(x))
Residual = 7 / Abs(x) - Abs(-7 / x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`7 / Abs(x) - Abs(-7 / x)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-99-complex true simplipy-complex-branch solved Q.complex(x) ⊢ Eq((Abs(x)/3), Abs((x/(-3)))) true difference → 0 · ask → True 0.011 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x))
Residual = Abs(x) / 3 - Abs(x / -3)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(x) / 3 - Abs(x / -3)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Abs(x) <= 1)
Residual = asin(Abs(x)) - Abs(asin(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`asin(Abs(x)) - Abs(asin(x))`	→	`-Abs(asin(x)) + asin(Abs(x))`
ask	`Q.zero(Residual)`	→	`None`
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 · ask → None 0.039 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.imaginary(x), ~Q.zero(x), ~Q.zero(Abs(x)))
Residual = Abs(x) / x - (x / Abs(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(x) / x - (x / Abs(x))`	→	`-x/Abs(x) + Abs(x)/x`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.imaginary(x), ~Q.zero(cosh(x)))
Residual = Abs(asin(tanh(x))) - acos(1 / cosh(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(asin(tanh(x))) - acos(1 / cosh(x))`	→	`Abs(asin(tanh(x))) - acos(1/cosh(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), re(x) >= 0, Ne(exp(x), 1, evaluate=False), Ne(exp(x), -1, evaluate=False))
Residual = Abs(atanh(exp(x))) - atanh(exp(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(atanh(exp(x))) - atanh(exp(x))`	→	`Abs(atanh(exp(x))) - atanh(exp(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Abs(x) <= 1)
Residual = Abs(cos(asin(x))) - cos(asin(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(cos(asin(x))) - cos(asin(x))`	→	`-sqrt(1 - x2) + Abs(sqrt(1 - x2))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), x > 1)
Residual = Abs(cos(asin(x))) - cos(asin(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(cos(asin(x))) - cos(asin(x))`	→	`-sqrt(1 - x2) + Abs(sqrt(1 - x2))`
ask	`Q.zero(Residual)`	→	`None`
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) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.imaginary(x), Ne(x, I, evaluate=False), Ne(x, -I, evaluate=False))
Residual = Abs(cos(atan(x))) - cos(atan(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(cos(atan(x))) - cos(atan(x))`	→	`1/Abs(sqrt(x2 + 1)) - 1/sqrt(x2 + 1)`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Abs(x) < pi / 2, ~Q.zero(cos(x)), ~Q.zero(1 / cos(x)))
Residual = Abs(log(cos(x))) - log(1 / cos(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(log(cos(x))) - log(1 / cos(x))`	→	`-log(1/cos(x)) + Abs(log(cos(x)))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.imaginary(x), ~Q.zero(cosh(x)))
Residual = Abs(log(cosh(x))) - log(cosh(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(log(cosh(x))) - log(cosh(x))`	→	`-log(cosh(x)) + Abs(log(cosh(x)))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), x >= 0, x <= pi, ~Q.zero(sin(x)))
Residual = Abs(log(sin(x))) - (-log(sin(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(log(sin(x))) - (-log(sin(x)))`	→	`log(sin(x)) + Abs(log(sin(x)))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.imaginary(x), ~Q.zero(cosh(x)), ~Q.zero(tanh(x)))
Residual = Abs(log(tanh(x))) - (-log(tanh(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(log(tanh(x))) - (-log(tanh(x)))`	→	`log(tanh(x)) + Abs(log(tanh(x)))`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

sp-acj4-136-cond true simplipy-conditional no verdict Q.real(x) ∧ Q.nonnegative(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) · ask → None 0.158 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Q.nonnegative(x), Or(~Q.zero(x), re(exp(1)) > 0))
Residual = Abs(Pow(x, exp(1))) - Pow(x, exp(1))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(Pow(x, exp(1))) - Pow(x, exp(1))`	→	`-xE + Abs(xE)`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

sp-acj4-137-cond true simplipy-conditional no verdict Q.real(x) ∧ Q.nonnegative(x) ∧ Or((~Q.zero(x)), (re(pi) > 0)) ⊢ Eq(Abs(Pow(x, pi)), Pow(x, pi)) null difference → -x**pi + Abs(x**pi) · ask → None 0.145 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Q.nonnegative(x), Or(~Q.zero(x), re(pi) > 0))
Residual = Abs(Pow(x, pi)) - Pow(x, pi)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(Pow(x, pi)) - Pow(x, pi)`	→	`-xpi + Abs(xpi)`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Abs(x) <= 1)
Residual = Abs(sin(acos(x))) - cos(asin(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(sin(acos(x))) - cos(asin(x))`	→	`-sqrt(1 - x2) + Abs(sqrt(1 - x2))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), x > 1)
Residual = Abs(sin(acos(x))) - cos(asin(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(sin(acos(x))) - cos(asin(x))`	→	`-sqrt(1 - x2) + Abs(sqrt(1 - x2))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.imaginary(x), ~Q.zero(cosh(asinh(x))), ~Q.zero(x), Ne(1 / x, I, evaluate=False), Ne(1 / x, -I, evaluate=False))
Residual = Abs(tanh(asinh(x))) - cos(atan(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(tanh(asinh(x))) - cos(atan(1 / x))`	→	`Abs(x)/Abs(sqrt(x2 + 1)) - 1/sqrt(1 + x(-2))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Abs(x) <= 1)
Residual = acos(cos(asin(x))) - Abs(asin(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`acos(cos(asin(x))) - Abs(asin(x))`	→	`-Abs(asin(x)) + acos(sqrt(1 - x**2))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Abs(x) <= 1)
Residual = acos(sin(acos(x))) - Abs(asin(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`acos(sin(acos(x))) - Abs(asin(x))`	→	`-Abs(asin(x)) + acos(sqrt(1 - x**2))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 0.044 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), x <= 1, ~Q.zero(cosh(x)))
Residual = acos(tanh(Abs(x))) - asin(1 / cosh(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`acos(tanh(Abs(x))) - asin(1 / cosh(x))`	→	`acos(tanh(Abs(x))) - asin(1/cosh(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Abs(x) <= pi / 2, ~Q.zero(cosh(x)))
Residual = acos(tanh(Abs(x))) - asin(1 / cosh(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`acos(tanh(Abs(x))) - asin(1 / cosh(x))`	→	`acos(tanh(Abs(x))) - asin(1/cosh(x))`
ask	`Q.zero(Residual)`	→	`None`
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(Piecewise((Abs(x)**(1/5)*sign(x), Eq(im(x), 0)), (x**(1/5), True… · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), re(x) >= 0, Q.real(x))
Residual = acosh(real_root(x, 5)) - acosh(Pow(x, Rational(1, 5)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`acosh(real_root(x, 5)) - acosh(Pow(x, Rational(1, 5)))`	→	`-acosh(x(1/5)) + acosh(Piecewise((Abs(x)(1/5)sign(x), Eq(im(x), 0)), (x*(1/5), True)))`
ask	`Q.zero(Residual)`	→	`None`
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(Abs(x)**(1/5)*sign(x)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Q.negative(x))
Residual = acosh(real_root(x, 5)) - acosh(Pow(x, Rational(1, 5)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, 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))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Abs(im(x)) < pi, ~Q.zero(cosh(x)))
Residual = asin(sin(tanh(x))) - tanh(x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`asin(sin(tanh(x))) - tanh(x)`	→	`-tanh(x) + asin(sin(tanh(x)))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.imaginary(x), ~Q.zero(cosh(x)))
Residual = asin(sin(tanh(x))) - tanh(x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`asin(sin(tanh(x))) - tanh(x)`	→	`-tanh(x) + asin(sin(tanh(x)))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Abs(x) <= pi / 2, Ne(sinh(acos(x)), I, evaluate=False), Ne(sinh(acos(x)), -I, evaluate=False), ~Q.zero(cosh(acos(x))))
Residual = atan(sinh(acos(x))) - asin(tanh(acos(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atan(sinh(acos(x))) - asin(tanh(acos(x)))`	→	`-asin(tanh(acos(x))) + atan(sinh(acos(x)))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), re(x) >= 0, Ne(sinh(acosh(x)), I, evaluate=False), Ne(sinh(acosh(x)), -I, evaluate=False), ~Q.zero(cosh(acosh(x))))
Residual = atan(sinh(acosh(x))) - asin(tanh(acosh(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, 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))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Abs(x) <= pi / 2, Ne(sinh(asin(x)), I, evaluate=False), Ne(sinh(asin(x)), -I, evaluate=False), ~Q.zero(cosh(asin(x))))
Residual = atan(sinh(asin(x))) - asin(tanh(asin(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atan(sinh(asin(x))) - asin(tanh(asin(x)))`	→	`-asin(tanh(asin(x))) + atan(sinh(asin(x)))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), re(x) >= 0, ~Q.zero(x), Ne(sinh(log(x)), I, evaluate=False), Ne(sinh(log(x)), -I, evaluate=False), ~Q.zero(cosh(log(x))))
Residual = atan(sinh(log(x))) - asin(tanh(log(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atan(sinh(log(x))) - asin(tanh(log(x)))`	→	`-asin(tanh(log(x))) + atan(sinh(log(x)))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.imaginary(x), ~Q.zero(cos(sin(x))), Ne(tan(sin(x)), I, evaluate=False), Ne(tan(sin(x)), -I, evaluate=False))
Residual = atan(tan(sin(x))) - sin(x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atan(tan(sin(x))) - sin(x)`	→	`-sin(x) + atan(tan(sin(x)))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.imaginary(x), ~Q.zero(cosh(x)), ~Q.zero(cos(tanh(x))), Ne(tan(tanh(x)), I, evaluate=False), Ne(tan(tanh(x)), -I, evaluate=False))
Residual = atan(tan(tanh(x))) - tanh(x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atan(tan(tanh(x))) - tanh(x)`	→	`-tanh(x) + atan(tan(tanh(x)))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.imaginary(x), Ne(x, I, evaluate=False), Ne(x, -I, evaluate=False), Ne(cos(atan(x)), 1, evaluate=False), Ne(cos(atan(x)), -1, evaluate=False), ~Q.zero(x))
Residual = atanh(cos(atan(x))) - Abs(asinh(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atanh(cos(atan(x))) - Abs(asinh(1 / x))`	→	`-Abs(asinh(1/x)) + atanh(1/sqrt(x**2 + 1))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.imaginary(x), Ne(sin(acos(x)), 1, evaluate=False), Ne(sin(acos(x)), -1, evaluate=False), ~Q.zero(x))
Residual = atanh(sin(acos(x))) - acosh(Abs(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atanh(sin(acos(x))) - acosh(Abs(1 / x))`	→	`-acosh(1/Abs(x)) + atanh(sqrt(1 - x**2))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.imaginary(x), ~Q.zero(cosh(x)), Ne(sin(tanh(x)), 1, evaluate=False), Ne(sin(tanh(x)), -1, evaluate=False), ~Q.zero(cos(tanh(x))))
Residual = atanh(sin(tanh(x))) - asinh(tan(tanh(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atanh(sin(tanh(x))) - asinh(tan(tanh(x)))`	→	`-asinh(tan(tanh(x))) + atanh(sin(tanh(x)))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.imaginary(x))
Residual = sinh(Abs(x)) - Abs(sinh(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`sinh(Abs(x)) - Abs(sinh(x))`	→	`sinh(Abs(x)) - Abs(sinh(x))`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

sp-acj4-200-cond true simplipy-conditional no verdict Q.complex(x) ∧ Q.imaginary(x) ⊢ Eq(cos(asin(sin(x))), Abs(cos(x))) null difference → sqrt(1 - sin(x)**2) - Abs(cos(x)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.imaginary(x))
Residual = cos(asin(sin(x))) - Abs(cos(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`cos(asin(sin(x))) - Abs(cos(x))`	→	`sqrt(1 - sin(x)**2) - Abs(cos(x))`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

sp-acj4-202-cond true simplipy-conditional no verdict 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))) null difference → -Abs(cos(x)) + 1/sqrt(tan(x)**2 + 1) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.imaginary(x), ~Q.zero(cos(x)), Ne(tan(x), I, evaluate=False), Ne(tan(x), -I, evaluate=False))
Residual = cos(atan(tan(x))) - Abs(cos(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`cos(atan(tan(x))) - Abs(cos(x))`	→	`-Abs(cos(x)) + 1/sqrt(tan(x)**2 + 1)`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), re(x) >= 0, ~Q.zero(x), ~Q.zero(1 / x))
Residual = cos(log(1 / x)) - cos(log(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`cos(log(1 / x)) - cos(log(x))`	→	`cos(log(1/x)) - cos(log(x))`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

sp-acj4-205-cond true simplipy-conditional no verdict Q.complex(x) ∧ Q.imaginary(x) ∧ (~Q.zero(cos(x))) ⊢ Eq(cosh(asinh(tan(x))), Abs((1/cos(x)))) null difference → sqrt(tan(x)**2 + 1) - 1/Abs(cos(x)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.imaginary(x), ~Q.zero(cos(x)))
Residual = cosh(asinh(tan(x))) - Abs(1 / cos(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`cosh(asinh(tan(x))) - Abs(1 / cos(x))`	→	`sqrt(tan(x)**2 + 1) - 1/Abs(cos(x))`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

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) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(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))
Residual = 1 / Pow(x, x) - Pow(1 / x, x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`1 / Pow(x, x) - Pow(1 / x, x)`	→	`-(1/x)x + x(-x)`
ask	`Q.zero(Residual)`	→	`None`
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 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(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))
Residual = 1 / Pow(x, x) - Pow(1 / x, x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`1 / Pow(x, x) - Pow(1 / x, x)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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(Piecewise((Abs(x)**(1/5)*sign(x), Eq(im(x), 0)), (x**(1/5), True))) · ask → None 0.041 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), re(x) > 0, Q.real(x), ~Q.zero(real_root(x, 5)), ~Q.zero(x))
Residual = log(real_root(x, 5)) - (log(x) / 5)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`log(real_root(x, 5)) - (log(x) / 5)`	→	`-log(x)/5 + log(Piecewise((Abs(x)*(1/5)sign(x), Eq(im(x), 0)), (x**(1/5), True)))`
ask	`Q.zero(Residual)`	→	`None`
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(Piecewise((Abs(x)**(1/7)*sign(x), Eq(im(x), 0)), (x**(1/7), True))) · ask → None 0.041 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), re(x) > 0, Q.real(x), ~Q.zero(real_root(x, 7)), ~Q.zero(x))
Residual = log(real_root(x, 7)) - (log(x) / 7)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`log(real_root(x, 7)) - (log(x) / 7)`	→	`-log(x)/7 + log(Piecewise((Abs(x)*(1/7)sign(x), Eq(im(x), 0)), (x**(1/7), True)))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Abs(x) <= 1)
Residual = -Abs(asin(x)) - asin(-Abs(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-Abs(asin(x)) - asin(-Abs(x))`	→	`-Abs(asin(x)) + asin(Abs(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 0.039 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Abs(x) < 1, Ne(x, 1, evaluate=False), Ne(x, -1, evaluate=False), Ne(-Abs(x), 1, evaluate=False), Ne(-Abs(x), -1, evaluate=False))
Residual = -Abs(atanh(x)) - atanh(-Abs(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-Abs(atanh(x)) - atanh(-Abs(x))`	→	`-Abs(atanh(x)) + atanh(Abs(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Abs(re(x)) < pi / 2, ~Q.zero(cos(x)), ~Q.zero(1 / cos(x)))
Residual = -log(cos(x)) - log(1 / cos(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-log(cos(x)) - log(1 / cos(x))`	→	`-log(1/cos(x)) - log(cos(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), re(x) > 0, ~Q.zero(cosh(x)), ~Q.zero(1 / cosh(x)))
Residual = -log(cosh(x)) - log(1 / cosh(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-log(cosh(x)) - log(1 / cosh(x))`	→	`-log(1/cosh(x)) - log(cosh(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 0.039 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), re(x) >= 0, ~Q.zero(x), ~Q.zero(1 / x))
Residual = -sin(log(x)) - sin(log(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-sin(log(x)) - sin(log(1 / x))`	→	`-sin(log(1/x)) - sin(log(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Q.negative(x), ~Q.zero(x), ~Q.zero(1 / x))
Residual = -sin(log(x)) - sin(log(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-sin(log(x)) - sin(log(1 / x))`	→	`-sin(log(1/x)) - sin(log(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 0.041 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), re(x) >= 0, ~Q.zero(x), ~Q.zero(cos(log(x))), ~Q.zero(1 / x), ~Q.zero(cos(log(1 / x))))
Residual = -tan(log(x)) - tan(log(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-tan(log(x)) - tan(log(1 / x))`	→	`-tan(log(1/x)) - tan(log(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Q.negative(x), ~Q.zero(x), ~Q.zero(cos(log(x))), ~Q.zero(1 / x), ~Q.zero(cos(log(1 / x))))
Residual = -tan(log(x)) - tan(log(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-tan(log(x)) - tan(log(1 / x))`	→	`-tan(log(1/x)) - tan(log(x))`
ask	`Q.zero(Residual)`	→	`None`
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 · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.imaginary(x))
Residual = Pow(Abs(x), 2) - (x * x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(Abs(x), 2) - (x * x)`	→	`-x2 + Abs(x)2`
ask	`Q.zero(Residual)`	→	`None`
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 · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.imaginary(x))
Residual = Pow(Abs(x), 6) - Pow(x, 6)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(Abs(x), 6) - Pow(x, 6)`	→	`-x6 + Abs(x)6`
ask	`Q.zero(Residual)`	→	`None`
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 · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.imaginary(x))
Residual = Pow(Abs(x), 8) - Pow(x, 8)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(Abs(x), 8) - Pow(x, 8)`	→	`-x8 + Abs(x)8`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

sp-acj4-29-cond true simplipy-conditional no verdict Q.real(x) ∧ Q.positive(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) · ask → None 0.041 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Q.positive(x), ~Q.zero(x), ~Q.zero(Pow(x, 3)))
Residual = 3 * log(x) - log(Pow(x, 3))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`3 * log(x) - log(Pow(x, 3))`	→	`3log(x) - log(x*3)`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

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) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.imaginary(x), ~Q.zero(x), ~Q.zero(Pow(x, 3)))
Residual = 3 * log(x) - log(Pow(x, 3))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`3 * log(x) - log(Pow(x, 3))`	→	`3log(x) - log(x*3)`
ask	`Q.zero(Residual)`	→	`None`
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) · ask → None 0.144 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), And(im(x) > -pi, im(x) <= pi), Or(~Q.zero(exp(x)), re(exp(1)) > 0))
Residual = Pow(exp(x), exp(1)) - exp(exp(1) * x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(exp(x), exp(1)) - exp(exp(1) * x)`	→	`exp(x)*E - exp(Ex)`
ask	`Q.zero(Residual)`	→	`None`
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) · ask → None 0.142 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), And(im(x) > -pi, im(x) <= pi), Or(~Q.zero(exp(x)), re(pi) > 0))
Residual = Pow(exp(x), pi) - exp(pi * x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(exp(x), pi) - exp(pi * x)`	→	`exp(x)*pi - exp(pix)`
ask	`Q.zero(Residual)`	→	`None`
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) · ask → None 0.044 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), And(im(x) > -pi, im(x) <= pi), Or(~Q.zero(exp(x)), re(x) > 0))
Residual = Pow(exp(x), x) - exp(x * x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(exp(x), x) - exp(x * x)`	→	`exp(x)x - exp(x2)`
ask	`Q.zero(Residual)`	→	`None`
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 · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), re(x) >= 0, ~Q.zero(x), Or(~Q.zero(1 / x), re(x) > 0), Or(~Q.zero(x), re(-x) > 0))
Residual = Pow(1 / x, x) - Pow(x, -x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(1 / x, x) - Pow(x, -x)`	→	`(1/x)x - 1/xx`
ask	`Q.zero(Residual)`	→	`None`
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 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.integer(x), ~Q.zero(x), Or(~Q.zero(1 / x), re(x) > 0), Or(~Q.zero(x), re(-x) > 0))
Residual = Pow(1 / x, x) - Pow(x, -x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(1 / x, x) - Pow(x, -x)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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)**(… · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), re(x) > 0, Q.real(cosh(x)), ~Q.zero(cosh(x)))
Residual = real_root(cosh(x), -5) - Pow(cosh(x), Rational(-1, 5))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, 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)`
ask	`Q.zero(Residual)`	→	`None`
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)**(… · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), re(x) > 0, Q.real(cosh(x)))
Residual = real_root(cosh(x), 5) - Pow(cosh(x), Rational(1, 5))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, 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)`
ask	`Q.zero(Residual)`	→	`None`
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… · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Abs(im(x)) < pi, Q.real(exp(x)), ~Q.zero(exp(x)))
Residual = real_root(exp(x), -3) - exp(x / -3)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, 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)`
ask	`Q.zero(Residual)`	→	`None`
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… · ask → None 0.044 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), re(x) > 0, Q.real(exp(x)))
Residual = real_root(exp(x), 3) - exp(x / 3)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, 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)`
ask	`Q.zero(Residual)`	→	`None`
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) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Abs(x) <= 1)
Residual = sin(Abs(asin(x))) - Abs(cos(acos(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`sin(Abs(asin(x))) - Abs(cos(acos(x)))`	→	`sin(Abs(asin(x))) - Abs(x)`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Abs(x) < 1, Ne(x, 1, evaluate=False), Ne(x, -1, evaluate=False))
Residual = sin(Abs(atanh(x))) - Abs(sin(atanh(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`sin(Abs(atanh(x))) - Abs(sin(atanh(x)))`	→	`sin(Abs(atanh(x))) - Abs(sin(atanh(x)))`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

sp-acj4-399-cond true simplipy-conditional no verdict Q.complex(x) ∧ Q.imaginary(x) ⊢ Eq(sin(acos(sin(x))), Abs(cos(x))) null difference → sqrt(1 - sin(x)**2) - Abs(cos(x)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.imaginary(x))
Residual = sin(acos(sin(x))) - Abs(cos(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`sin(acos(sin(x))) - Abs(cos(x))`	→	`sqrt(1 - sin(x)**2) - Abs(cos(x))`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Abs(x) < 1, Ne(Abs(x), 1, evaluate=False), Ne(x, 1, evaluate=False), Ne(x, -1, evaluate=False))
Residual = sin(atanh(Abs(x))) - Abs(sin(atanh(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`sin(atanh(Abs(x))) - Abs(sin(atanh(x)))`	→	`sin(atanh(Abs(x))) - Abs(sin(atanh(x)))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 0.039 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), re(x) >= 0, ~Q.zero(x), ~Q.zero(1 / x))
Residual = sin(-log(x)) - sin(log(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`sin(-log(x)) - sin(log(1 / x))`	→	`-sin(log(1/x)) - sin(log(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Q.negative(x), ~Q.zero(x), ~Q.zero(1 / x))
Residual = sin(-log(x)) - sin(log(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`sin(-log(x)) - sin(log(1 / x))`	→	`-sin(log(1/x)) - sin(log(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Abs(x) < 1, ~Q.zero(cos(Abs(asin(x)))), ~Q.zero(cos(asin(x))))
Residual = tan(Abs(asin(x))) - Abs(tan(asin(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`tan(Abs(asin(x))) - Abs(tan(asin(x)))`	→	`tan(Abs(asin(x))) - Abs(x)/Abs(sqrt(1 - x**2))`
ask	`Q.zero(Residual)`	→	`None`
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) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Abs(x) <= 1, ~Q.zero(cos(acos(Abs(x)))), ~Q.zero(cos(acos(x))))
Residual = tan(acos(Abs(x))) - Abs(tan(acos(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`tan(acos(Abs(x))) - Abs(tan(acos(x)))`	→	`sqrt(1 - x2)/Abs(x) - Abs(sqrt(1 - x2)/x)`
ask	`Q.zero(Residual)`	→	`None`
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) · ask → None 0.086 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Abs(x) < 1, ~Q.zero(cos(asin(Abs(x)))), ~Q.zero(cos(asin(x))))
Residual = tan(asin(Abs(x))) - Abs(tan(asin(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`tan(asin(Abs(x))) - Abs(tan(asin(x)))`	→	`-Abs(x)/Abs(sqrt(1 - x2)) + Abs(x)/sqrt(1 - x2)`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 0.041 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), re(x) >= 0, ~Q.zero(x), ~Q.zero(cos(-log(x))), ~Q.zero(1 / x), ~Q.zero(cos(log(1 / x))))
Residual = tan(-log(x)) - tan(log(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`tan(-log(x)) - tan(log(1 / x))`	→	`-tan(log(1/x)) - tan(log(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Q.negative(x), ~Q.zero(x), ~Q.zero(cos(-log(x))), ~Q.zero(1 / x), ~Q.zero(cos(log(1 / x))))
Residual = tan(-log(x)) - tan(log(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`tan(-log(x)) - tan(log(1 / x))`	→	`-tan(log(1/x)) - tan(log(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.imaginary(x), ~Q.zero(x), Ne(1 / x, I, evaluate=False), Ne(1 / x, -I, evaluate=False))
Residual = tanh(Abs(asinh(x))) - cos(atan(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`tanh(Abs(asinh(x))) - cos(atan(1 / x))`	→	`tanh(Abs(asinh(x))) - 1/sqrt(1 + x**(-2))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 0.067 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.imaginary(x), ~Q.zero(x), Ne(1 / x, I, evaluate=False), Ne(1 / x, -I, evaluate=False))
Residual = tanh(asinh(Abs(x))) - cos(atan(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`tanh(asinh(Abs(x))) - cos(atan(1 / x))`	→	`Abs(x)/sqrt(Abs(x)2 + 1) - 1/sqrt(1 + x(-2))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), x <= 1)
Residual = atan(sinh(x)) - asin(tanh(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atan(sinh(x)) - asin(tanh(x))`	→	`-asin(tanh(x)) + atan(sinh(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), x >= 0, x <= pi)
Residual = atan(sinh(x)) - asin(tanh(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atan(sinh(x)) - asin(tanh(x))`	→	`-asin(tanh(x)) + atan(sinh(x))`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

sp-acj4-430-cond true simplipy-conditional no verdict 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))) null difference → x*log(x) - log(x**x) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Q.positive(x), ~Q.zero(x), Or(~Q.zero(x), re(x) > 0), ~Q.zero(Pow(x, x)))
Residual = log(x) * x - log(Pow(x, x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`log(x) * x - log(Pow(x, x))`	→	`xlog(x) - log(x*x)`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

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) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Abs(x) < 1, ~Q.zero(x), Or(~Q.zero(x), re(x) > 0), ~Q.zero(Pow(x, x)))
Residual = log(x) * x - log(Pow(x, x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`log(x) * x - log(Pow(x, x))`	→	`xlog(x) - log(x*x)`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Abs(x) <= pi / 2, ~Q.zero(cosh(x)))
Residual = acos(Abs(tanh(x))) - asin(1 / cosh(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`acos(Abs(tanh(x))) - asin(1 / cosh(x))`	→	`acos(Abs(tanh(x))) - asin(1/cosh(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), re(x) >= 0, ~Q.zero(x), Ne(-log(x), I, evaluate=False), Ne(-log(x), -I, evaluate=False), ~Q.zero(1 / x), Ne(log(1 / x), I, evaluate=False), Ne(log(1 / x), -I, evaluate=False))
Residual = atan(-log(x)) - atan(log(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atan(-log(x)) - atan(log(1 / x))`	→	`-atan(log(1/x)) - atan(log(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Q.negative(x), ~Q.zero(x), Ne(-log(x), I, evaluate=False), Ne(-log(x), -I, evaluate=False), ~Q.zero(1 / x), Ne(log(1 / x), I, evaluate=False), Ne(log(1 / x), -I, evaluate=False))
Residual = atan(-log(x)) - atan(log(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atan(-log(x)) - atan(log(1 / x))`	→	`-atan(log(1/x)) - atan(log(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 0.039 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.imaginary(x), ~Q.zero(x), ~Q.zero(log(x)), ~Q.zero(1 / log(x)))
Residual = -log(log(x)) - log(1 / log(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-log(log(x)) - log(1 / log(x))`	→	`-log(1/log(x)) - log(log(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 0.039 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.integer(x), ~Q.zero(x), ~Q.zero(log(x)), ~Q.zero(1 / log(x)))
Residual = -log(log(x)) - log(1 / log(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-log(log(x)) - log(1 / log(x))`	→	`-log(1/log(x)) - log(log(x))`
ask	`Q.zero(Residual)`	→	`None`
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) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), And(im(x) > -pi, im(x) <= pi), ~Q.zero(Pow(2, x)))
Residual = log(2) * x - log(Pow(2, x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`log(2) * x - log(Pow(2, x))`	→	`xlog(2) - log(2*x)`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Abs(x) < 1, Ne(Abs(x), 1, evaluate=False), Ne(x, 1, evaluate=False), Ne(x, -1, evaluate=False))
Residual = atanh(Abs(x)) - Abs(atanh(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atanh(Abs(x)) - Abs(atanh(x))`	→	`-Abs(atanh(x)) + atanh(Abs(x))`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

sp-acj4-55-cond true simplipy-conditional no verdict 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)))) null difference → E*log(x) - log(x**E) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Q.positive(x), ~Q.zero(x), Or(~Q.zero(x), re(exp(1)) > 0), ~Q.zero(Pow(x, exp(1))))
Residual = log(x) * exp(1) - log(Pow(x, exp(1)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`log(x) * exp(1) - log(Pow(x, exp(1)))`	→	`Elog(x) - log(x*E)`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

sp-acj4-56-cond true simplipy-conditional no verdict 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))) null difference → pi*log(x) - log(x**pi) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Q.positive(x), ~Q.zero(x), Or(~Q.zero(x), re(pi) > 0), ~Q.zero(Pow(x, pi)))
Residual = log(x) * pi - log(Pow(x, pi))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`log(x) * pi - log(Pow(x, pi))`	→	`pilog(x) - log(x*pi)`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

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) · ask → None 0.141 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), Q.imaginary(x), ~Q.zero(x), Or(~Q.zero(x), re(pi) > 0), ~Q.zero(Pow(x, pi)))
Residual = log(x) * pi - log(Pow(x, pi))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`log(x) * pi - log(Pow(x, pi))`	→	`pilog(x) - log(x*pi)`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.complex(x), And(im(x) > -pi, im(x) <= pi), ~Q.zero(exp(x)))
Residual = log(exp(x)) - x
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`log(exp(x)) - x`	→	`-x + log(exp(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = acosh(cosh(x)) - Abs(x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`acosh(cosh(x)) - Abs(x)`	→	`-Abs(x) + acosh(cosh(x))`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

sp-acj4-115-real true simplipy-f64-edge no verdict Q.real(x) ∧ (~Q.zero(x)) ∧ (x > 0) ∧ (~Q.zero(real_root(x, (-4)))) ⊢ Eq((log(x)/(-4)), log(real_root(x, (-4)))) null difference → -log(x**(-1/4)) - log(x)/4 · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(x), x > 0, ~Q.zero(real_root(x, -4)))
Residual = log(x) / -4 - log(real_root(x, -4))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`log(x) / -4 - log(real_root(x, -4))`	→	`-log(x**(-1/4)) - log(x)/4`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

sp-acj4-116-real true simplipy-f64-edge no verdict Q.real(x) ∧ (~Q.zero(x)) ∧ (x > 0) ∧ (~Q.zero(real_root(x, (-6)))) ⊢ Eq((log(x)/(-6)), log(real_root(x, (-6)))) null difference → -log(x**(-1/6)) - log(x)/6 · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(x), x > 0, ~Q.zero(real_root(x, -6)))
Residual = log(x) / -6 - log(real_root(x, -6))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`log(x) / -6 - log(real_root(x, -6))`	→	`-log(x**(-1/6)) - log(x)/6`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(cos(x)), ~Q.zero(1 / cos(x)))
Residual = Abs(log(cos(x))) - log(1 / cos(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(log(cos(x))) - log(1 / cos(x))`	→	`-log(1/cos(x)) + Abs(log(cos(x)))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = acos(cos(asin(x))) - Abs(asin(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`acos(cos(asin(x))) - Abs(asin(x))`	→	`-Abs(asin(x)) + acos(sqrt(1 - x**2))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = acos(cos(sin(x))) - Abs(sin(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`acos(cos(sin(x))) - Abs(sin(x))`	→	`-Abs(sin(x)) + acos(cos(sin(x)))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = acos(sin(acos(x))) - Abs(asin(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`acos(sin(acos(x))) - Abs(asin(x))`	→	`-Abs(asin(x)) + acos(sqrt(1 - x**2))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Ne(sinh(acosh(x)), I, evaluate=False), Ne(sinh(acosh(x)), -I, evaluate=False), ~Q.zero(cosh(acosh(x))))
Residual = atan(sinh(acosh(x))) - asin(tanh(acosh(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, 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))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(x), Ne(sinh(log(x)), I, evaluate=False), Ne(sinh(log(x)), -I, evaluate=False), ~Q.zero(cosh(log(x))))
Residual = atan(sinh(log(x))) - asin(tanh(log(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atan(sinh(log(x))) - asin(tanh(log(x)))`	→	`-asin(tanh(log(x))) + atan(sinh(log(x)))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Ne(cos(asin(x)), 1, evaluate=False), Ne(cos(asin(x)), -1, evaluate=False), ~Q.zero(x))
Residual = atanh(cos(asin(x))) - acosh(Abs(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atanh(cos(asin(x))) - acosh(Abs(1 / x))`	→	`-acosh(1/Abs(x)) + atanh(sqrt(1 - x**2))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Ne(cos(atan(x)), 1, evaluate=False), Ne(cos(atan(x)), -1, evaluate=False), ~Q.zero(x))
Residual = atanh(cos(atan(x))) - Abs(asinh(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atanh(cos(atan(x))) - Abs(asinh(1 / x))`	→	`-Abs(asinh(1/x)) + atanh(1/sqrt(x**2 + 1))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Ne(sin(acos(x)), 1, evaluate=False), Ne(sin(acos(x)), -1, evaluate=False), ~Q.zero(x))
Residual = atanh(sin(acos(x))) - acosh(Abs(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atanh(sin(acos(x))) - acosh(Abs(1 / x))`	→	`-acosh(1/Abs(x)) + atanh(sqrt(1 - x**2))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(x), ~Q.zero(1 / x))
Residual = cos(log(1 / x)) - cos(log(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`cos(log(1 / x)) - cos(log(x))`	→	`cos(log(1/x)) - cos(log(x))`
ask	`Q.zero(Residual)`	→	`None`
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 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(Pow(pi, x)))
Residual = 1 / Pow(pi, x) - Pow(1 / pi, x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`1 / Pow(pi, x) - Pow(1 / pi, x)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(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))
Residual = 1 / Pow(x, x) - Pow(1 / x, x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`1 / Pow(x, x) - Pow(1 / x, x)`	→	`-(1/x)x + x(-x)`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(real_root(x, 3)), ~Q.zero(x))
Residual = log(real_root(x, 3)) - (log(x) / 3)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`log(real_root(x, 3)) - (log(x) / 3)`	→	`-log(x)/3 + log(Abs(x)*(1/3)sign(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(real_root(x, 9)), ~Q.zero(x))
Residual = log(real_root(x, 9)) - (log(x) / 9)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`log(real_root(x, 9)) - (log(x) / 9)`	→	`-log(x)/9 + log(Abs(x)*(1/9)sign(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(cos(x)), ~Q.zero(1 / cos(x)))
Residual = -log(cos(x)) - log(1 / cos(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-log(cos(x)) - log(1 / cos(x))`	→	`-log(1/cos(x)) - log(cos(x))`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

sp-acj4-261-real true simplipy-f64-edge no verdict Q.real(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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(cosh(x)), ~Q.zero(1 / cosh(x)))
Residual = -log(cosh(x)) - log(1 / cosh(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-log(cosh(x)) - log(1 / cosh(x))`	→	`-log(1/cosh(x)) - log(cosh(x))`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(x), ~Q.zero(1 / x))
Residual = -sin(log(x)) - sin(log(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-sin(log(x)) - sin(log(1 / x))`	→	`-sin(log(1/x)) - sin(log(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(x), ~Q.zero(cos(log(x))), ~Q.zero(1 / x), ~Q.zero(cos(log(1 / x))))
Residual = -tan(log(x)) - tan(log(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-tan(log(x)) - tan(log(1 / x))`	→	`-tan(log(1/x)) - tan(log(x))`
ask	`Q.zero(Residual)`	→	`None`
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) · ask → None 0.041 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(x), ~Q.zero(Pow(x, 3)))
Residual = 3 * log(x) - log(Pow(x, 3))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`3 * log(x) - log(Pow(x, 3))`	→	`3log(x) - log(x*3)`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = asinh(sinh(x)) - x
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`asinh(sinh(x)) - x`	→	`-x + asinh(sinh(x))`
ask	`Q.zero(Residual)`	→	`None`
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 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = Pow(1 / pi, x) - Pow(pi, -x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(1 / pi, x) - Pow(pi, -x)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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 · ask → None 0.044 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(x), Or(~Q.zero(1 / x), re(x) > 0), Or(~Q.zero(x), re(-x) > 0))
Residual = Pow(1 / x, x) - Pow(x, -x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(1 / x, x) - Pow(x, -x)`	→	`(1/x)x - 1/xx`
ask	`Q.zero(Residual)`	→	`None`
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 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(exp(x)))
Residual = real_root(exp(x), -5) - exp(x / -5)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`real_root(exp(x), -5) - exp(x / -5)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(exp(x)))
Residual = real_root(exp(x), -7) - exp(x / -7)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`real_root(exp(x), -7) - exp(x / -7)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = sin(Abs(asin(x))) - Abs(cos(acos(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`sin(Abs(asin(x))) - Abs(cos(acos(x)))`	→	`sin(Abs(asin(x))) - Abs(x)`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(x), ~Q.zero(1 / x))
Residual = sin(-log(x)) - sin(log(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`sin(-log(x)) - sin(log(1 / x))`	→	`-sin(log(1/x)) - sin(log(x))`
ask	`Q.zero(Residual)`	→	`None`
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 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(x), ~Q.zero(sinh(x)))
Residual = sinh(exp(log(x))) - exp(log(sinh(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`sinh(exp(log(x))) - exp(log(sinh(x)))`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(cos(acos(Abs(x)))), ~Q.zero(cos(acos(x))))
Residual = tan(acos(Abs(x))) - Abs(tan(acos(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`tan(acos(Abs(x))) - Abs(tan(acos(x)))`	→	`sqrt(1 - x2)/Abs(x) - Abs(sqrt(1 - x2)/x)`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(x), ~Q.zero(cos(-log(x))), ~Q.zero(1 / x), ~Q.zero(cos(log(1 / x))))
Residual = tan(-log(x)) - tan(log(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`tan(-log(x)) - tan(log(1 / x))`	→	`-tan(log(1/x)) - tan(log(x))`
ask	`Q.zero(Residual)`	→	`None`
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) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(x), Or(~Q.zero(x), re(x) > 0), ~Q.zero(Pow(x, x)))
Residual = log(x) * x - log(Pow(x, x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`log(x) * x - log(Pow(x, x))`	→	`xlog(x) - log(x*x)`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(x), Ne(-log(x), I, evaluate=False), Ne(-log(x), -I, evaluate=False), ~Q.zero(1 / x), Ne(log(1 / x), I, evaluate=False), Ne(log(1 / x), -I, evaluate=False))
Residual = atan(-log(x)) - atan(log(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atan(-log(x)) - atan(log(1 / x))`	→	`-atan(log(1/x)) - atan(log(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 0.039 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(x), ~Q.zero(log(x)), ~Q.zero(1 / log(x)))
Residual = -log(log(x)) - log(1 / log(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-log(log(x)) - log(1 / log(x))`	→	`-log(1/log(x)) - log(log(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(x), ~Q.zero(cosh(-log(x))), ~Q.zero(1 / x), ~Q.zero(cosh(log(1 / x))))
Residual = tanh(-log(x)) - tanh(log(1 / x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`tanh(-log(x)) - tanh(log(1 / x))`	→	`-tanh(log(1/x)) - tanh(log(x))`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

sp-acj4-450-real true simplipy-f64-edge solved Q.real(x) ∧ (~Q.zero(x)) ⊢ Eq((x/x), 1) true difference → 0 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(x))
Residual = x / x - 1
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`x / x - 1`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-451-real true simplipy-f64-edge solved Q.real(x) ∧ (~Q.zero(x)) ⊢ Eq((0/x), 0) true difference → 0 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(x))
Residual = 0 / x - 0
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`0 / x - 0`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-50-real true simplipy-f64-edge no verdict Q.real(x) ∧ (~Q.zero(Pow(6, x))) ⊢ Eq((log(6)*x), log(Pow(6, x))) null difference → x*log(6) - log(6**x) · ask → None 0.041 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(Pow(6, x)))
Residual = log(6) * x - log(Pow(6, x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`log(6) * x - log(Pow(6, x))`	→	`xlog(6) - log(6*x)`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

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) · ask → None 0.141 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(x), Or(~Q.zero(x), re(exp(1)) > 0), ~Q.zero(Pow(x, exp(1))))
Residual = log(x) * exp(1) - log(Pow(x, exp(1)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`log(x) * exp(1) - log(Pow(x, exp(1)))`	→	`Elog(x) - log(x*E)`
ask	`Q.zero(Residual)`	→	`None`
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) · ask → None 0.143 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(x), Or(~Q.zero(x), re(pi) > 0), ~Q.zero(Pow(x, pi)))
Residual = log(x) * pi - log(Pow(x, pi))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`log(x) * pi - log(Pow(x, pi))`	→	`pilog(x) - log(x*pi)`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

sp-acj4-6-real true simplipy-f64-edge solved Q.real(x) ∧ Ne(tanh(x), 1) ∧ Ne(tanh(x), (-1)) ⊢ Eq(atanh(tanh(x)), x) true difference → 0 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Ne(tanh(x), 1, evaluate=False), Ne(tanh(x), -1, evaluate=False))
Residual = atanh(tanh(x)) - x
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atanh(tanh(x)) - x`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-806-ground true simplipy-f64-edge solved Eq(cosh(0), 1) true difference → 0 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Assum = And()
Residual = cosh(0) - 1
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`cosh(0) - 1`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-813-ground true simplipy-f64-edge solved Eq(sinh(0), 0) true difference → 0 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Assum = And()
Residual = sinh(0) - 0
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`sinh(0) - 0`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-816-ground true simplipy-f64-edge solved Eq(tanh(0), 0) true difference → 0 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Assum = And()
Residual = tanh(0) - 0
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`tanh(0) - 0`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-1007-ground true simplipy-ground solved Eq((0/sin(5)), 0) true difference → 0 · ask → True 0.011 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Assum = And()
Residual = 0 / sin(5) - 0
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`0 / sin(5) - 0`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-1107-ground true simplipy-ground solved Eq(asin(sin((1/10))), Rational(1, 10)) true difference → 0 · ask → True 0.021 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Assum = And()
Residual = asin(sin(Integer(1) / 10)) - Rational(1, 10)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`asin(sin(Integer(1) / 10)) - Rational(1, 10)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-1148-ground true simplipy-ground no verdict Eq(cosh(log((1/4))), Rational(17, 8)) null difference → -17/8 + cosh(log(4)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Assum = And()
Residual = cosh(log(Integer(1) / 4)) - Rational(17, 8)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`cosh(log(Integer(1) / 4)) - Rational(17, 8)`	→	`-17/8 + cosh(log(4))`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

sp-acj4-1149-ground true simplipy-ground solved Eq(exp(Abs(log(2))), 2) true difference → 0 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Assum = And()
Residual = exp(Abs(log(2))) - 2
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`exp(Abs(log(2))) - 2`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-1177-ground true simplipy-ground solved Eq(Pow(0, asinh(10)), 0) true difference → 0 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Assum = And()
Residual = Pow(0, asinh(10)) - 0
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(0, asinh(10)) - 0`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-1195-ground true simplipy-ground solved Eq(Pow(0, atan(7)), 0) true difference → 0 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Assum = And()
Residual = Pow(0, atan(7)) - 0
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(0, atan(7)) - 0`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-1217-ground true simplipy-ground solved Eq(Pow(0, exp((-1))), 0) true difference → 0 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Assum = And()
Residual = Pow(0, exp(-1)) - 0
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(0, exp(-1)) - 0`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-1238-ground true simplipy-ground solved Eq(Pow(0, (1/pi)), 0) true difference → 0 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Assum = And()
Residual = Pow(0, 1 / pi) - 0
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(0, 1 / pi) - 0`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-1247-ground true simplipy-ground solved Eq(Pow(0, log(9)), 0) true difference → 0 · ask → True 0.011 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Assum = And()
Residual = Pow(0, log(9)) - 0
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(0, log(9)) - 0`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-1254-ground true simplipy-ground solved Eq(Pow(0, sin(2)), 0) true difference → 0 · ask → True 0.011 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Assum = And()
Residual = Pow(0, sin(2)) - 0
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(0, sin(2)) - 0`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-1258-ground true simplipy-ground solved Eq(Pow(0, sin(9)), 0) true difference → 0 · ask → True 0.011 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Assum = And()
Residual = Pow(0, sin(9)) - 0
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(0, sin(9)) - 0`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-5372-ground true simplipy-ground solved Eq(sin(asin((1/(-4)))), Rational(-1, 4)) true difference → 0 · ask → True 0.018 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Assum = And()
Residual = sin(asin(Integer(1) / -4)) - Rational(-1, 4)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`sin(asin(Integer(1) / -4)) - Rational(-1, 4)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-5382-ground true simplipy-ground no verdict Eq(sinh(log((1/4))), Rational(-15, 8)) null difference → 15/8 - sinh(log(4)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Assum = And()
Residual = sinh(log(Integer(1) / 4)) - Rational(-15, 8)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`sinh(log(Integer(1) / 4)) - Rational(-15, 8)`	→	`15/8 - sinh(log(4))`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

sp-acj4-5385-ground true simplipy-ground no verdict Eq(sinh((-log(4))), Rational(-15, 8)) null difference → 15/8 - sinh(log(4)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Assum = And()
Residual = sinh(-log(4)) - Rational(-15, 8)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`sinh(-log(4)) - Rational(-15, 8)`	→	`15/8 - sinh(log(4))`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

sp-acj4-819-ground true simplipy-ground solved Eq((0/pi), 0) true difference → 0 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Assum = And()
Residual = 0 / pi - 0
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`0 / pi - 0`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-837-ground true simplipy-ground solved Eq(Pow(0, pi), 0) true difference → 0 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Assum = And()
Residual = Pow(0, pi) - 0
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(0, pi) - 0`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-848-ground true simplipy-ground no verdict Eq(sinh(log(4)), Rational(15, 8)) null difference → -15/8 + sinh(log(4)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Assum = And()
Residual = sinh(log(4)) - Rational(15, 8)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`sinh(log(4)) - Rational(15, 8)`	→	`-15/8 + sinh(log(4))`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

sp-acj4-868-ground true simplipy-ground solved Eq((0*acosh(7)), 0) true difference → 0 · ask → True 0.019 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Assum = And()
Residual = 0 * acosh(7) - 0
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`0 * acosh(7) - 0`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-911-ground true simplipy-ground solved Eq((0/asin((-1))), 0) true difference → 0 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Assum = And()
Residual = 0 / asin(-1) - 0
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`0 / asin(-1) - 0`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-927-ground true simplipy-ground solved Eq((0/asinh(4)), 0) true difference → 0 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked process, starting from this state:
# the expression caches are dropped (imported and lazily loaded modules stay)
sympy.core.cache.clear_cache()

Assum = And()
Residual = 0 / asinh(4) - 0
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`0 / asinh(4) - 0`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = asin(Abs(x)) - Abs(asin(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`asin(Abs(x)) - Abs(asin(x))`	→	`-Abs(asin(x)) + asin(Abs(x))`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

sp-acj4-102-real true simplipy-real solved Q.real(x) ⊢ Eq((Abs(x)/6), Abs((x/(-6)))) true difference → 0 · ask → True 0.011 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = Abs(x) / 6 - Abs(x / -6)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(x) / 6 - Abs(x / -6)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-108-real true simplipy-real no verdict Q.real(x) ∧ (~Q.zero(x)) ∧ (~Q.zero(Abs(x))) ⊢ Eq((Abs(x)/x), (x/Abs(x))) null difference → -x/Abs(x) + Abs(x)/x · ask → None 0.039 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(x), ~Q.zero(Abs(x)))
Residual = Abs(x) / x - (x / Abs(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(x) / x - (x / Abs(x))`	→	`-x/Abs(x) + Abs(x)/x`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

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 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(Abs(x)), ~Q.zero(x))
Residual = pi / Abs(x) - Abs(pi / x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`pi / Abs(x) - Abs(pi / x)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Ne(exp(x), 1, evaluate=False), Ne(exp(x), -1, evaluate=False))
Residual = Abs(atanh(exp(x))) - atanh(exp(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(atanh(exp(x))) - atanh(exp(x))`	→	`Abs(atanh(exp(x))) - atanh(exp(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = Abs(cos(asin(x))) - cos(asin(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(cos(asin(x))) - cos(asin(x))`	→	`-sqrt(1 - x2) + Abs(sqrt(1 - x2))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(cosh(x)))
Residual = Abs(log(cosh(x))) - log(cosh(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(log(cosh(x))) - log(cosh(x))`	→	`-log(cosh(x)) + Abs(log(cosh(x)))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(sin(x)))
Residual = Abs(log(sin(x))) - (-log(sin(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(log(sin(x))) - (-log(sin(x)))`	→	`log(sin(x)) + Abs(log(sin(x)))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(tanh(x)))
Residual = Abs(log(tanh(x))) - (-log(tanh(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(log(tanh(x))) - (-log(tanh(x)))`	→	`log(tanh(x)) + Abs(log(tanh(x)))`
ask	`Q.zero(Residual)`	→	`None`
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) · ask → None 0.143 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Or(~Q.zero(x), re(exp(1)) > 0))
Residual = Abs(Pow(x, exp(1))) - Pow(x, exp(1))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(Pow(x, exp(1))) - Pow(x, exp(1))`	→	`-xE + Abs(xE)`
ask	`Q.zero(Residual)`	→	`None`
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) · ask → None 0.143 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Or(~Q.zero(x), re(pi) > 0))
Residual = Abs(Pow(x, pi)) - Pow(x, pi)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(Pow(x, pi)) - Pow(x, pi)`	→	`-xpi + Abs(xpi)`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

sp-acj4-14-real true simplipy-real solved Q.real(x) ⊢ Eq((-sin(x)), sin((-x))) true difference → 0 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = -sin(x) - sin(-x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-sin(x) - sin(-x)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = Abs(sin(acos(x))) - cos(asin(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(sin(acos(x))) - cos(asin(x))`	→	`-sqrt(1 - x2) + Abs(sqrt(1 - x2))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = acosh(real_root(x, 5)) - acosh(Pow(x, Rational(1, 5)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, 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))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Ne(sinh(acos(x)), I, evaluate=False), Ne(sinh(acos(x)), -I, evaluate=False), ~Q.zero(cosh(acos(x))))
Residual = atan(sinh(acos(x))) - asin(tanh(acos(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atan(sinh(acos(x))) - asin(tanh(acos(x)))`	→	`-asin(tanh(acos(x))) + atan(sinh(acos(x)))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Ne(sinh(asin(x)), I, evaluate=False), Ne(sinh(asin(x)), -I, evaluate=False), ~Q.zero(cosh(asin(x))))
Residual = atan(sinh(asin(x))) - asin(tanh(asin(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atan(sinh(asin(x))) - asin(tanh(asin(x)))`	→	`-asin(tanh(asin(x))) + atan(sinh(asin(x)))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(cos(cos(x))), Ne(tan(cos(x)), I, evaluate=False), Ne(tan(cos(x)), -I, evaluate=False))
Residual = atan(tan(cos(x))) - cos(x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atan(tan(cos(x))) - cos(x)`	→	`-cos(x) + atan(tan(cos(x)))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Ne(sin(cos(x)), 1, evaluate=False), Ne(sin(cos(x)), -1, evaluate=False), ~Q.zero(cos(cos(x))))
Residual = atanh(sin(cos(x))) - asinh(tan(cos(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atanh(sin(cos(x))) - asinh(tan(cos(x)))`	→	`-asinh(tan(cos(x))) + atanh(sin(cos(x)))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Ne(sin(sin(x)), 1, evaluate=False), Ne(sin(sin(x)), -1, evaluate=False), ~Q.zero(cos(sin(x))))
Residual = atanh(sin(sin(x))) - asinh(tan(sin(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atanh(sin(sin(x))) - asinh(tan(sin(x)))`	→	`-asinh(tan(sin(x))) + atanh(sin(sin(x)))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Ne(sin(tanh(x)), 1, evaluate=False), Ne(sin(tanh(x)), -1, evaluate=False), ~Q.zero(cos(tanh(x))))
Residual = atanh(sin(tanh(x))) - asinh(tan(tanh(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atanh(sin(tanh(x))) - asinh(tan(tanh(x)))`	→	`-asinh(tan(tanh(x))) + atanh(sin(tanh(x)))`
ask	`Q.zero(Residual)`	→	`None`
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 · ask → True 0.011 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(x), ~Q.zero(-6 / x))
Residual = 1 / (-6 / x) - (x / -6)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`1 / (-6 / x) - (x / -6)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = tanh(Abs(x)) - Abs(tanh(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`tanh(Abs(x)) - Abs(tanh(x))`	→	`tanh(Abs(x)) - Abs(tanh(x))`
ask	`Q.zero(Residual)`	→	`None`
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 · ask → True 0.011 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(x), ~Q.zero(-8 / x))
Residual = 1 / (-8 / x) - (x / -8)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`1 / (-8 / x) - (x / -8)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Or(~Q.zero(x), re(pi) > 0), ~Q.zero(Pow(x, pi)), Or(~Q.zero(x), re(-pi) > 0))
Residual = 1 / Pow(x, pi) - Pow(x, -pi)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`1 / Pow(x, pi) - Pow(x, -pi)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = -Abs(asin(x)) - asin(-Abs(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-Abs(asin(x)) - asin(-Abs(x))`	→	`-Abs(asin(x)) + asin(Abs(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = -Abs(asinh(x)) - asinh(-Abs(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-Abs(asinh(x)) - asinh(-Abs(x))`	→	`-Abs(asinh(x)) + asinh(Abs(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 0.039 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Ne(x, 1, evaluate=False), Ne(x, -1, evaluate=False), Ne(-Abs(x), 1, evaluate=False), Ne(-Abs(x), -1, evaluate=False))
Residual = -Abs(atanh(x)) - atanh(-Abs(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-Abs(atanh(x)) - atanh(-Abs(x))`	→	`-Abs(atanh(x)) + atanh(Abs(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = -Abs(sinh(x)) - sinh(-Abs(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-Abs(sinh(x)) - sinh(-Abs(x))`	→	`sinh(Abs(x)) - Abs(sinh(x))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = -Abs(tanh(x)) - tanh(-Abs(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-Abs(tanh(x)) - tanh(-Abs(x))`	→	`tanh(Abs(x)) - Abs(tanh(x))`
ask	`Q.zero(Residual)`	→	`None`
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 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(-exp(x)))
Residual = -exp(-x) - (1 / -exp(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-exp(-x) - (1 / -exp(x))`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-275-real true simplipy-real no verdict Q.real(x) ∧ (~Q.zero(Abs(x))) ∧ (~Q.zero(x)) ⊢ Eq(Pow(Abs(x), (-3)), Abs(Pow(x, (-3)))) null difference → -1/(x**2*Abs(x)) + Abs(x)/x**4 · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(Abs(x)), ~Q.zero(x))
Residual = Pow(Abs(x), -3) - Abs(Pow(x, -3))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(Abs(x), -3) - Abs(Pow(x, -3))`	→	`-1/(x*2Abs(x)) + Abs(x)/x**4`
ask	`Q.zero(Residual)`	→	`None`
answer			`null`

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 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(Abs(x)), ~Q.zero(x))
Residual = Pow(Abs(x), -4) - Pow(x, -4)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(Abs(x), -4) - Pow(x, -4)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-283-real true simplipy-real solved Q.real(x) ⊢ Eq(Pow(Abs(x), 2), (x*x)) true difference → 0 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = Pow(Abs(x), 2) - (x * x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(Abs(x), 2) - (x * x)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = Pow(Abs(x), 5) - Abs(Pow(x, 5))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(Abs(x), 5) - Abs(Pow(x, 5))`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-289-real true simplipy-real solved Q.real(x) ⊢ Eq(Pow(Abs(x), 8), Pow(x, 8)) true difference → 0 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = Pow(Abs(x), 8) - Pow(x, 8)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(Abs(x), 8) - Pow(x, 8)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-31-real true simplipy-real solved Q.real(x) ⊢ Eq((5*Abs(x)), Abs(((-5)*x))) true difference → 0 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = 5 * Abs(x) - Abs(-5 * x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`5 * Abs(x) - Abs(-5 * x)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-326-real true simplipy-real solved Q.real(x) ⊢ Eq(Pow(exp(x), 2), exp((2*x))) true difference → 0 · ask → True 0.011 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = Pow(exp(x), 2) - exp(2 * x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(exp(x), 2) - exp(2 * x)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-33-real true simplipy-real solved Q.real(x) ⊢ Eq((6*Abs(x)), Abs(((-6)*x))) true difference → 0 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = 6 * Abs(x) - Abs(-6 * x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`6 * Abs(x) - Abs(-6 * x)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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) · ask → None 0.041 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(x), ~Q.zero(Pow(x, 7)))
Residual = 7 * log(x) - log(Pow(x, 7))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`7 * log(x) - log(Pow(x, 7))`	→	`7log(x) - log(x*7)`
ask	`Q.zero(Residual)`	→	`None`
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) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Or(~Q.zero(x), re(log(5)) > 0), ~Q.zero(x))
Residual = Pow(x, log(5)) - Pow(5, log(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(x, log(5)) - Pow(5, log(x))`	→	`-5log(x) + xlog(5)`
ask	`Q.zero(Residual)`	→	`None`
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) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Or(~Q.zero(x), re(log(7)) > 0), ~Q.zero(x))
Residual = Pow(x, log(7)) - Pow(7, log(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(x, log(7)) - Pow(7, log(x))`	→	`-7log(x) + xlog(7)`
ask	`Q.zero(Residual)`	→	`None`
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) · ask → None 0.142 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Or(~Q.zero(x), re(log(pi)) > 0), ~Q.zero(x))
Residual = Pow(x, log(pi)) - Pow(pi, log(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Pow(x, log(pi)) - Pow(pi, log(x))`	→	`-pilog(x) + xlog(pi)`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = real_root(Abs(x), 3) - Abs(real_root(x, 3))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, 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))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = real_root(Abs(x), 9) - Abs(real_root(x, 9))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, 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))`
ask	`Q.zero(Residual)`	→	`None`
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… · ask → None 0.041 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Q.real(acos(x)), ~Q.zero(acos(x)))
Residual = real_root(acos(x), -5) - Pow(acos(x), Rational(-1, 5))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, 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)`
ask	`Q.zero(Residual)`	→	`None`
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)… · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Q.real(acos(x)))
Residual = real_root(acos(x), 5) - Pow(acos(x), Rational(1, 5))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, 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)`
ask	`Q.zero(Residual)`	→	`None`
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), … · ask → None 0.039 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Q.real(acosh(x)), ~Q.zero(acosh(x)))
Residual = real_root(acosh(x), -5) - Pow(acosh(x), Rational(-1, 5))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, 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)`
ask	`Q.zero(Residual)`	→	`None`
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… · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Q.real(acosh(x)))
Residual = real_root(acosh(x), 5) - Pow(acosh(x), Rational(1, 5))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, 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)`
ask	`Q.zero(Residual)`	→	`None`
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 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(cosh(x)))
Residual = real_root(cosh(x), -5) - Pow(cosh(x), Rational(-1, 5))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`real_root(cosh(x), -5) - Pow(cosh(x), Rational(-1, 5))`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = real_root(cosh(x), 5) - Pow(cosh(x), Rational(1, 5))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`real_root(cosh(x), 5) - Pow(cosh(x), Rational(1, 5))`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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) · ask → None 0.041 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(x), ~Q.zero(Pow(x, 9)))
Residual = 9 * log(x) - log(Pow(x, 9))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`9 * log(x) - log(Pow(x, 9))`	→	`9log(x) - log(x*9)`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Ne(x, 1, evaluate=False), Ne(x, -1, evaluate=False))
Residual = sin(Abs(atanh(x))) - Abs(sin(atanh(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`sin(Abs(atanh(x))) - Abs(sin(atanh(x)))`	→	`sin(Abs(atanh(x))) - Abs(sin(atanh(x)))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = sin(Abs(cos(x))) - Abs(sin(cos(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`sin(Abs(cos(x))) - Abs(sin(cos(x)))`	→	`sin(Abs(cos(x))) - Abs(sin(cos(x)))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = sin(Abs(sin(x))) - Abs(sin(sin(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`sin(Abs(sin(x))) - Abs(sin(sin(x)))`	→	`sin(Abs(sin(x))) - Abs(sin(sin(x)))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = sin(Abs(tanh(x))) - Abs(sin(tanh(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`sin(Abs(tanh(x))) - Abs(sin(tanh(x)))`	→	`sin(Abs(tanh(x))) - Abs(sin(tanh(x)))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Ne(Abs(x), 1, evaluate=False), Ne(x, 1, evaluate=False), Ne(x, -1, evaluate=False))
Residual = sin(atanh(Abs(x))) - Abs(sin(atanh(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`sin(atanh(Abs(x))) - Abs(sin(atanh(x)))`	→	`sin(atanh(Abs(x))) - Abs(sin(atanh(x)))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = sin(tanh(Abs(x))) - Abs(sin(tanh(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`sin(tanh(Abs(x))) - Abs(sin(tanh(x)))`	→	`sin(tanh(Abs(x))) - Abs(sin(tanh(x)))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(cos(Abs(asin(x)))), ~Q.zero(cos(asin(x))))
Residual = tan(Abs(asin(x))) - Abs(tan(asin(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`tan(Abs(asin(x))) - Abs(tan(asin(x)))`	→	`tan(Abs(asin(x))) - Abs(x)/Abs(sqrt(1 - x**2))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(cos(Abs(cos(x)))), ~Q.zero(cos(cos(x))))
Residual = tan(Abs(cos(x))) - Abs(tan(cos(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`tan(Abs(cos(x))) - Abs(tan(cos(x)))`	→	`tan(Abs(cos(x))) - Abs(tan(cos(x)))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(cos(Abs(sin(x)))), ~Q.zero(cos(sin(x))))
Residual = tan(Abs(sin(x))) - Abs(tan(sin(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`tan(Abs(sin(x))) - Abs(tan(sin(x)))`	→	`tan(Abs(sin(x))) - Abs(tan(sin(x)))`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(cos(Abs(tanh(x)))), ~Q.zero(cos(tanh(x))))
Residual = tan(Abs(tanh(x))) - Abs(tan(tanh(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`tan(Abs(tanh(x))) - Abs(tan(tanh(x)))`	→	`tan(Abs(tanh(x))) - Abs(tan(tanh(x)))`
ask	`Q.zero(Residual)`	→	`None`
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) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(cos(asin(Abs(x)))), ~Q.zero(cos(asin(x))))
Residual = tan(asin(Abs(x))) - Abs(tan(asin(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`tan(asin(Abs(x))) - Abs(tan(asin(x)))`	→	`-Abs(x)/Abs(sqrt(1 - x2)) + Abs(x)/sqrt(1 - x2)`
ask	`Q.zero(Residual)`	→	`None`
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))) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(cos(tanh(Abs(x)))), ~Q.zero(cos(tanh(x))))
Residual = tan(tanh(Abs(x))) - Abs(tan(tanh(x)))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`tan(tanh(Abs(x))) - Abs(tan(tanh(x)))`	→	`tan(tanh(Abs(x))) - Abs(tan(tanh(x)))`
ask	`Q.zero(Residual)`	→	`None`
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)) · ask → None 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), Ne(Abs(x), 1, evaluate=False), Ne(x, 1, evaluate=False), Ne(x, -1, evaluate=False))
Residual = atanh(Abs(x)) - Abs(atanh(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`atanh(Abs(x)) - Abs(atanh(x))`	→	`-Abs(atanh(x)) + atanh(Abs(x))`
ask	`Q.zero(Residual)`	→	`None`
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 · ask → True 0.011 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(Abs(x)), ~Q.zero(-Abs(x)))
Residual = -1 / Abs(x) - (1 / -Abs(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-1 / Abs(x) - (1 / -Abs(x))`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(cos(x)), ~Q.zero(-cos(x)))
Residual = -1 / cos(x) - (1 / -cos(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-1 / cos(x) - (1 / -cos(x))`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(x), ~Q.zero(log(x)), ~Q.zero(-log(x)))
Residual = -1 / log(x) - (1 / -log(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-1 / log(x) - (1 / -log(x))`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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 · ask → True 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(cos(x)), ~Q.zero(tan(x)), ~Q.zero(-tan(x)))
Residual = -1 / tan(x) - (1 / -tan(x))
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`-1 / tan(x) - (1 / -tan(x))`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
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 · ask → True 0.011 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x), ~Q.zero(Abs(x)), ~Q.zero(x))
Residual = 3 / Abs(x) - Abs(-3 / x)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`3 / Abs(x) - Abs(-3 / x)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`

sp-acj4-99-real true simplipy-real solved Q.real(x) ⊢ Eq((Abs(x)/3), Abs((x/(-3)))) true difference → 0 · ask → True 0.011 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 = ask(Q.positive(W**2 + 1), Q.real(W))
# every query then runs in its own forked 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)
Assum = And(Q.real(x))
Residual = Abs(x) / 3 - Abs(x / -3)
# not Q.eq: in SymPy 1.14 ask(Q.eq(x**2, x), Q.real(x)) is wrongly False
Answer = ask(Q.zero(Residual), Assum)
print(Residual, Answer, sep='\n')

difference	`Abs(x) / 3 - Abs(x / -3)`	→	`0`
ask	`Q.zero(Residual)`	→	`True`
answer			`true`