def Pow(expr, assumptions): """ Real**Integer -> Real Positive**Real -> Real Real**(Integer/Even) -> Real if base is nonnegative Real**(Integer/Odd) -> Real Real**Imaginary -> ? Imaginary**Real -> ? Real**Real -> ? """ if expr.is_number: return AskRealHandler._number(expr, assumptions) if ask(Q.imaginary(expr.base), assumptions): if ask(Q.real(expr.exp), assumptions): if ask(Q.odd(expr.exp), assumptions): return False elif ask(Q.even(expr.exp), assumptions): return True elif ask(Q.real(expr.base), assumptions): if ask(Q.real(expr.exp), assumptions): if expr.exp.is_Rational and \ ask(Q.even(expr.exp.q), assumptions): return ask(Q.positive(expr.base), assumptions) elif ask(Q.integer(expr.exp), assumptions): return True elif ask(Q.positive(expr.base), assumptions): return True elif ask(Q.negative(expr.base), assumptions): return False
def test_float_1(): z = 1.0 assert ask(Q.commutative(z)) == True assert ask(Q.integer(z)) == True assert ask(Q.rational(z)) == True assert ask(Q.real(z)) == True assert ask(Q.complex(z)) == True assert ask(Q.irrational(z)) == False assert ask(Q.imaginary(z)) == False assert ask(Q.positive(z)) == True assert ask(Q.negative(z)) == False assert ask(Q.even(z)) == False assert ask(Q.odd(z)) == True assert ask(Q.bounded(z)) == True assert ask(Q.infinitesimal(z)) == False assert ask(Q.prime(z)) == False assert ask(Q.composite(z)) == True z = 7.2123 assert ask(Q.commutative(z)) == True assert ask(Q.integer(z)) == False assert ask(Q.rational(z)) == True assert ask(Q.real(z)) == True assert ask(Q.complex(z)) == True assert ask(Q.irrational(z)) == False assert ask(Q.imaginary(z)) == False assert ask(Q.positive(z)) == True assert ask(Q.negative(z)) == False assert ask(Q.even(z)) == False assert ask(Q.odd(z)) == False assert ask(Q.bounded(z)) == True assert ask(Q.infinitesimal(z)) == False assert ask(Q.prime(z)) == False assert ask(Q.composite(z)) == False
def Pow(expr, assumptions): """ Imaginary**integer -> Imaginary if integer % 2 == 1 Imaginary**integer -> real if integer % 2 == 0 Imaginary**Imaginary -> ? Imaginary**Real -> ? """ if expr.is_number: return AskImaginaryHandler._number(expr, assumptions) if ask(Q.imaginary(expr.base), assumptions): if ask(Q.real(expr.exp), assumptions): if ask(Q.odd(expr.exp), assumptions): return True elif ask(Q.even(expr.exp), assumptions): return False elif ask(Q.real(expr.base), assumptions): if ask(Q.real(expr.exp), assumptions): if expr.exp.is_Rational and \ ask(Q.even(expr.exp.q), assumptions): return ask(Q.negative(expr.base),assumptions) elif ask(Q.integer(expr.exp), assumptions): return False elif ask(Q.positive(expr.base), assumptions): return False elif ask(Q.negative(expr.base), assumptions): return True
def test_negative(): x, y = symbols('x,y') assert ask(Q.negative(x), Q.negative(x)) == True assert ask(Q.negative(x), Q.positive(x)) == False assert ask(Q.negative(x), ~Q.real(x)) == False assert ask(Q.negative(x), Q.prime(x)) == False assert ask(Q.negative(x), ~Q.prime(x)) == None assert ask(Q.negative(-x), Q.positive(x)) == True assert ask(Q.negative(-x), ~Q.positive(x)) == None assert ask(Q.negative(-x), Q.negative(x)) == False assert ask(Q.negative(-x), Q.positive(x)) == True assert ask(Q.negative(x-1), Q.negative(x)) == True assert ask(Q.negative(x+y)) == None assert ask(Q.negative(x+y), Q.negative(x)) == None assert ask(Q.negative(x+y), Q.negative(x) & Q.negative(y)) == True assert ask(Q.negative(x**2)) == None assert ask(Q.negative(x**2), Q.real(x)) == False assert ask(Q.negative(x**1.4), Q.real(x)) == None assert ask(Q.negative(x*y)) == None assert ask(Q.negative(x*y), Q.positive(x) & Q.positive(y)) == False assert ask(Q.negative(x*y), Q.positive(x) & Q.negative(y)) == True assert ask(Q.negative(x*y), Q.complex(x) & Q.complex(y)) == None assert ask(Q.negative(x**y)) == None assert ask(Q.negative(x**y), Q.negative(x) & Q.even(y)) == False assert ask(Q.negative(x**y), Q.negative(x) & Q.odd(y)) == True assert ask(Q.negative(x**y), Q.positive(x) & Q.integer(y)) == False assert ask(Q.negative(Abs(x))) == False
def test_functions_in_assumptions(): from sympy.logic.boolalg import Equivalent, Xor x = symbols("x") assert ask(x, Q.negative, Q.real(x) >> Q.positive(x)) is False assert ask(x, Q.negative, Equivalent(Q.real(x), Q.positive(x))) is False assert ask(x, Q.negative, Xor(Q.real(x), Q.negative(x))) is False
def test_positive(): x, y, z, w = symbols('x,y,z,w') assert ask(Q.positive(x), Q.positive(x)) == True assert ask(Q.positive(x), Q.negative(x)) == False assert ask(Q.positive(x), Q.nonzero(x)) == None assert ask(Q.positive(-x), Q.positive(x)) == False assert ask(Q.positive(-x), Q.negative(x)) == True assert ask(Q.positive(x+y), Q.positive(x) & Q.positive(y)) == True assert ask(Q.positive(x+y), Q.positive(x) & Q.negative(y)) == None assert ask(Q.positive(2*x), Q.positive(x)) == True assumptions = Q.positive(x) & Q.negative(y) & Q.negative(z) & Q.positive(w) assert ask(Q.positive(x*y*z)) == None assert ask(Q.positive(x*y*z), assumptions) == True assert ask(Q.positive(-x*y*z), assumptions) == False assert ask(Q.positive(x**2), Q.positive(x)) == True assert ask(Q.positive(x**2), Q.negative(x)) == True #exponential assert ask(Q.positive(exp(x)), Q.real(x)) == True assert ask(Q.positive(x + exp(x)), Q.real(x)) == None #absolute value assert ask(Q.positive(Abs(x))) == None # Abs(0) = 0 assert ask(Q.positive(Abs(x)), Q.positive(x)) == True
def test_refine(): m0 = OperationsOnlyMatrix([[Abs(x)**2, sqrt(x**2)], [sqrt(x**2)*Abs(y)**2, sqrt(y**2)*Abs(x)**2]]) m1 = m0.refine(Q.real(x) & Q.real(y)) assert m1 == Matrix([[x**2, Abs(x)], [y**2*Abs(x), x**2*Abs(y)]]) m1 = m0.refine(Q.positive(x) & Q.positive(y)) assert m1 == Matrix([[x**2, x], [x*y**2, x**2*y]]) m1 = m0.refine(Q.negative(x) & Q.negative(y)) assert m1 == Matrix([[x**2, -x], [-x*y**2, -x**2*y]])
def Pow(expr, assumptions): """ Real**Integer -> Real Positive**Real -> Real Real**(Integer/Even) -> Real if base is nonnegative Real**(Integer/Odd) -> Real Imaginary**(Integer/Even) -> Real Imaginary**(Integer/Odd) -> not Real Imaginary**Real -> ? since Real could be 0 (giving real) or 1 (giving imaginary) b**Imaginary -> Real if log(b) is imaginary and b != 0 and exponent != integer multiple of I*pi/log(b) Real**Real -> ? e.g. sqrt(-1) is imaginary and sqrt(2) is not """ if expr.is_number: return AskRealHandler._number(expr, assumptions) if expr.base.func == exp: if ask(Q.imaginary(expr.base.args[0]), assumptions): if ask(Q.imaginary(expr.exp), assumptions): return True # If the i = (exp's arg)/(I*pi) is an integer or half-integer # multiple of I*pi then 2*i will be an integer. In addition, # exp(i*I*pi) = (-1)**i so the overall realness of the expr # can be determined by replacing exp(i*I*pi) with (-1)**i. i = expr.base.args[0]/I/pi if ask(Q.integer(2*i), assumptions): return ask(Q.real(((-1)**i)**expr.exp), assumptions) return if ask(Q.imaginary(expr.base), assumptions): if ask(Q.integer(expr.exp), assumptions): odd = ask(Q.odd(expr.exp), assumptions) if odd is not None: return not odd return if ask(Q.imaginary(expr.exp), assumptions): imlog = ask(Q.imaginary(log(expr.base)), assumptions) if imlog is not None: # I**i -> real, log(I) is imag; # (2*I)**i -> complex, log(2*I) is not imag return imlog if ask(Q.real(expr.base), assumptions): if ask(Q.real(expr.exp), assumptions): if expr.exp.is_Rational and \ ask(Q.even(expr.exp.q), assumptions): return ask(Q.positive(expr.base), assumptions) elif ask(Q.integer(expr.exp), assumptions): return True elif ask(Q.positive(expr.base), assumptions): return True elif ask(Q.negative(expr.base), assumptions): return False
def test_I(): I = S.ImaginaryUnit z = I assert ask(Q.commutative(z)) == True assert ask(Q.integer(z)) == False assert ask(Q.rational(z)) == False assert ask(Q.real(z)) == False assert ask(Q.complex(z)) == True assert ask(Q.irrational(z)) == False assert ask(Q.imaginary(z)) == True assert ask(Q.positive(z)) == False assert ask(Q.negative(z)) == False assert ask(Q.even(z)) == False assert ask(Q.odd(z)) == False assert ask(Q.bounded(z)) == True assert ask(Q.infinitesimal(z)) == False assert ask(Q.prime(z)) == False assert ask(Q.composite(z)) == False z = 1 + I assert ask(Q.commutative(z)) == True assert ask(Q.integer(z)) == False assert ask(Q.rational(z)) == False assert ask(Q.real(z)) == False assert ask(Q.complex(z)) == True assert ask(Q.irrational(z)) == False assert ask(Q.imaginary(z)) == False assert ask(Q.positive(z)) == False assert ask(Q.negative(z)) == False assert ask(Q.even(z)) == False assert ask(Q.odd(z)) == False assert ask(Q.bounded(z)) == True assert ask(Q.infinitesimal(z)) == False assert ask(Q.prime(z)) == False assert ask(Q.composite(z)) == False z = I*(1+I) assert ask(Q.commutative(z)) == True assert ask(Q.integer(z)) == False assert ask(Q.rational(z)) == False assert ask(Q.real(z)) == False assert ask(Q.complex(z)) == True assert ask(Q.irrational(z)) == False assert ask(Q.imaginary(z)) == False assert ask(Q.positive(z)) == False assert ask(Q.negative(z)) == False assert ask(Q.even(z)) == False assert ask(Q.odd(z)) == False assert ask(Q.bounded(z)) == True assert ask(Q.infinitesimal(z)) == False assert ask(Q.prime(z)) == False assert ask(Q.composite(z)) == False
def Pow(expr, assumptions): """ Imaginary**Odd -> Imaginary Imaginary**Even -> Real b**Imaginary -> !Imaginary if exponent is an integer multiple of I*pi/log(b) Imaginary**Real -> ? Positive**Real -> Real Negative**Integer -> Real Negative**(Integer/2) -> Imaginary Negative**Real -> not Imaginary if exponent is not Rational """ if expr.is_number: return AskImaginaryHandler._number(expr, assumptions) if expr.base.func == exp: if ask(Q.imaginary(expr.base.args[0]), assumptions): if ask(Q.imaginary(expr.exp), assumptions): return False i = expr.base.args[0]/I/pi if ask(Q.integer(2*i), assumptions): return ask(Q.imaginary(((-1)**i)**expr.exp), assumptions) if ask(Q.imaginary(expr.base), assumptions): if ask(Q.integer(expr.exp), assumptions): odd = ask(Q.odd(expr.exp), assumptions) if odd is not None: return odd return if ask(Q.imaginary(expr.exp), assumptions): imlog = ask(Q.imaginary(log(expr.base)), assumptions) if imlog is not None: return False # I**i -> real; (2*I)**i -> complex ==> not imaginary if ask(Q.real(expr.base) & Q.real(expr.exp), assumptions): if ask(Q.positive(expr.base), assumptions): return False else: rat = ask(Q.rational(expr.exp), assumptions) if not rat: return rat if ask(Q.integer(expr.exp), assumptions): return False else: half = ask(Q.integer(2*expr.exp), assumptions) if half: return ask(Q.negative(expr.base), assumptions) return half
def test_extended_real(): x = symbols('x') assert ask(Q.extended_real(x), Q.positive(x)) == True assert ask(Q.extended_real(-x), Q.positive(x)) == True assert ask(Q.extended_real(-x), Q.negative(x)) == True assert ask(Q.extended_real(x+S.Infinity), Q.real(x)) == True
def refine_abs(expr, assumptions): """ Handler for the absolute value. Examples ======== >>> from sympy import Symbol, Q, refine, Abs >>> from sympy.assumptions.refine import refine_abs >>> from sympy.abc import x >>> refine_abs(Abs(x), Q.real(x)) >>> refine_abs(Abs(x), Q.positive(x)) x >>> refine_abs(Abs(x), Q.negative(x)) -x """ from sympy.core.logic import fuzzy_not arg = expr.args[0] if ask(Q.real(arg), assumptions) and fuzzy_not(ask(Q.negative(arg), assumptions)): # if it's nonnegative return arg if ask(Q.negative(arg), assumptions): return -arg
def Basic(expr, assumptions): _real = ask(Q.real(expr), assumptions) if _real: _rational = ask(Q.rational(expr), assumptions) if _rational is None: return None return not _rational else: return _real
def Basic(expr, assumptions): if expr.is_number: notpositive = fuzzy_not(AskPositiveHandler._number(expr, assumptions)) if notpositive: return ask(Q.real(expr), assumptions) else: return notpositive
def Pow(expr, assumptions): """ Real ** Even -> NonNegative Real ** Odd -> same_as_base NonNegative ** Positive -> NonNegative """ if expr.is_number: return AskNegativeHandler._number(expr, assumptions) if ask(Q.real(expr.base), assumptions): if ask(Q.positive(expr.base), assumptions): if ask(Q.real(expr.exp), assumptions): return False if ask(Q.even(expr.exp), assumptions): return False if ask(Q.odd(expr.exp), assumptions): return ask(Q.negative(expr.base), assumptions)
def refine_atan2(expr, assumptions): """ Handler for the atan2 function Examples ======== >>> from sympy import Symbol, Q, refine, atan2 >>> from sympy.assumptions.refine import refine_atan2 >>> from sympy.abc import x, y >>> refine_atan2(atan2(y,x), Q.real(y) & Q.positive(x)) atan(y/x) >>> refine_atan2(atan2(y,x), Q.negative(y) & Q.negative(x)) atan(y/x) - pi >>> refine_atan2(atan2(y,x), Q.positive(y) & Q.negative(x)) atan(y/x) + pi """ from sympy.functions.elementary.complexes import atan from sympy.core import S y, x = expr.args if ask(Q.real(y) & Q.positive(x), assumptions): return atan(y / x) elif ask(Q.negative(y) & Q.negative(x), assumptions): return atan(y / x) - S.Pi elif ask(Q.positive(y) & Q.negative(x), assumptions): return atan(y / x) + S.Pi else: return expr
def reduce_abs_inequality(expr, rel, gen, assume=True): """Reduce an inequality with nested absolute values. """ if not ask(Q.real(gen), assumptions=assume): raise NotImplementedError("can't solve inequalities with absolute values of a complex variable") def bottom_up_scan(expr): exprs = [] if expr.is_Add or expr.is_Mul: op = expr.__class__ for arg in expr.args: _exprs = bottom_up_scan(arg) if not exprs: exprs = _exprs else: args = [] for expr, conds in exprs: for _expr, _conds in _exprs: args.append((op(expr, _expr), conds + _conds)) exprs = args elif expr.is_Pow: n = expr.exp if not n.is_Integer or n < 0: raise ValueError("only non-negative integer powers are allowed") _exprs = bottom_up_scan(expr.base) for expr, conds in _exprs: exprs.append((expr ** n, conds)) elif isinstance(expr, Abs): _exprs = bottom_up_scan(expr.args[0]) for expr, conds in _exprs: exprs.append((expr, conds + [Ge(expr, 0)])) exprs.append((-expr, conds + [Lt(expr, 0)])) else: exprs = [(expr, [])] return exprs exprs = bottom_up_scan(expr) mapping = {"<": ">", "<=": ">="} inequalities = [] for expr, conds in exprs: if rel not in mapping.keys(): expr = Relational(expr, 0, rel) else: expr = Relational(-expr, 0, mapping[rel]) inequalities.append([expr] + conds) return reduce_poly_inequalities(inequalities, gen, assume)
def log(expr, assumptions): r = ask(Q.real(expr.args[0]), assumptions) if r is not True: return r if ask(Q.positive(expr.args[0] - 1), assumptions): return True if ask(Q.negative(expr.args[0] - 1), assumptions): return False
def Pow(expr, assumptions): """ Imaginary**integer/odd -> Imaginary Imaginary**integer/even -> Real if integer % 2 == 0 b**Imaginary -> !Imaginary if exponent is an integer multiple of I*pi/log(b) Imaginary**Real -> ? Negative**even root -> Imaginary Negative**odd root -> Real Negative**Real -> Imaginary Real**Integer -> Real Real**Positive -> Real """ if expr.is_number: return AskImaginaryHandler._number(expr, assumptions) if expr.base.func == C.exp: if ask(Q.imaginary(expr.base.args[0]), assumptions): if ask(Q.imaginary(expr.exp), assumptions): return False i = expr.base.args[0]/I/pi if ask(Q.integer(2*i), assumptions): return ask(Q.imaginary(((-1)**i)**expr.exp), assumptions) if ask(Q.imaginary(expr.base), assumptions): if ask(Q.integer(expr.exp), assumptions): odd = ask(Q.odd(expr.exp), assumptions) if odd is not None: return odd return if ask(Q.imaginary(expr.exp), assumptions): imlog = ask(Q.imaginary(C.log(expr.base)), assumptions) if imlog is not None: return False # I**i -> real; (2*I)**i -> complex ==> not imaginary if ask(Q.real(expr.base), assumptions): if ask(Q.real(expr.exp), assumptions): if ask(Q.rational(expr.exp) & Q.even(denom(expr.exp)), assumptions): return ask(Q.negative(expr.base), assumptions) elif ask(Q.integer(expr.exp), assumptions): return False elif ask(Q.positive(expr.base), assumptions): return False elif ask(Q.negative(expr.base), assumptions): return True
def reduce_poly_inequalities(exprs, gen, assume=True, relational=True): """Reduce a system of polynomial inequalities with rational coefficients. """ exact = True polys = [] for _exprs in exprs: _polys = [] for expr in _exprs: if isinstance(expr, tuple): expr, rel = expr else: if expr.is_Relational: expr, rel = expr.lhs - expr.rhs, expr.rel_op else: expr, rel = expr, '==' poly = Poly(expr, gen) if not poly.get_domain().is_Exact: poly, exact = poly.to_exact(), False domain = poly.get_domain() if not (domain.is_ZZ or domain.is_QQ): raise NotImplementedError("inequality solving is not supported over %s" % domain) _polys.append((poly, rel)) polys.append(_polys) solution = solve_poly_inequalities(polys) if isinstance(solution, Union): intervals = list(solution.args) elif isinstance(solution, Interval): intervals = [solution] else: intervals = [] if not exact: intervals = map(interval_evalf, intervals) if not relational: return intervals real = ask(Q.real(gen), assumptions=assume) def relationalize(gen): return Or(*[ i.as_relational(gen) for i in intervals ]) if not real: result = And(relationalize(re(gen)), Eq(im(gen), 0)) else: result = relationalize(gen) return result
def Basic(expr, assumptions): if ask(Q.real(expr)) is False: return False if expr.is_number: # if there are no symbols just evalf i = expr.evalf(2) def nonz(i): if i._prec != 1: return i != 0 return fuzzy_or(nonz(i) for i in i.as_real_imag())
def test_integer(): x = symbols('x') assert ask(Q.integer(x)) == None assert ask(Q.integer(x), Q.integer(x)) == True assert ask(Q.integer(x), ~Q.integer(x)) == False assert ask(Q.integer(x), ~Q.real(x)) == False assert ask(Q.integer(x), ~Q.positive(x)) == None assert ask(Q.integer(x), Q.even(x) | Q.odd(x)) == True assert ask(Q.integer(2*x), Q.integer(x)) == True assert ask(Q.integer(2*x), Q.even(x)) == True assert ask(Q.integer(2*x), Q.prime(x)) == True assert ask(Q.integer(2*x), Q.rational(x)) == None assert ask(Q.integer(2*x), Q.real(x)) == None assert ask(Q.integer(sqrt(2)*x), Q.integer(x)) == False assert ask(Q.integer(x/2), Q.odd(x)) == False assert ask(Q.integer(x/2), Q.even(x)) == True assert ask(Q.integer(x/3), Q.odd(x)) == None assert ask(Q.integer(x/3), Q.even(x)) == None
def Pow(expr, assumptions): if expr.is_number: return expr.evalf() > 0 if ask(Q.positive(expr.base), assumptions): if ask(Q.real(expr.exp), assumptions): return True if ask(Q.negative(expr.base), assumptions): if ask(Q.even(expr.exp), assumptions): return True if ask(Q.even(expr.exp), assumptions): return False
def Pow(expr, assumptions): """ Real**Integer -> Real Positive**Real -> Real Real**(Integer/Even) -> Real if base is nonnegative Real**(Integer/Odd) -> Real """ if expr.is_number: return AskRealHandler._number(expr, assumptions) if ask(Q.real(expr.base), assumptions): if ask(Q.integer(expr.exp), assumptions): return True elif expr.exp.is_Rational: if (expr.exp.q % 2 == 0): return ask(Q.real(expr.base), assumptions) and \ not ask(Q.negative(expr.base), assumptions) else: return True elif ask(Q.real(expr.exp), assumptions): if ask(Q.positive(expr.base), assumptions): return True
def Pow(expr, assumptions): if expr.is_number: return AskPositiveHandler._number(expr, assumptions) if ask(Q.positive(expr.base), assumptions): if ask(Q.real(expr.exp), assumptions): return True if ask(Q.negative(expr.base), assumptions): if ask(Q.even(expr.exp), assumptions): return True if ask(Q.odd(expr.exp), assumptions): return False
def log(expr, assumptions): if ask(Q.real(expr.args[0]), assumptions): if ask(Q.positive(expr.args[0]), assumptions): return False return # XXX it should be enough to do # return ask(Q.nonpositive(expr.args[0]), assumptions) # but ask(Q.nonpositive(exp(x)), Q.imaginary(x)) -> None; # it should return True since exp(x) will be either 0 or complex if expr.args[0].func == exp: if expr.args[0].args[0] in [I, -I]: return True im = ask(Q.imaginary(expr.args[0]), assumptions) if im is False: return False
def reduce_poly_inequalities(exprs, gen, assume=True, relational=True): """Reduce a system of polynomial inequalities with rational coefficients. """ exact = True polys = [] for _exprs in exprs: _polys = [] for expr in _exprs: if isinstance(expr, tuple): expr, rel = expr else: if expr.is_Relational: expr, rel = expr.lhs - expr.rhs, expr.rel_op else: expr, rel = expr, "==" poly = Poly(expr, gen) if not poly.get_domain().is_Exact: poly, exact = poly.to_exact(), False domain = poly.get_domain() if not (domain.is_ZZ or domain.is_QQ): raise NotImplementedError("inequality solving is not supported over %s" % domain) _polys.append((poly, rel)) polys.append(_polys) solution = solve_poly_inequalities(polys) if not exact: solution = solution.evalf() if not relational: return solution real = ask(Q.real(gen), assumptions=assume) if not real: result = And(solution.as_relational(re(gen)), Eq(im(gen), 0)) else: result = solution.as_relational(gen) return result
def test_zero_0(): z = Integer(0) assert ask(Q.nonzero(z)) == False assert ask(Q.commutative(z)) == True assert ask(Q.integer(z)) == True assert ask(Q.rational(z)) == True assert ask(Q.real(z)) == True assert ask(Q.complex(z)) == True assert ask(Q.imaginary(z)) == False assert ask(Q.positive(z)) == False assert ask(Q.negative(z)) == False assert ask(Q.even(z)) == True assert ask(Q.odd(z)) == False assert ask(Q.bounded(z)) == True assert ask(Q.infinitesimal(z)) == True assert ask(Q.prime(z)) == False assert ask(Q.composite(z)) == False
def test_E(): z = S.Exp1 assert ask(Q.commutative(z)) == True assert ask(Q.integer(z)) == False assert ask(Q.rational(z)) == False assert ask(Q.real(z)) == True assert ask(Q.complex(z)) == True assert ask(Q.irrational(z)) == True assert ask(Q.imaginary(z)) == False assert ask(Q.positive(z)) == True assert ask(Q.negative(z)) == False assert ask(Q.even(z)) == False assert ask(Q.odd(z)) == False assert ask(Q.bounded(z)) == True assert ask(Q.infinitesimal(z)) == False assert ask(Q.prime(z)) == False assert ask(Q.composite(z)) == False
def test_Rational_number(): r = Rational(3,4) assert ask(Q.commutative(r)) == True assert ask(Q.integer(r)) == False assert ask(Q.rational(r)) == True assert ask(Q.real(r)) == True assert ask(Q.complex(r)) == True assert ask(Q.irrational(r)) == False assert ask(Q.imaginary(r)) == False assert ask(Q.positive(r)) == True assert ask(Q.negative(r)) == False assert ask(Q.even(r)) == False assert ask(Q.odd(r)) == False assert ask(Q.bounded(r)) == True assert ask(Q.infinitesimal(r)) == False assert ask(Q.prime(r)) == False assert ask(Q.composite(r)) == False r = Rational(1,4) assert ask(Q.positive(r)) == True assert ask(Q.negative(r)) == False r = Rational(5,4) assert ask(Q.negative(r)) == False assert ask(Q.positive(r)) == True r = Rational(5,3) assert ask(Q.positive(r)) == True assert ask(Q.negative(r)) == False r = Rational(-3,4) assert ask(Q.positive(r)) == False assert ask(Q.negative(r)) == True r = Rational(-1,4) assert ask(Q.positive(r)) == False assert ask(Q.negative(r)) == True r = Rational(-5,4) assert ask(Q.negative(r)) == True assert ask(Q.positive(r)) == False r = Rational(-5,3) assert ask(Q.positive(r)) == False assert ask(Q.negative(r)) == True
def exp(expr, assumptions): if ask(Q.real(expr.args[0]), assumptions): return True if ask(Q.imaginary(expr.args[0]), assumptions): from sympy import pi, I return ask(Q.even(expr.args[0] / (I * pi)), assumptions)
def _(expr, assumptions): if ask(Q.real(expr.exp), assumptions): return True if ask(Q.imaginary(expr.exp), assumptions): return ask(Q.even(expr.exp / (I * pi)), assumptions)
def test_imaginary(): x, y, z = symbols('x,y,z') I = S.ImaginaryUnit assert ask(Q.imaginary(x)) == None assert ask(Q.imaginary(x), Q.real(x)) == False assert ask(Q.imaginary(x), Q.prime(x)) == False assert ask(Q.imaginary(x + 1), Q.real(x)) == False assert ask(Q.imaginary(x + 1), Q.imaginary(x)) == False assert ask(Q.imaginary(x + I), Q.real(x)) == False assert ask(Q.imaginary(x + I), Q.imaginary(x)) == True assert ask(Q.imaginary(x + y), Q.imaginary(x) & Q.imaginary(y)) == True assert ask(Q.imaginary(x + y), Q.real(x) & Q.real(y)) == False assert ask(Q.imaginary(x + y), Q.imaginary(x) & Q.real(y)) == False assert ask(Q.imaginary(x + y), Q.complex(x) & Q.real(y)) == None assert ask(Q.imaginary(I * x), Q.real(x)) == True assert ask(Q.imaginary(I * x), Q.imaginary(x)) == False assert ask(Q.imaginary(I * x), Q.complex(x)) == None assert ask(Q.imaginary(x * y), Q.imaginary(x) & Q.real(y)) == True assert ask(Q.imaginary(x + y + z), Q.real(x) & Q.real(y) & Q.real(z)) == False assert ask(Q.imaginary(x + y + z), Q.real(x) & Q.real(y) & Q.imaginary(z)) == None assert ask(Q.imaginary(x + y + z), Q.real(x) & Q.imaginary(y) & Q.imaginary(z)) == False
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_real(): x, y = symbols('x,y') assert ask(Q.real(x)) == None assert ask(Q.real(x), Q.real(x)) == True assert ask(Q.real(x), Q.nonzero(x)) == True assert ask(Q.real(x), Q.positive(x)) == True assert ask(Q.real(x), Q.negative(x)) == True assert ask(Q.real(x), Q.integer(x)) == True assert ask(Q.real(x), Q.even(x)) == True assert ask(Q.real(x), Q.prime(x)) == True assert ask(Q.real(x / sqrt(2)), Q.real(x)) == True assert ask(Q.real(x / sqrt(-2)), Q.real(x)) == False I = S.ImaginaryUnit assert ask(Q.real(x + 1), Q.real(x)) == True assert ask(Q.real(x + I), Q.real(x)) == False assert ask(Q.real(x + I), Q.complex(x)) == None assert ask(Q.real(2 * x), Q.real(x)) == True assert ask(Q.real(I * x), Q.real(x)) == False assert ask(Q.real(I * x), Q.imaginary(x)) == True assert ask(Q.real(I * x), Q.complex(x)) == None assert ask(Q.real(x**2), Q.real(x)) == True assert ask(Q.real(sqrt(x)), Q.negative(x)) == False assert ask(Q.real(x**y), Q.real(x) & Q.integer(y)) == True assert ask(Q.real(x**y), Q.real(x) & Q.real(y)) == None assert ask(Q.real(x**y), Q.positive(x) & Q.real(y)) == True # trigonometric functions assert ask(Q.real(sin(x))) == None assert ask(Q.real(cos(x))) == None assert ask(Q.real(sin(x)), Q.real(x)) == True assert ask(Q.real(cos(x)), Q.real(x)) == True # exponential function assert ask(Q.real(exp(x))) == None assert ask(Q.real(exp(x)), Q.real(x)) == True assert ask(Q.real(x + exp(x)), Q.real(x)) == True # Q.complexes assert ask(Q.real(re(x))) == True assert ask(Q.real(im(x))) == True
def test_functions_in_assumptions(): from sympy.logic.boolalg import Equivalent, Xor x = symbols('x') assert ask(Q.negative(x), Q.real(x) >> Q.positive(x)) is False assert ask(Q.negative(x), Equivalent(Q.real(x), Q.positive(x))) is False assert ask(Q.negative(x), Xor(Q.real(x), Q.negative(x))) is False
def test_composite_ask(): x = symbols('x') assert ask(Q.negative(x) & Q.integer(x), assumptions=Q.real(x) >> Q.positive(x)) is False
def _(expr, assumptions): if ask(Q.real(expr.exp), assumptions): return True if ask(Q.imaginary(expr.exp), assumptions): from sympy import pi, I return ask(Q.even(expr.exp / (I * pi)), assumptions)
def acot(expr, assumptions): return ask(Q.real(expr.args[0]), assumptions)
def _(expr, assumptions): """ * Real**Integer -> Real * Positive**Real -> Real * Real**(Integer/Even) -> Real if base is nonnegative * Real**(Integer/Odd) -> Real * Imaginary**(Integer/Even) -> Real * Imaginary**(Integer/Odd) -> not Real * Imaginary**Real -> ? since Real could be 0 (giving real) or 1 (giving imaginary) * b**Imaginary -> Real if log(b) is imaginary and b != 0 and exponent != integer multiple of I*pi/log(b) * Real**Real -> ? e.g. sqrt(-1) is imaginary and sqrt(2) is not """ if expr.is_number: return _RealPredicate_number(expr, assumptions) if expr.base == E: return ask( Q.integer(expr.exp / I / pi) | Q.real(expr.exp), assumptions) if expr.base.func == exp or (expr.base.is_Pow and expr.base.base == E): if ask(Q.imaginary(expr.base.exp), assumptions): if ask(Q.imaginary(expr.exp), assumptions): return True # If the i = (exp's arg)/(I*pi) is an integer or half-integer # multiple of I*pi then 2*i will be an integer. In addition, # exp(i*I*pi) = (-1)**i so the overall realness of the expr # can be determined by replacing exp(i*I*pi) with (-1)**i. i = expr.base.exp / I / pi if ask(Q.integer(2 * i), assumptions): return ask(Q.real((S.NegativeOne**i)**expr.exp), assumptions) return if ask(Q.imaginary(expr.base), assumptions): if ask(Q.integer(expr.exp), assumptions): odd = ask(Q.odd(expr.exp), assumptions) if odd is not None: return not odd return if ask(Q.imaginary(expr.exp), assumptions): imlog = ask(Q.imaginary(log(expr.base)), assumptions) if imlog is not None: # I**i -> real, log(I) is imag; # (2*I)**i -> complex, log(2*I) is not imag return imlog if ask(Q.real(expr.base), assumptions): if ask(Q.real(expr.exp), assumptions): if expr.exp.is_Rational and \ ask(Q.even(expr.exp.q), assumptions): return ask(Q.positive(expr.base), assumptions) elif ask(Q.integer(expr.exp), assumptions): return True elif ask(Q.positive(expr.base), assumptions): return True elif ask(Q.negative(expr.base), assumptions): return False
def sin(expr, assumptions): if ask(Q.real(expr.args[0]), assumptions): return True
def reduce_abs_inequality(expr, rel, gen, assume=True): """Reduce an inequality with nested absolute values. Examples ======== >>> from sympy import Q, Abs >>> from sympy.abc import x >>> from sympy.solvers.inequalities import reduce_abs_inequality >>> reduce_abs_inequality(Abs(x - 5) - 3, '<', x, assume=Q.real(x)) And(2 < x, x < 8) >>> reduce_abs_inequality(Abs(x + 2)*3 - 13, '<', x, assume=Q.real(x)) And(-19/3 < x, x < 7/3) See Also ======== reduce_abs_inequalities """ if not ask(Q.real(gen), assumptions=assume): raise NotImplementedError( "can't solve inequalities with absolute values of a complex variable" ) def _bottom_up_scan(expr): exprs = [] if expr.is_Add or expr.is_Mul: op = expr.__class__ for arg in expr.args: _exprs = _bottom_up_scan(arg) if not exprs: exprs = _exprs else: args = [] for expr, conds in exprs: for _expr, _conds in _exprs: args.append((op(expr, _expr), conds + _conds)) exprs = args elif expr.is_Pow: n = expr.exp if not n.is_Integer or n < 0: raise ValueError( "only non-negative integer powers are allowed") _exprs = _bottom_up_scan(expr.base) for expr, conds in _exprs: exprs.append((expr**n, conds)) elif isinstance(expr, Abs): _exprs = _bottom_up_scan(expr.args[0]) for expr, conds in _exprs: exprs.append((expr, conds + [Ge(expr, 0)])) exprs.append((-expr, conds + [Lt(expr, 0)])) else: exprs = [(expr, [])] return exprs exprs = _bottom_up_scan(expr) mapping = {'<': '>', '<=': '>='} inequalities = [] for expr, conds in exprs: if rel not in mapping.keys(): expr = Relational(expr, 0, rel) else: expr = Relational(-expr, 0, mapping[rel]) inequalities.append([expr] + conds) return reduce_poly_inequalities(inequalities, gen, assume)
def Basic(expr, assumptions): return fuzzy_and([fuzzy_not(ask(Q.nonzero(expr), assumptions)), ask(Q.real(expr), assumptions)])
def _(expr, assumptions): return ask(Q.real(expr), assumptions)
def test_complex(): x, y = symbols('x,y') assert ask(Q.complex(x)) == None assert ask(Q.complex(x), Q.complex(x)) == True assert ask(Q.complex(x), Q.complex(y)) == None assert ask(Q.complex(x), ~Q.complex(x)) == False assert ask(Q.complex(x), Q.real(x)) == True assert ask(Q.complex(x), ~Q.real(x)) == None assert ask(Q.complex(x), Q.rational(x)) == True assert ask(Q.complex(x), Q.irrational(x)) == True assert ask(Q.complex(x), Q.positive(x)) == True assert ask(Q.complex(x), Q.imaginary(x)) == True # a+b assert ask(Q.complex(x + 1), Q.complex(x)) == True assert ask(Q.complex(x + 1), Q.real(x)) == True assert ask(Q.complex(x + 1), Q.rational(x)) == True assert ask(Q.complex(x + 1), Q.irrational(x)) == True assert ask(Q.complex(x + 1), Q.imaginary(x)) == True assert ask(Q.complex(x + 1), Q.integer(x)) == True assert ask(Q.complex(x + 1), Q.even(x)) == True assert ask(Q.complex(x + 1), Q.odd(x)) == True assert ask(Q.complex(x + y), Q.complex(x) & Q.complex(y)) == True assert ask(Q.complex(x + y), Q.real(x) & Q.imaginary(y)) == True # a*x +b assert ask(Q.complex(2 * x + 1), Q.complex(x)) == True assert ask(Q.complex(2 * x + 1), Q.real(x)) == True assert ask(Q.complex(2 * x + 1), Q.positive(x)) == True assert ask(Q.complex(2 * x + 1), Q.rational(x)) == True assert ask(Q.complex(2 * x + 1), Q.irrational(x)) == True assert ask(Q.complex(2 * x + 1), Q.imaginary(x)) == True assert ask(Q.complex(2 * x + 1), Q.integer(x)) == True assert ask(Q.complex(2 * x + 1), Q.even(x)) == True assert ask(Q.complex(2 * x + 1), Q.odd(x)) == True # x**2 assert ask(Q.complex(x**2), Q.complex(x)) == True assert ask(Q.complex(x**2), Q.real(x)) == True assert ask(Q.complex(x**2), Q.positive(x)) == True assert ask(Q.complex(x**2), Q.rational(x)) == True assert ask(Q.complex(x**2), Q.irrational(x)) == True assert ask(Q.complex(x**2), Q.imaginary(x)) == True assert ask(Q.complex(x**2), Q.integer(x)) == True assert ask(Q.complex(x**2), Q.even(x)) == True assert ask(Q.complex(x**2), Q.odd(x)) == True # 2**x assert ask(Q.complex(2**x), Q.complex(x)) == True assert ask(Q.complex(2**x), Q.real(x)) == True assert ask(Q.complex(2**x), Q.positive(x)) == True assert ask(Q.complex(2**x), Q.rational(x)) == True assert ask(Q.complex(2**x), Q.irrational(x)) == True assert ask(Q.complex(2**x), Q.imaginary(x)) == True assert ask(Q.complex(2**x), Q.integer(x)) == True assert ask(Q.complex(2**x), Q.even(x)) == True assert ask(Q.complex(2**x), Q.odd(x)) == True assert ask(Q.complex(x**y), Q.complex(x) & Q.complex(y)) == True # trigonometric expressions assert ask(Q.complex(sin(x))) == True assert ask(Q.complex(sin(2 * x + 1))) == True assert ask(Q.complex(cos(x))) == True assert ask(Q.complex(cos(2 * x + 1))) == True # exponential assert ask(Q.complex(exp(x))) == True assert ask(Q.complex(exp(x))) == True # Q.complexes assert ask(Q.complex(Abs(x))) == True assert ask(Q.complex(re(x))) == True assert ask(Q.complex(im(x))) == True
def exp(expr, assumptions): if ask(Q.real(expr.args[0]), assumptions): return False
def _(expr, assumptions): if ask(Q.real(expr.exp), assumptions): return False
def exp(expr, assumptions): return ask( Q.integer(expr.args[0] / I / pi) | Q.real(expr.args[0]), assumptions)
def _(expr, assumptions): if isinstance(expr, MatrixBase): return None return ask(Q.real(expr), assumptions)
def test_positive_xfail(): assert ask(Q.positive(1 / (1 + x**2)), Q.real(x)) == True
def exp(expr, assumptions): if ask(Q.real(expr.args[0]), assumptions): return True if ask(Q.imaginary(expr.args[0]), assumptions): return False
def refine_Pow(expr, assumptions): """ Handler for instances of Pow. >>> from sympy import Symbol, Q >>> from sympy.assumptions.refine import refine_Pow >>> from sympy.abc import x,y,z >>> refine_Pow((-1)**x, Q.real(x)) >>> refine_Pow((-1)**x, Q.even(x)) 1 >>> refine_Pow((-1)**x, Q.odd(x)) -1 For powers of -1, even parts of the exponent can be simplified: >>> refine_Pow((-1)**(x+y), Q.even(x)) (-1)**y >>> refine_Pow((-1)**(x+y+z), Q.odd(x) & Q.odd(z)) (-1)**y >>> refine_Pow((-1)**(x+y+2), Q.odd(x)) (-1)**(y + 1) >>> refine_Pow((-1)**(x+3), True) (-1)**(x + 1) """ from sympy.core import Pow, Rational from sympy.functions.elementary.complexes import Abs from sympy.functions import sign if isinstance(expr.base, Abs): if ask(Q.real(expr.base.args[0]), assumptions) and \ ask(Q.even(expr.exp), assumptions): return expr.base.args[0]**expr.exp if ask(Q.real(expr.base), assumptions): if expr.base.is_number: if ask(Q.even(expr.exp), assumptions): return abs(expr.base)**expr.exp if ask(Q.odd(expr.exp), assumptions): return sign(expr.base) * abs(expr.base)**expr.exp if isinstance(expr.exp, Rational): if type(expr.base) is Pow: return abs(expr.base.base)**(expr.base.exp * expr.exp) if expr.base is S.NegativeOne: if expr.exp.is_Add: old = expr # For powers of (-1) we can remove # - even terms # - pairs of odd terms # - a single odd term + 1 # - A numerical constant N can be replaced with mod(N,2) coeff, terms = expr.exp.as_coeff_add() terms = set(terms) even_terms = set([]) odd_terms = set([]) initial_number_of_terms = len(terms) for t in terms: if ask(Q.even(t), assumptions): even_terms.add(t) elif ask(Q.odd(t), assumptions): odd_terms.add(t) terms -= even_terms if len(odd_terms) % 2: terms -= odd_terms new_coeff = (coeff + S.One) % 2 else: terms -= odd_terms new_coeff = coeff % 2 if new_coeff != coeff or len(terms) < initial_number_of_terms: terms.add(new_coeff) expr = expr.base**(Add(*terms)) # Handle (-1)**((-1)**n/2 + m/2) e2 = 2 * expr.exp if ask(Q.even(e2), assumptions): if e2.could_extract_minus_sign(): e2 *= expr.base if e2.is_Add: i, p = e2.as_two_terms() if p.is_Pow and p.base is S.NegativeOne: if ask(Q.integer(p.exp), assumptions): i = (i + 1) / 2 if ask(Q.even(i), assumptions): return expr.base**p.exp elif ask(Q.odd(i), assumptions): return expr.base**(p.exp + 1) else: return expr.base**(p.exp + i) if old != expr: return expr
def reduce_rational_inequalities(exprs, gen, assume=True, relational=True): """Reduce a system of rational inequalities with rational coefficients. Examples ======== >>> from sympy import Poly, Symbol >>> from sympy.solvers.inequalities import reduce_rational_inequalities >>> x = Symbol('x', real=True) >>> reduce_rational_inequalities([[x**2 <= 0]], x) x == 0 >>> reduce_rational_inequalities([[x + 2 > 0]], x) x > -2 >>> reduce_rational_inequalities([[(x + 2, ">")]], x) x > -2 >>> reduce_rational_inequalities([[x + 2]], x) x == -2 """ exact = True eqs = [] for _exprs in exprs: _eqs = [] for expr in _exprs: if isinstance(expr, tuple): expr, rel = expr else: if expr.is_Relational: expr, rel = expr.lhs - expr.rhs, expr.rel_op else: expr, rel = expr, '==' try: (numer, denom), opt = parallel_poly_from_expr( expr.together().as_numer_denom(), gen) except PolynomialError: raise PolynomialError( "only polynomials and " "rational functions are supported in this context") if not opt.domain.is_Exact: numer, denom, exact = numer.to_exact(), denom.to_exact(), False domain = opt.domain.get_exact() if not (domain.is_ZZ or domain.is_QQ): raise NotImplementedError( "inequality solving is not supported over %s" % opt.domain) _eqs.append(((numer, denom), rel)) eqs.append(_eqs) solution = solve_rational_inequalities(eqs) if not exact: solution = solution.evalf() if not relational: return solution real = ask(Q.real(gen), assumptions=assume) if not real: result = And(solution.as_relational(re(gen)), Eq(im(gen), 0)) else: result = solution.as_relational(gen) return result
def _(expr, assumptions): if ask(Q.real(expr.exp), assumptions): return False raise MDNotImplementedError
def re(expr, assumptions): if ask(Q.real(expr.args[0]), assumptions): return ask(Q.even(expr.args[0]), assumptions)
def test_pi(): z = S.Pi assert ask(Q.commutative(z)) == True assert ask(Q.integer(z)) == False assert ask(Q.rational(z)) == False assert ask(Q.real(z)) == True assert ask(Q.complex(z)) == True assert ask(Q.irrational(z)) == True assert ask(Q.imaginary(z)) == False assert ask(Q.positive(z)) == True assert ask(Q.negative(z)) == False assert ask(Q.even(z)) == False assert ask(Q.odd(z)) == False assert ask(Q.bounded(z)) == True assert ask(Q.infinitesimal(z)) == False assert ask(Q.prime(z)) == False assert ask(Q.composite(z)) == False z = S.Pi + 1 assert ask(Q.commutative(z)) == True assert ask(Q.integer(z)) == False assert ask(Q.rational(z)) == False assert ask(Q.real(z)) == True assert ask(Q.complex(z)) == True assert ask(Q.irrational(z)) == True assert ask(Q.imaginary(z)) == False assert ask(Q.positive(z)) == True assert ask(Q.negative(z)) == False assert ask(Q.even(z)) == False assert ask(Q.odd(z)) == False assert ask(Q.bounded(z)) == True assert ask(Q.infinitesimal(z)) == False assert ask(Q.prime(z)) == False assert ask(Q.composite(z)) == False z = 2 * S.Pi assert ask(Q.commutative(z)) == True assert ask(Q.integer(z)) == False assert ask(Q.rational(z)) == False assert ask(Q.real(z)) == True assert ask(Q.complex(z)) == True assert ask(Q.irrational(z)) == True assert ask(Q.imaginary(z)) == False assert ask(Q.positive(z)) == True assert ask(Q.negative(z)) == False assert ask(Q.even(z)) == False assert ask(Q.odd(z)) == False assert ask(Q.bounded(z)) == True assert ask(Q.infinitesimal(z)) == False assert ask(Q.prime(z)) == False assert ask(Q.composite(z)) == False z = S.Pi**2 assert ask(Q.commutative(z)) == True assert ask(Q.integer(z)) == False assert ask(Q.rational(z)) == False assert ask(Q.real(z)) == True assert ask(Q.complex(z)) == True assert ask(Q.irrational(z)) == True assert ask(Q.imaginary(z)) == False assert ask(Q.positive(z)) == True assert ask(Q.negative(z)) == False assert ask(Q.even(z)) == False assert ask(Q.odd(z)) == False assert ask(Q.bounded(z)) == True assert ask(Q.infinitesimal(z)) == False assert ask(Q.prime(z)) == False assert ask(Q.composite(z)) == False z = (1 + S.Pi)**2 assert ask(Q.commutative(z)) == True assert ask(Q.integer(z)) == False assert ask(Q.rational(z)) == False assert ask(Q.real(z)) == True assert ask(Q.complex(z)) == True assert ask(Q.irrational(z)) == True assert ask(Q.imaginary(z)) == False assert ask(Q.positive(z)) == True assert ask(Q.negative(z)) == False assert ask(Q.even(z)) == False assert ask(Q.odd(z)) == False assert ask(Q.bounded(z)) == True assert ask(Q.infinitesimal(z)) == False assert ask(Q.prime(z)) == False assert ask(Q.composite(z)) == False
def refine_Pow(expr, assumptions): """ Handler for instances of Pow. >>> from sympy import Symbol, Q >>> from sympy.assumptions.refine import refine_Pow >>> from sympy.abc import x,y,z >>> refine_Pow((-1)**x, Q.real(x)) >>> refine_Pow((-1)**x, Q.even(x)) 1 >>> refine_Pow((-1)**x, Q.odd(x)) -1 For powers of -1, even parts of the exponent can be simplified: >>> refine_Pow((-1)**(x+y), Q.even(x)) (-1)**y >>> refine_Pow((-1)**(x+y+z), Q.odd(x) & Q.odd(z)) (-1)**y >>> refine_Pow((-1)**(x+y+2), Q.odd(x)) (-1)**(y + 1) >>> refine_Pow((-1)**(x+3), True) (-1)**(x + 1) """ from sympy.core import Pow, Rational from sympy.functions import sign if ask(Q.real(expr.base), assumptions): if expr.base.is_number: if ask(Q.even(expr.exp), assumptions): return abs(expr.base) ** expr.exp if ask(Q.odd(expr.exp), assumptions): return sign(expr.base) * abs(expr.base) ** expr.exp if isinstance(expr.exp, Rational): if type(expr.base) is Pow: return abs(expr.base.base) ** (expr.base.exp * expr.exp) if expr.base is S.NegativeOne: if expr.exp.is_Add: # For powers of (-1) we can remove # - even terms # - pairs of odd terms # - a single odd term + 1 # - A numerical constant N can be replaced with mod(N,2) coeff, terms = expr.exp.as_coeff_add() terms = set(terms) even_terms = set([]) odd_terms = set([]) initial_number_of_terms = len(terms) for t in terms: if ask(Q.even(t), assumptions): even_terms.add(t) elif ask(Q.odd(t), assumptions): odd_terms.add(t) terms -= even_terms if len(odd_terms) % 2: terms -= odd_terms new_coeff = (coeff + S.One) % 2 else: terms -= odd_terms new_coeff = coeff % 2 if new_coeff != coeff or len(terms) < initial_number_of_terms: terms.add(new_coeff) return expr.base**(Add(*terms))
def reduce_poly_inequalities(exprs, gen, assume=True, relational=True): """Reduce a system of polynomial inequalities with rational coefficients. Examples ======== >>> from sympy import Poly, Symbol >>> from sympy.solvers.inequalities import reduce_poly_inequalities >>> x = Symbol('x', real=True) >>> reduce_poly_inequalities([[x**2 <= 0]], x) x == 0 >>> reduce_poly_inequalities([[x + 2 > 0]], x) -2 < x """ exact = True polys = [] for _exprs in exprs: _polys = [] for expr in _exprs: if isinstance(expr, tuple): expr, rel = expr else: if expr.is_Relational: expr, rel = expr.lhs - expr.rhs, expr.rel_op else: expr, rel = expr, '==' poly = Poly(expr, gen) if not poly.get_domain().is_Exact: poly, exact = poly.to_exact(), False domain = poly.get_domain() if not (domain.is_ZZ or domain.is_QQ): raise NotImplementedError( "inequality solving is not supported over %s" % domain) _polys.append((poly, rel)) polys.append(_polys) solution = solve_poly_inequalities(polys) if not exact: solution = solution.evalf() if not relational: return solution real = ask(Q.real(gen), assumptions=assume) if not real: result = And(solution.as_relational(re(gen)), Eq(im(gen), 0)) else: result = solution.as_relational(gen) return result
def _(expr, assumptions): return ask(Q.integer(expr.exp / I / pi) | Q.real(expr.exp), assumptions)