def _construct_simple(coeffs, opt):
"""Handle simple domains, e.g.: ZZ, QQ, RR and algebraic domains. """
result, rationals, reals, algebraics = {}, False, False, False
if opt.extension is True:
is_algebraic = lambda coeff: ask(Q.algebraic(coeff))
else:
is_algebraic = lambda coeff: False
# XXX: add support for a + b*I coefficients
for coeff in coeffs:
if coeff.is_Rational:
if not coeff.is_Integer:
rationals = True
elif coeff.is_Float:
if not algebraics:
reals = True
else:
# there are both reals and algebraics -> EX
return False
elif is_algebraic(coeff):
if not reals:
algebraics = True
else:
# there are both algebraics and reals -> EX
return False
else:
# this is a composite domain, e.g. ZZ[X], EX
return None
if algebraics:
domain, result = _construct_algebraic(coeffs, opt)
else:
if reals:
domain = RR
else:
if opt.field or rationals:
domain = QQ
else:
domain = ZZ
result = []
for coeff in coeffs:
result.append(domain.from_sympy(coeff))
return domain, result
def log(expr, assumptions):
x = expr.args[0]
if ask(Q.algebraic(x), assumptions):
return ask(~Q.nonzero(x - 1), assumptions)
def Pow(expr, assumptions):
return expr.exp.is_Rational and ask(
Q.algebraic(expr.base), assumptions)
def _(expr, assumptions):
if expr.base == E:
if ask(Q.algebraic(expr.exp), assumptions):
return ask(~Q.nonzero(expr.exp), assumptions)
return
return expr.exp.is_Rational and ask(Q.algebraic(expr.base), assumptions)
def cot(expr, assumptions):
x = expr.args[0]
if ask(Q.algebraic(x), assumptions):
return False
def cot(expr, assumptions):
x = expr.args[0]
if ask(Q.algebraic(x), assumptions):
return False
def log(expr, assumptions):
x = expr.args[0]
if ask(Q.algebraic(x), assumptions):
return ask(~Q.nonzero(x - 1), assumptions)
def _is_coeff(factor):
return ask(Q.algebraic(factor))
def Pow(expr, assumptions):
return expr.exp.is_Rational and ask(
Q.algebraic(expr.base), assumptions)
def get_known_facts(x=None):
"""
Facts between unary predicates.
Parameters
==========
x : Symbol, optional
Placeholder symbol for unary facts. Default is ``Symbol('x')``.
Returns
=======
fact : Known facts in conjugated normal form.
"""
if x is None:
x = Symbol('x')
fact = And(
# primitive predicates for extended real exclude each other.
Exclusive(Q.negative_infinite(x), Q.negative(x), Q.zero(x),
Q.positive(x), Q.positive_infinite(x)),
# build complex plane
Exclusive(Q.real(x), Q.imaginary(x)),
Implies(Q.real(x) | Q.imaginary(x), Q.complex(x)),
# other subsets of complex
Exclusive(Q.transcendental(x), Q.algebraic(x)),
Equivalent(Q.real(x),
Q.rational(x) | Q.irrational(x)),
Exclusive(Q.irrational(x), Q.rational(x)),
Implies(Q.rational(x), Q.algebraic(x)),
# integers
Exclusive(Q.even(x), Q.odd(x)),
Implies(Q.integer(x), Q.rational(x)),
Implies(Q.zero(x), Q.even(x)),
Exclusive(Q.composite(x), Q.prime(x)),
Implies(Q.composite(x) | Q.prime(x),
Q.integer(x) & Q.positive(x)),
Implies(Q.even(x) & Q.positive(x) & ~Q.prime(x), Q.composite(x)),
# hermitian and antihermitian
Implies(Q.real(x), Q.hermitian(x)),
Implies(Q.imaginary(x), Q.antihermitian(x)),
Implies(Q.zero(x),
Q.hermitian(x) | Q.antihermitian(x)),
# define finity and infinity, and build extended real line
Exclusive(Q.infinite(x), Q.finite(x)),
Implies(Q.complex(x), Q.finite(x)),
Implies(
Q.negative_infinite(x) | Q.positive_infinite(x), Q.infinite(x)),
# commutativity
Implies(Q.finite(x) | Q.infinite(x), Q.commutative(x)),
# matrices
Implies(Q.orthogonal(x), Q.positive_definite(x)),
Implies(Q.orthogonal(x), Q.unitary(x)),
Implies(Q.unitary(x) & Q.real_elements(x), Q.orthogonal(x)),
Implies(Q.unitary(x), Q.normal(x)),
Implies(Q.unitary(x), Q.invertible(x)),
Implies(Q.normal(x), Q.square(x)),
Implies(Q.diagonal(x), Q.normal(x)),
Implies(Q.positive_definite(x), Q.invertible(x)),
Implies(Q.diagonal(x), Q.upper_triangular(x)),
Implies(Q.diagonal(x), Q.lower_triangular(x)),
Implies(Q.lower_triangular(x), Q.triangular(x)),
Implies(Q.upper_triangular(x), Q.triangular(x)),
Implies(Q.triangular(x),
Q.upper_triangular(x) | Q.lower_triangular(x)),
Implies(Q.upper_triangular(x) & Q.lower_triangular(x), Q.diagonal(x)),
Implies(Q.diagonal(x), Q.symmetric(x)),
Implies(Q.unit_triangular(x), Q.triangular(x)),
Implies(Q.invertible(x), Q.fullrank(x)),
Implies(Q.invertible(x), Q.square(x)),
Implies(Q.symmetric(x), Q.square(x)),
Implies(Q.fullrank(x) & Q.square(x), Q.invertible(x)),
Equivalent(Q.invertible(x), ~Q.singular(x)),
Implies(Q.integer_elements(x), Q.real_elements(x)),
Implies(Q.real_elements(x), Q.complex_elements(x)),
)
return fact
def test_algebraic():
x, y = symbols('x,y')
assert ask(Q.algebraic(x)) == None
assert ask(Q.algebraic(I)) == True
assert ask(Q.algebraic(2*I)) == True
assert ask(Q.algebraic(I/3)) == True
assert ask(Q.algebraic(sqrt(7))) == True
assert ask(Q.algebraic(2*sqrt(7))) == True
assert ask(Q.algebraic(sqrt(7)/3)) == True
assert ask(Q.algebraic(I*sqrt(3))) == True
assert ask(Q.algebraic(sqrt(1+I*sqrt(3)))) == True
assert ask(Q.algebraic((1+I*sqrt(3)**(S(17)/31)))) == True
assert ask(Q.algebraic((1+I*sqrt(3)**(S(17)/pi)))) == False
assert ask(Q.algebraic(sin(7))) == None
assert ask(Q.algebraic(sqrt(sin(7)))) == None
assert ask(Q.algebraic(sqrt(y+I*sqrt(7)))) == None
assert ask(Q.algebraic(oo)) == False
assert ask(Q.algebraic(-oo)) == False
assert ask(Q.algebraic(2.47)) == False
def _(expr, assumptions):
x = expr.exp
if ask(Q.algebraic(x), assumptions):
return ask(~Q.nonzero(x), assumptions)
def _is_coeff(factor):
return ask(Q.algebraic(factor))
def test_algebraic():
x, y = symbols('x,y')
assert ask(Q.algebraic(x)) == None
assert ask(Q.algebraic(I)) == True
assert ask(Q.algebraic(2 * I)) == True
assert ask(Q.algebraic(I / 3)) == True
assert ask(Q.algebraic(sqrt(7))) == True
assert ask(Q.algebraic(2 * sqrt(7))) == True
assert ask(Q.algebraic(sqrt(7) / 3)) == True
assert ask(Q.algebraic(I * sqrt(3))) == True
assert ask(Q.algebraic(sqrt(1 + I * sqrt(3)))) == True
assert ask(Q.algebraic((1 + I * sqrt(3)**(S(17) / 31)))) == True
assert ask(Q.algebraic((1 + I * sqrt(3)**(S(17) / pi)))) == False
assert ask(Q.algebraic(sin(7))) == None
assert ask(Q.algebraic(sqrt(sin(7)))) == None
assert ask(Q.algebraic(sqrt(y + I * sqrt(7)))) == None
assert ask(Q.algebraic(oo)) == False
assert ask(Q.algebraic(-oo)) == False
assert ask(Q.algebraic(2.47)) == False
