ó ~9­\c%@ s dZddlmZmZddlmZmZmZddlm Z ddl m Z ddl m Z ddlmZddlmZmZmZmZmZmZmZmZdd lmZdd lmZd d d gZiZeeƒZde fd„ƒYZ!e!ƒZ"e#d„Z$e#ed„Z%d„Z&d„Z'd„Z(d„Z)d„Z*dZ+ddfddfddfddfd d!fd"d#fd$d%fd&d'fd(d)fd*d+fd,d-fd.d/fd0d1fd2d3fd4d5fd6d7fd8d9fd:d;fd<d=fd>d?fd@dAfdBdCfdDdEfdFdGfdHdIfdJdKfdLdMfdNdOfdPdQfdRdSfdTdUfdVdWfdXdYfdZd[fd\d]fd^d_fg$Z,x%e,D]\Z-Z.e'e-e+e.ƒq±We d`„ƒZ/e da„ƒZ0ddbl1m2Z2m3Z3dcS(ds4Module for querying SymPy objects about assumptions.iÿÿÿÿ(tprint_functiontdivision(tglobal_assumptionst PredicatetAppliedPredicate(tsympify(tcacheit(t deprecated(t Relational(tto_cnftAndtNottOrtImpliest EquivalenttBooleanFunctiont BooleanAtom(t satisfiable(tmemoize_propertytboundedtinfinityt infinitesimaltAssumptionKeyscB seZdZed„ƒZed„ƒZed„ƒZed„ƒZed„ƒZed„ƒZ ed„ƒZ ed„ƒZ ed „ƒZ ed „ƒZ ed „ƒZed „ƒZeed dddddƒd„ƒƒZed„ƒZeed dddddƒd„ƒƒZeed dddddƒd„ƒƒZed„ƒZed„ƒZed„ƒZed„ƒZed„ƒZed „ƒZed!„ƒZed"„ƒZed#„ƒZed$„ƒZed%„ƒZed&„ƒZ ed'„ƒZ!ed(„ƒZ"ed)„ƒZ#ed*„ƒZ$ed+„ƒZ%ed,„ƒZ&ed-„ƒZ'ed.„ƒZ(ed/„ƒZ)ed0„ƒZ*ed1„ƒZ+ed2„ƒZ,ed3„ƒZ-ed4„ƒZ.ed5„ƒZ/ed6„ƒZ0ed7„ƒZ1RS(8s@ This class contains all the supported keys by ``ask``. cC s tdƒS(sø Hermitian predicate. ``ask(Q.hermitian(x))`` is true iff ``x`` belongs to the set of Hermitian operators. References ========== .. [1] http://mathworld.wolfram.com/HermitianOperator.html t hermitian(R(tself((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR$scC s tdƒS(sH Antihermitian predicate. ``Q.antihermitian(x)`` is true iff ``x`` belongs to the field of antihermitian operators, i.e., operators in the form ``x*I``, where ``x`` is Hermitian. References ========== .. [1] http://mathworld.wolfram.com/HermitianOperator.html t antihermitian(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR5scC s tdƒS(s@ Real number predicate. ``Q.real(x)`` is true iff ``x`` is a real number, i.e., it is in the interval `(-\infty, \infty)`. Note that, in particular the infinities are not real. Use ``Q.extended_real`` if you want to consider those as well. A few important facts about reals: - Every real number is positive, negative, or zero. Furthermore, because these sets are pairwise disjoint, each real number is exactly one of those three. - Every real number is also complex. - Every real number is finite. - Every real number is either rational or irrational. - Every real number is either algebraic or transcendental. - The facts ``Q.negative``, ``Q.zero``, ``Q.positive``, ``Q.nonnegative``, ``Q.nonpositive``, ``Q.nonzero``, ``Q.integer``, ``Q.rational``, and ``Q.irrational`` all imply ``Q.real``, as do all facts that imply those facts. - The facts ``Q.algebraic``, and ``Q.transcendental`` do not imply ``Q.real``; they imply ``Q.complex``. An algebraic or transcendental number may or may not be real. - The "non" facts (i.e., ``Q.nonnegative``, ``Q.nonzero``, ``Q.nonpositive`` and ``Q.noninteger``) are not equivalent to not the fact, but rather, not the fact *and* ``Q.real``. For example, ``Q.nonnegative`` means ``~Q.negative & Q.real``. So for example, ``I`` is not nonnegative, nonzero, or nonpositive. Examples ======== >>> from sympy import Q, ask, symbols >>> x = symbols('x') >>> ask(Q.real(x), Q.positive(x)) True >>> ask(Q.real(0)) True References ========== .. [1] https://en.wikipedia.org/wiki/Real_number treal(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyRGs7cC s tdƒS(sÈ Extended real predicate. ``Q.extended_real(x)`` is true iff ``x`` is a real number or `\{-\infty, \infty\}`. See documentation of ``Q.real`` for more information about related facts. Examples ======== >>> from sympy import ask, Q, oo, I >>> ask(Q.extended_real(1)) True >>> ask(Q.extended_real(I)) False >>> ask(Q.extended_real(oo)) True t extended_real(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR€scC s tdƒS(s; Imaginary number predicate. ``Q.imaginary(x)`` is true iff ``x`` can be written as a real number multiplied by the imaginary unit ``I``. Please note that ``0`` is not considered to be an imaginary number. Examples ======== >>> from sympy import Q, ask, I >>> ask(Q.imaginary(3*I)) True >>> ask(Q.imaginary(2 + 3*I)) False >>> ask(Q.imaginary(0)) False References ========== .. [1] https://en.wikipedia.org/wiki/Imaginary_number t imaginary(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR˜scC s tdƒS(s Complex number predicate. ``Q.complex(x)`` is true iff ``x`` belongs to the set of complex numbers. Note that every complex number is finite. Examples ======== >>> from sympy import Q, Symbol, ask, I, oo >>> x = Symbol('x') >>> ask(Q.complex(0)) True >>> ask(Q.complex(2 + 3*I)) True >>> ask(Q.complex(oo)) False References ========== .. [1] https://en.wikipedia.org/wiki/Complex_number tcomplex(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR´scC s tdƒS(sE Algebraic number predicate. ``Q.algebraic(x)`` is true iff ``x`` belongs to the set of algebraic numbers. ``x`` is algebraic if there is some polynomial in ``p(x)\in \mathbb\{Q\}[x]`` such that ``p(x) = 0``. Examples ======== >>> from sympy import ask, Q, sqrt, I, pi >>> ask(Q.algebraic(sqrt(2))) True >>> ask(Q.algebraic(I)) True >>> ask(Q.algebraic(pi)) False References ========== .. [1] https://en.wikipedia.org/wiki/Algebraic_number t algebraic(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyRÐscC s tdƒS(sî Transcedental number predicate. ``Q.transcendental(x)`` is true iff ``x`` belongs to the set of transcendental numbers. A transcendental number is a real or complex number that is not algebraic. ttranscendental(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyRës cC s tdƒS(s} Integer predicate. ``Q.integer(x)`` is true iff ``x`` belongs to the set of integer numbers. Examples ======== >>> from sympy import Q, ask, S >>> ask(Q.integer(5)) True >>> ask(Q.integer(S(1)/2)) False References ========== .. [1] https://en.wikipedia.org/wiki/Integer tinteger(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR øscC s tdƒS(sà Rational number predicate. ``Q.rational(x)`` is true iff ``x`` belongs to the set of rational numbers. Examples ======== >>> from sympy import ask, Q, pi, S >>> ask(Q.rational(0)) True >>> ask(Q.rational(S(1)/2)) True >>> ask(Q.rational(pi)) False References ========== https://en.wikipedia.org/wiki/Rational_number trational(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR!scC s tdƒS(s& Irrational number predicate. ``Q.irrational(x)`` is true iff ``x`` is any real number that cannot be expressed as a ratio of integers. Examples ======== >>> from sympy import ask, Q, pi, S, I >>> ask(Q.irrational(0)) False >>> ask(Q.irrational(S(1)/2)) False >>> ask(Q.irrational(pi)) True >>> ask(Q.irrational(I)) False References ========== .. [1] https://en.wikipedia.org/wiki/Irrational_number t irrational(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR"+scC s tdƒS(sh Finite predicate. ``Q.finite(x)`` is true if ``x`` is neither an infinity nor a ``NaN``. In other words, ``ask(Q.finite(x))`` is true for all ``x`` having a bounded absolute value. Examples ======== >>> from sympy import Q, ask, Symbol, S, oo, I >>> x = Symbol('x') >>> ask(Q.finite(S.NaN)) False >>> ask(Q.finite(oo)) False >>> ask(Q.finite(1)) True >>> ask(Q.finite(2 + 3*I)) True References ========== .. [1] https://en.wikipedia.org/wiki/Finite tfinite(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR#Hst useinsteadR#tissueiÑ$tdeprecated_since_versions1.0cC s tdƒS(s4 See documentation of ``Q.finite``. R#(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyRgscC s tdƒS(s… Infinite number predicate. ``Q.infinite(x)`` is true iff the absolute value of ``x`` is infinity. tinfinite(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR'os R'iÒ$cC s tdƒS(s6 See documentation of ``Q.infinite``. R'(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR{stzeroiË%cC s tdƒS(s2 See documentation of ``Q.zero``. R((R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyRƒscC s tdƒS(s~ Positive real number predicate. ``Q.positive(x)`` is true iff ``x`` is real and `x > 0`, that is if ``x`` is in the interval `(0, \infty)`. In particular, infinity is not positive. A few important facts about positive numbers: - Note that ``Q.nonpositive`` and ``~Q.positive`` are *not* the same thing. ``~Q.positive(x)`` simply means that ``x`` is not positive, whereas ``Q.nonpositive(x)`` means that ``x`` is real and not positive, i.e., ``Q.nonpositive(x)`` is logically equivalent to `Q.negative(x) | Q.zero(x)``. So for example, ``~Q.positive(I)`` is true, whereas ``Q.nonpositive(I)`` is false. - See the documentation of ``Q.real`` for more information about related facts. Examples ======== >>> from sympy import Q, ask, symbols, I >>> x = symbols('x') >>> ask(Q.positive(x), Q.real(x) & ~Q.negative(x) & ~Q.zero(x)) True >>> ask(Q.positive(1)) True >>> ask(Q.nonpositive(I)) False >>> ask(~Q.positive(I)) True tpositive(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR)‹s$cC s tdƒS(sž Negative number predicate. ``Q.negative(x)`` is true iff ``x`` is a real number and :math:`x < 0`, that is, it is in the interval :math:`(-\infty, 0)`. Note in particular that negative infinity is not negative. A few important facts about negative numbers: - Note that ``Q.nonnegative`` and ``~Q.negative`` are *not* the same thing. ``~Q.negative(x)`` simply means that ``x`` is not negative, whereas ``Q.nonnegative(x)`` means that ``x`` is real and not negative, i.e., ``Q.nonnegative(x)`` is logically equivalent to ``Q.zero(x) | Q.positive(x)``. So for example, ``~Q.negative(I)`` is true, whereas ``Q.nonnegative(I)`` is false. - See the documentation of ``Q.real`` for more information about related facts. Examples ======== >>> from sympy import Q, ask, symbols, I >>> x = symbols('x') >>> ask(Q.negative(x), Q.real(x) & ~Q.positive(x) & ~Q.zero(x)) True >>> ask(Q.negative(-1)) True >>> ask(Q.nonnegative(I)) False >>> ask(~Q.negative(I)) True tnegative(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR*±s$cC s tdƒS(sÏ Zero number predicate. ``ask(Q.zero(x))`` is true iff the value of ``x`` is zero. Examples ======== >>> from sympy import ask, Q, oo, symbols >>> x, y = symbols('x, y') >>> ask(Q.zero(0)) True >>> ask(Q.zero(1/oo)) True >>> ask(Q.zero(0*oo)) False >>> ask(Q.zero(1)) False >>> ask(Q.zero(x*y), Q.zero(x) | Q.zero(y)) True R((R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR(×scC s tdƒS(s  Nonzero real number predicate. ``ask(Q.nonzero(x))`` is true iff ``x`` is real and ``x`` is not zero. Note in particular that ``Q.nonzero(x)`` is false if ``x`` is not real. Use ``~Q.zero(x)`` if you want the negation of being zero without any real assumptions. A few important facts about nonzero numbers: - ``Q.nonzero`` is logically equivalent to ``Q.positive | Q.negative``. - See the documentation of ``Q.real`` for more information about related facts. Examples ======== >>> from sympy import Q, ask, symbols, I, oo >>> x = symbols('x') >>> print(ask(Q.nonzero(x), ~Q.zero(x))) None >>> ask(Q.nonzero(x), Q.positive(x)) True >>> ask(Q.nonzero(x), Q.zero(x)) False >>> ask(Q.nonzero(0)) False >>> ask(Q.nonzero(I)) False >>> ask(~Q.zero(I)) True >>> ask(Q.nonzero(oo)) #doctest: +SKIP False tnonzero(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR+ñs&cC s tdƒS(s˜ Nonpositive real number predicate. ``ask(Q.nonpositive(x))`` is true iff ``x`` belongs to the set of negative numbers including zero. - Note that ``Q.nonpositive`` and ``~Q.positive`` are *not* the same thing. ``~Q.positive(x)`` simply means that ``x`` is not positive, whereas ``Q.nonpositive(x)`` means that ``x`` is real and not positive, i.e., ``Q.nonpositive(x)`` is logically equivalent to `Q.negative(x) | Q.zero(x)``. So for example, ``~Q.positive(I)`` is true, whereas ``Q.nonpositive(I)`` is false. Examples ======== >>> from sympy import Q, ask, I >>> ask(Q.nonpositive(-1)) True >>> ask(Q.nonpositive(0)) True >>> ask(Q.nonpositive(1)) False >>> ask(Q.nonpositive(I)) False >>> ask(Q.nonpositive(-I)) False t nonpositive(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR,scC s tdƒS(s™ Nonnegative real number predicate. ``ask(Q.nonnegative(x))`` is true iff ``x`` belongs to the set of positive numbers including zero. - Note that ``Q.nonnegative`` and ``~Q.negative`` are *not* the same thing. ``~Q.negative(x)`` simply means that ``x`` is not negative, whereas ``Q.nonnegative(x)`` means that ``x`` is real and not negative, i.e., ``Q.nonnegative(x)`` is logically equivalent to ``Q.zero(x) | Q.positive(x)``. So for example, ``~Q.negative(I)`` is true, whereas ``Q.nonnegative(I)`` is false. Examples ======== >>> from sympy import Q, ask, I >>> ask(Q.nonnegative(1)) True >>> ask(Q.nonnegative(0)) True >>> ask(Q.nonnegative(-1)) False >>> ask(Q.nonnegative(I)) False >>> ask(Q.nonnegative(-I)) False t nonnegative(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR-:scC s tdƒS(st Even number predicate. ``ask(Q.even(x))`` is true iff ``x`` belongs to the set of even integers. Examples ======== >>> from sympy import Q, ask, pi >>> ask(Q.even(0)) True >>> ask(Q.even(2)) True >>> ask(Q.even(3)) False >>> ask(Q.even(pi)) False teven(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR.[scC s tdƒS(se Odd number predicate. ``ask(Q.odd(x))`` is true iff ``x`` belongs to the set of odd numbers. Examples ======== >>> from sympy import Q, ask, pi >>> ask(Q.odd(0)) False >>> ask(Q.odd(2)) False >>> ask(Q.odd(3)) True >>> ask(Q.odd(pi)) False todd(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR/sscC s tdƒS(sî Prime number predicate. ``ask(Q.prime(x))`` is true iff ``x`` is a natural number greater than 1 that has no positive divisors other than ``1`` and the number itself. Examples ======== >>> from sympy import Q, ask >>> ask(Q.prime(0)) False >>> ask(Q.prime(1)) False >>> ask(Q.prime(2)) True >>> ask(Q.prime(20)) False >>> ask(Q.prime(-3)) False tprime(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR0ŠscC s tdƒS(sÎ Composite number predicate. ``ask(Q.composite(x))`` is true iff ``x`` is a positive integer and has at least one positive divisor other than ``1`` and the number itself. Examples ======== >>> from sympy import Q, ask >>> ask(Q.composite(0)) False >>> ask(Q.composite(1)) False >>> ask(Q.composite(2)) False >>> ask(Q.composite(20)) True t composite(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR1¥scC s tdƒS(s¯ Commutative predicate. ``ask(Q.commutative(x))`` is true iff ``x`` commutes with any other object with respect to multiplication operation. t commutative(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR2½s cC s tdƒS(s3 Generic predicate. ``ask(Q.is_true(x))`` is true iff ``x`` is true. This only makes sense if ``x`` is a predicate. Examples ======== >>> from sympy import ask, Q, symbols >>> x = symbols('x') >>> ask(Q.is_true(True)) True tis_true(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR3ÉscC s tdƒS(sÐ Symmetric matrix predicate. ``Q.symmetric(x)`` is true iff ``x`` is a square matrix and is equal to its transpose. Every square diagonal matrix is a symmetric matrix. Examples ======== >>> from sympy import Q, ask, MatrixSymbol >>> X = MatrixSymbol('X', 2, 2) >>> Y = MatrixSymbol('Y', 2, 3) >>> Z = MatrixSymbol('Z', 2, 2) >>> ask(Q.symmetric(X*Z), Q.symmetric(X) & Q.symmetric(Z)) True >>> ask(Q.symmetric(X + Z), Q.symmetric(X) & Q.symmetric(Z)) True >>> ask(Q.symmetric(Y)) False References ========== .. [1] https://en.wikipedia.org/wiki/Symmetric_matrix t symmetric(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR4ÜscC s tdƒS(sØ Invertible matrix predicate. ``Q.invertible(x)`` is true iff ``x`` is an invertible matrix. A square matrix is called invertible only if its determinant is 0. Examples ======== >>> from sympy import Q, ask, MatrixSymbol >>> X = MatrixSymbol('X', 2, 2) >>> Y = MatrixSymbol('Y', 2, 3) >>> Z = MatrixSymbol('Z', 2, 2) >>> ask(Q.invertible(X*Y), Q.invertible(X)) False >>> ask(Q.invertible(X*Z), Q.invertible(X) & Q.invertible(Z)) True >>> ask(Q.invertible(X), Q.fullrank(X) & Q.square(X)) True References ========== .. [1] https://en.wikipedia.org/wiki/Invertible_matrix t invertible(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR5ýscC s tdƒS(s® Orthogonal matrix predicate. ``Q.orthogonal(x)`` is true iff ``x`` is an orthogonal matrix. A square matrix ``M`` is an orthogonal matrix if it satisfies ``M^TM = MM^T = I`` where ``M^T`` is the transpose matrix of ``M`` and ``I`` is an identity matrix. Note that an orthogonal matrix is necessarily invertible. Examples ======== >>> from sympy import Q, ask, MatrixSymbol, Identity >>> X = MatrixSymbol('X', 2, 2) >>> Y = MatrixSymbol('Y', 2, 3) >>> Z = MatrixSymbol('Z', 2, 2) >>> ask(Q.orthogonal(Y)) False >>> ask(Q.orthogonal(X*Z*X), Q.orthogonal(X) & Q.orthogonal(Z)) True >>> ask(Q.orthogonal(Identity(3))) True >>> ask(Q.invertible(X), Q.orthogonal(X)) True References ========== .. [1] https://en.wikipedia.org/wiki/Orthogonal_matrix t orthogonal(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR6s!cC s tdƒS(s6 Unitary matrix predicate. ``Q.unitary(x)`` is true iff ``x`` is a unitary matrix. Unitary matrix is an analogue to orthogonal matrix. A square matrix ``M`` with complex elements is unitary if :math:``M^TM = MM^T= I`` where :math:``M^T`` is the conjugate transpose matrix of ``M``. Examples ======== >>> from sympy import Q, ask, MatrixSymbol, Identity >>> X = MatrixSymbol('X', 2, 2) >>> Y = MatrixSymbol('Y', 2, 3) >>> Z = MatrixSymbol('Z', 2, 2) >>> ask(Q.unitary(Y)) False >>> ask(Q.unitary(X*Z*X), Q.unitary(X) & Q.unitary(Z)) True >>> ask(Q.unitary(Identity(3))) True References ========== .. [1] https://en.wikipedia.org/wiki/Unitary_matrix tunitary(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR7>scC s tdƒS(s= Positive definite matrix predicate. If ``M`` is a :math:``n \times n`` symmetric real matrix, it is said to be positive definite if :math:`Z^TMZ` is positive for every non-zero column vector ``Z`` of ``n`` real numbers. Examples ======== >>> from sympy import Q, ask, MatrixSymbol, Identity >>> X = MatrixSymbol('X', 2, 2) >>> Y = MatrixSymbol('Y', 2, 3) >>> Z = MatrixSymbol('Z', 2, 2) >>> ask(Q.positive_definite(Y)) False >>> ask(Q.positive_definite(Identity(3))) True >>> ask(Q.positive_definite(X + Z), Q.positive_definite(X) & ... Q.positive_definite(Z)) True References ========== .. [1] https://en.wikipedia.org/wiki/Positive-definite_matrix tpositive_definite(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR8^scC s tdƒS(së Upper triangular matrix predicate. A matrix ``M`` is called upper triangular matrix if :math:`M_{ij}=0` for :math:`i>> from sympy import Q, ask, ZeroMatrix, Identity >>> ask(Q.upper_triangular(Identity(3))) True >>> ask(Q.upper_triangular(ZeroMatrix(3, 3))) True References ========== .. [1] http://mathworld.wolfram.com/UpperTriangularMatrix.html tupper_triangular(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR9~scC s tdƒS(sê Lower triangular matrix predicate. A matrix ``M`` is called lower triangular matrix if :math:`a_{ij}=0` for :math:`i>j`. Examples ======== >>> from sympy import Q, ask, ZeroMatrix, Identity >>> ask(Q.lower_triangular(Identity(3))) True >>> ask(Q.lower_triangular(ZeroMatrix(3, 3))) True References ========== .. [1] http://mathworld.wolfram.com/LowerTriangularMatrix.html tlower_triangular(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR:—scC s tdƒS(sq Diagonal matrix predicate. ``Q.diagonal(x)`` is true iff ``x`` is a diagonal matrix. A diagonal matrix is a matrix in which the entries outside the main diagonal are all zero. Examples ======== >>> from sympy import Q, ask, MatrixSymbol, ZeroMatrix >>> X = MatrixSymbol('X', 2, 2) >>> ask(Q.diagonal(ZeroMatrix(3, 3))) True >>> ask(Q.diagonal(X), Q.lower_triangular(X) & ... Q.upper_triangular(X)) True References ========== .. [1] https://en.wikipedia.org/wiki/Diagonal_matrix tdiagonal(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR;¯scC s tdƒS(s` Fullrank matrix predicate. ``Q.fullrank(x)`` is true iff ``x`` is a full rank matrix. A matrix is full rank if all rows and columns of the matrix are linearly independent. A square matrix is full rank iff its determinant is nonzero. Examples ======== >>> from sympy import Q, ask, MatrixSymbol, ZeroMatrix, Identity >>> X = MatrixSymbol('X', 2, 2) >>> ask(Q.fullrank(X.T), Q.fullrank(X)) True >>> ask(Q.fullrank(ZeroMatrix(3, 3))) False >>> ask(Q.fullrank(Identity(3))) True tfullrank(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR<ËscC s tdƒS(sš Square matrix predicate. ``Q.square(x)`` is true iff ``x`` is a square matrix. A square matrix is a matrix with the same number of rows and columns. Examples ======== >>> from sympy import Q, ask, MatrixSymbol, ZeroMatrix, Identity >>> X = MatrixSymbol('X', 2, 2) >>> Y = MatrixSymbol('X', 2, 3) >>> ask(Q.square(X)) True >>> ask(Q.square(Y)) False >>> ask(Q.square(ZeroMatrix(3, 3))) True >>> ask(Q.square(Identity(3))) True References ========== .. [1] https://en.wikipedia.org/wiki/Square_matrix tsquare(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR=äscC s tdƒS(s[ Integer elements matrix predicate. ``Q.integer_elements(x)`` is true iff all the elements of ``x`` are integers. Examples ======== >>> from sympy import Q, ask, MatrixSymbol >>> X = MatrixSymbol('X', 4, 4) >>> ask(Q.integer(X[1, 2]), Q.integer_elements(X)) True tinteger_elements(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR>scC s tdƒS(sS Real elements matrix predicate. ``Q.real_elements(x)`` is true iff all the elements of ``x`` are real numbers. Examples ======== >>> from sympy import Q, ask, MatrixSymbol >>> X = MatrixSymbol('X', 4, 4) >>> ask(Q.real(X[1, 2]), Q.real_elements(X)) True t real_elements(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR?scC s tdƒS(s­ Complex elements matrix predicate. ``Q.complex_elements(x)`` is true iff all the elements of ``x`` are complex numbers. Examples ======== >>> from sympy import Q, ask, MatrixSymbol >>> X = MatrixSymbol('X', 4, 4) >>> ask(Q.complex(X[1, 2]), Q.complex_elements(X)) True >>> ask(Q.complex_elements(X), Q.integer_elements(X)) True tcomplex_elements(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyR@)scC s tdƒS(sÕ Singular matrix predicate. A matrix is singular iff the value of its determinant is 0. Examples ======== >>> from sympy import Q, ask, MatrixSymbol >>> X = MatrixSymbol('X', 4, 4) >>> ask(Q.singular(X), Q.invertible(X)) False >>> ask(Q.singular(X), ~Q.invertible(X)) True References ========== .. [1] http://mathworld.wolfram.com/SingularMatrix.html tsingular(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyRA>scC s tdƒS(sŽ Normal matrix predicate. A matrix is normal if it commutes with its conjugate transpose. Examples ======== >>> from sympy import Q, ask, MatrixSymbol >>> X = MatrixSymbol('X', 4, 4) >>> ask(Q.normal(X), Q.unitary(X)) True References ========== .. [1] https://en.wikipedia.org/wiki/Normal_matrix tnormal(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyRBWscC s tdƒS(s Triangular matrix predicate. ``Q.triangular(X)`` is true if ``X`` is one that is either lower triangular or upper triangular. Examples ======== >>> from sympy import Q, ask, MatrixSymbol >>> X = MatrixSymbol('X', 4, 4) >>> ask(Q.triangular(X), Q.upper_triangular(X)) True >>> ask(Q.triangular(X), Q.lower_triangular(X)) True References ========== .. [1] https://en.wikipedia.org/wiki/Triangular_matrix t triangular(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyRCnscC s tdƒS(sQ Unit triangular matrix predicate. A unit triangular matrix is a triangular matrix with 1s on the diagonal. Examples ======== >>> from sympy import Q, ask, MatrixSymbol >>> X = MatrixSymbol('X', 4, 4) >>> ask(Q.triangular(X), Q.unit_triangular(X)) True tunit_triangular(R(R((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyRD‡s(2t__name__t __module__t__doc__tpredicate_memoRRRRRRRRR R!R"R#RRR'RRR)R*R(R+R,R-R.R/R0R1R2R3R4R5R6R7R8R9R:R;R<R=R>R?R@RARBRCRD(((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyRsb9 ' ''&&(!! !#  cC s¥t|tƒr@|r@t||jtƒ}|dk r=|Sq@nt|tƒrSdS|j|ƒsfdSt|tƒr’|j |kr‹|j SdSnt|t ƒr |j dj t tfkr |j dt krÖtnt }|g|j dj D] }|^qðŒ}ng|j D]}t||ƒ^q}t|t ƒrxg|D]}|dk rD|^qD}|rx|j |ŒSn|r¡td„|Dƒƒr¡|j |ŒSdS(s Helper for ask(). Extracts the facts relevant to the symbol from an assumption. Returns None if there is nothing to extract. Nics s|]}|dk VqdS(N(tNone(t.0tx((s4lib/python2.7/site-packages/sympy/assumptions/ask.pys ºs(t isinstanceRt_extract_factstreversedtFalseRItboolthasRtargtfuncR targsR R tall(texprtsymboltcheck_reversed_reltrevtclsRRRTRK((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyRMs.  +-%%c  sõddlm}t|ttttfƒs:tdƒ‚nt|ttttfƒsdtdƒ‚nt|tƒr|jt |j ƒ}}nt j t |ƒ}}t |t |Œƒ}t|ƒ}t||ƒ}tƒ}tƒ‰|rtt ||ƒƒtkrtd|ƒ‚n||ƒj|ƒ}|d k rFt|ƒS|d krh||d|d|ƒS|jr¢|ˆ|kr…tSt|ƒˆ|kr½tSnt|t ƒrqt‡fd†|jDƒƒrqxê|jD]} | jr|ˆ| krýtSt|ƒˆ| krjtSqÚt| tƒrÚ| jd jrÚ|ˆ| krMtSt|ƒˆ| krjtSqÚqÚWnLt|tƒr½t|tƒr½|jd jr½|jd ˆ|kr½tSnt|||ƒ}|d krñ||d|d|ƒS|S( sº Method for inferring properties about objects. **Syntax** * ask(proposition) * ask(proposition, assumptions) where ``proposition`` is any boolean expression Examples ======== >>> from sympy import ask, Q, pi >>> from sympy.abc import x, y >>> ask(Q.rational(pi)) False >>> ask(Q.even(x*y), Q.even(x) & Q.integer(y)) True >>> ask(Q.prime(4*x), Q.integer(x)) False **Remarks** Relations in assumptions are not implemented (yet), so the following will not give a meaningful result. >>> ask(Q.positive(x), Q.is_true(x > 0)) # doctest: +SKIP It is however a work in progress. iÿÿÿÿ(tsatasks.proposition must be a valid logical expressions.assumptions must be a valid logical expressionsinconsistent assumptions %st assumptionstcontextc3 s|]}|ˆkVqdS(N((RJtk(tknown_facts_dict(s4lib/python2.7/site-packages/sympy/assumptions/ask.pys siN(tsympy.assumptions.sataskR[RLRRRPRt TypeErrorRSRRRtQR3R R RMtget_known_facts_cnftget_known_facts_dictRROt ValueErrort _eval_askRItis_AtomtTrueR RURTRtask_full_inference( t propositionR\R]R[tkeyRVt local_factstknown_facts_cnftrestassum((R_s4lib/python2.7/site-packages/sympy/assumptions/ask.pytask¾s\!   !      cC sBtt|||ƒƒstStt||t|ƒƒƒs>tSdS(s9 Method for inferring properties about objects. N(RR ROR RhRI(RjR\Rm((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyRis cC sot|ƒtkr|j}ntt|dƒ}|dk rL|j|ƒntt|t|d|gƒƒdS(sŒ Register a handler in the ask system. key must be a string and handler a class inheriting from AskHandler:: >>> from sympy.assumptions import register_handler, ask, Q >>> from sympy.assumptions.handlers import AskHandler >>> class MersenneHandler(AskHandler): ... # Mersenne numbers are in the form 2**n - 1, n integer ... @staticmethod ... def Integer(expr, assumptions): ... from sympy import log ... return ask(Q.integer(log(expr + 1, 2))) >>> register_handler('mersenne', MersenneHandler) >>> ask(Q.mersenne(7)) True thandlersN(ttypeRtnametgetattrRbRIt add_handlertsetattr(RkthandlertQkey((s4lib/python2.7/site-packages/sympy/assumptions/ask.pytregister_handler+s   cC s8t|ƒtkr|j}ntt|ƒj|ƒdS(sFRemoves a handler from the ask system. Same syntax as register_handlerN(RrRRsRtRbtremove_handler(RkRw((s4lib/python2.7/site-packages/sympy/assumptions/ask.pyRzFs cC sni}xa|D]Y}|h||s"matrices.AskIntegerElementsHandlerR?smatrices.AskRealElementsHandlerR@s"matrices.AskComplexElementsHandlercC sAgtjjD]0}|jdƒp+|tks tt|ƒ^q S(Nt__(Rbt __class__t__dict__t startswithtdeprecated_predicatesRt(tattr((s4lib/python2.7/site-packages/sympy/assumptions/ask.pytget_known_facts_keys»sc2C s×tttjtjƒttjtjƒttjtjƒttj tjtjBƒttj tj Btj ƒttj tj ƒttj tj tj@tj@ƒttj tjƒttjtjƒttjtjƒttjtjBtjƒttjtjƒttjtjtj@ƒttjtjƒttjtjƒttjtjBtjƒttjtjƒttjtj ƒttjtjtjBtjBƒttjtjtj@ƒttjtjƒttjtjtjBƒttjtjtjBƒttjtjtjBƒttjtjƒttjtjƒttjtj@tjƒttjtjƒttjtjƒttjtj ƒttj!tjƒttjtjƒttj!tj"ƒttj!tj#ƒttj#tj$ƒttj"tj$ƒttj$tj"tj#Bƒttj"tj#@tj!ƒttj!tj%ƒttj&tj$ƒttjtj'ƒttjtj ƒttj%tj ƒttj'tj @tjƒttjtj(ƒttj)tj*ƒttj*tj+ƒƒ/S(N(,R R RbR'R#RRRRRR.R/R R0R)R1R!RRRRR"R(R*R-R,R+R6R8R7RBR5R=R;R9R:RCR4RDR<RAR>R?R@(((s4lib/python2.7/site-packages/sympy/assumptions/ask.pytget_known_factsÃs`! (RdRcN(4RGt __future__RRtsympy.assumptions.assumeRRRt sympy.coreRtsympy.core.cacheRtsympy.core.decoratorsRtsympy.core.relationalRtsympy.logic.boolalgR R R R R RRRtsympy.logic.inferenceRtsympy.utilities.decoratorRRžtpredicate_storageRHtobjectRRbRhRMRpRiRyRzRR˜t _val_templatet _handlersRstvalueR R¡tsympy.assumptions.ask_generatedRdRc(((s4lib/python2.7/site-packages/sympy/assumptions/ask.pytsŠ:  ÿÿÿÿ€  !a   7                                   6