B [$@sdZddlmZmZddlmZddlmZddlm Z ddl m Z m Z m Z mZmZmZmZmZddlmZddlmZmZmZdd lmZdd lmZd d d gZiZeeZGddde Z!e!Z"dJddZ#defddZ$ddZ%ddZ&ddZ'ddZ(ddZ)dZ*d d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;dd?d@dAdBdCg$Z+x e+D]\Z,Z-e&e,e*e-qZWedDdEZ.edFdGZ/ddHl0m1Z1m2Z2dIS)Kz4Module for querying SymPy objects about assumptions.)print_functiondivision)sympify)cacheit) Relational)to_cnfAndNotOrImplies EquivalentBooleanFunction BooleanAtom) satisfiable)global_assumptions PredicateAppliedPredicate) deprecated)memoize_propertyboundedinfinity infinitesimalc@sVeZdZdZeddZeddZeddZedd Zed d Z ed d Z eddZ eddZ eddZ eddZeddZeddZeeddddddZed d!Zeed"d#ddd$d%Zeed&d'ddd(d)Zed*d+Zed,d-Zed.d/Zed0d1Zed2d3Zed4d5Zed6d7Zed8d9Zed:d;Zedd?Z ed@dAZ!edBdCZ"edDdEZ#edFdGZ$edHdIZ%edJdKZ&edLdMZ'edNdOZ(edPdQZ)edRdSZ*edTdUZ+edVdWZ,edXdYZ-edZd[Z.ed\d]Z/ed^d_Z0ed`daZ1edbdcZ2ddS)eAssumptionKeysz@ This class contains all the supported keys by ``ask``. cCstdS)z 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 hermitian)r)selfr4lib/python3.7/site-packages/sympy/assumptions/ask.pyr$szAssumptionKeys.hermitiancCstdS)aH 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 antihermitian)r)rrrrr5szAssumptionKeys.antihermitiancCstdS)a@ 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 real)r)rrrrrGs7zAssumptionKeys.realcCstdS)a 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 extended_real)r)rrrrrszAssumptionKeys.extended_realcCstdS)a; 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 imaginary)r)rrrrr szAssumptionKeys.imaginarycCstdS)a 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 complex)r)rrrrr!szAssumptionKeys.complexcCstdS)aD 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] http://en.wikipedia.org/wiki/Algebraic_number algebraic)r)rrrrr"szAssumptionKeys.algebraiccCstdS)z 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. transcendental)r)rrrrr#s zAssumptionKeys.transcendentalcCstdS)a} 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 integer)r)rrrrr$szAssumptionKeys.integercCstdS)a 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 rational)r)rrrrr%szAssumptionKeys.rationalcCstdS)a& 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 irrational)r)rrrrr&+szAssumptionKeys.irrationalcCstdS)ah 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 finite)r)rrrrr'HszAssumptionKeys.finiter'i$z1.0)Z useinsteadZissueZdeprecated_since_versioncCstdS)z4 See documentation of ``Q.finite``. r')r)rrrrrgszAssumptionKeys.boundedcCstdS)z Infinite number predicate. ``Q.infinite(x)`` is true iff the absolute value of ``x`` is infinity. infinite)r)rrrrr(os zAssumptionKeys.infiniter(i$cCstdS)z6 See documentation of ``Q.infinite``. r()r)rrrrr{szAssumptionKeys.infinityzeroi%cCstdS)z2 See documentation of ``Q.zero``. r))r)rrrrrszAssumptionKeys.infinitesimalcCstdS)a~ 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 positive)r)rrrrr*s$zAssumptionKeys.positivecCstdS)a 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 negative)r)rrrrr+s$zAssumptionKeys.negativecCstdS)a 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)rrrrr)szAssumptionKeys.zerocCstdS)a  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 nonzero)r)rrrrr,s&zAssumptionKeys.nonzerocCstdS)a 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 nonpositive)r)rrrrr-szAssumptionKeys.nonpositivecCstdS)a 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 nonnegative)r)rrrrr.:szAssumptionKeys.nonnegativecCstdS)at 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 even)r)rrrrr/[szAssumptionKeys.evencCstdS)ae 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 odd)r)rrrrr0sszAssumptionKeys.oddcCstdS)a 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 prime)r)rrrrr1szAssumptionKeys.primecCstdS)a 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 composite)r)rrrrr2szAssumptionKeys.compositecCstdS)z Commutative predicate. ``ask(Q.commutative(x))`` is true iff ``x`` commutes with any other object with respect to multiplication operation. commutative)r)rrrrr3s zAssumptionKeys.commutativecCstdS)a3 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 is_true)r)rrrrr4szAssumptionKeys.is_truecCstdS)a 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 symmetric)r)rrrrr5szAssumptionKeys.symmetriccCstdS)a 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 invertible)r)rrrrr6szAssumptionKeys.invertiblecCstdS)a 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 orthogonal)r)rrrrr7s!zAssumptionKeys.orthogonalcCstdS)a6 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 unitary)r)rrrrr8>szAssumptionKeys.unitarycCstdS)a= 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 positive_definite)r)rrrrr9^sz AssumptionKeys.positive_definitecCstdS)a 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 upper_triangular)r)rrrrr:~szAssumptionKeys.upper_triangularcCstdS)a 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 lower_triangular)r)rrrrr;szAssumptionKeys.lower_triangularcCstdS)aq 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 diagonal)r)rrrrr<szAssumptionKeys.diagonalcCstdS)a` 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 fullrank)r)rrrrr=szAssumptionKeys.fullrankcCstdS)a 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 square)r)rrrrr>szAssumptionKeys.squarecCstdS)a[ 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 integer_elements)r)rrrrr?szAssumptionKeys.integer_elementscCstdS)aS 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 real_elements)r)rrrrr@szAssumptionKeys.real_elementscCstdS)a 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 complex_elements)r)rrrrrA)szAssumptionKeys.complex_elementscCstdS)a 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 singular)r)rrrrrB>szAssumptionKeys.singularcCstdS)a 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 normal)r)rrrrrCWszAssumptionKeys.normalcCstdS)a 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 triangular)r)rrrrrDnszAssumptionKeys.triangularcCstdS)aQ 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 unit_triangular)r)rrrrrEszAssumptionKeys.unit_triangularN)3__name__ __module__ __qualname____doc__predicate_memorrrrr r!r"r#r$r%r&r'rrr(rrr*r+r)r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rArBrCrDrErrrrrsb   9          & &  ( ! !      !  #           rTcsttr(|r(t|jd}|dk r(|St|tr6dS|sDdSt|trb|jkr^|jSdSt|t r|j djt t fkr|j dt krt nt }|dd|j dj D}fdd|j D}t|t rdd|D}|r|j|S|rt dd |Dr|j|SdS) z Helper for ask(). Extracts the facts relevant to the symbol from an assumption. Returns None if there is nothing to extract. FNrcSsg|] }|qSrr).0argrrr sz"_extract_facts..csg|]}t|qSr)_extract_facts)rKrL)symbolrrrMscSsg|]}|dk r|qS)Nr)rKxrrrrMscss|]}|dkVqdS)Nr)rKrPrrr sz!_extract_facts..) isinstancerrNreversedboolZhasrrLfuncr argsrr all)exprrOZcheck_reversed_relZrevclsrVr)rOrrNs.       rNc s6ddlm}t|ttttfs&tdt|ttttfs@tdt|tr^|jt |j }}nt j t |}}t |t |}t|}t||}t}t|rtt ||dkrtd||||}|dk rt|S|dkr||||dS|jr"||kr d St||krdSnt|t rtfd d |jDrx|jD]z} | jr|| krnd St|| krdSnBt| trP| jdjrP|| krdSt|| krPd SqPWn>t|trt|tr|jdjr|jd|krdSt|||}|dkr2||||dS|S) a 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. r)sataskz.proposition must be a valid logical expressionz.assumptions must be a valid logical expressionFzinconsistent assumptions %sN) assumptionscontextTc3s|]}|kVqdS)Nr)rKk)known_facts_dictrrrQszask..)Zsympy.assumptions.sataskrZrRr rrTr TypeErrorrUrrLQr4rrrNget_known_facts_cnfget_known_facts_dictr ValueErrorZ _eval_askZis_Atomr rWrVrask_full_inference) propositionr[r\rZkeyrXZ local_factsknown_facts_cnfZresZassumr)r^rasks\!          rhcCs0tt|||sdStt||t|s,dSdS)z9 Method for inferring properties about objects. FTN)rrr )rer[rgrrrrds rdc CsVt|tkr|j}ytt||Wn*tk rPtt|t||gdYnXdS)a 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 )ZhandlersN)typernamegetattrr`Z add_handlerAttributeErrorsetattr)rfhandlerrrrregister_handler+s  rocCs&t|tkr|j}tt||dS)zFRemoves a handler from the ask system. Same syntax as register_handlerN)rirrjrkr`remove_handler)rfrnrrrrpEs rpcCsPi}xF|D]>}|h||<x.|D]&}||krt|||r|||qWq W|S)N)rdadd)known_facts_keysrgmappingrfZ other_keyrrrsingle_fact_lookupLs    rtc sddlm}m|d}d}dt|}|dd|jD}t||}t|t d}d d|D} d d|D} |fd dt | | Dd } ||| fS) aCompute the various forms of knowledge compilation used by the assumptions system. This function is typically applied to the results of the ``get_known_facts`` and ``get_known_facts_keys`` functions defined at the bottom of this file. r)dedentwrapa[ """ The contents of this file are the return value of ``sympy.assumptions.ask.compute_known_facts``. Do NOT manually edit this file. Instead, run ./bin/ask_update.py. """ from sympy.core.cache import cacheit from sympy.logic.boolalg import And, Not, Or from sympy.assumptions.ask import Q # -{ Known facts in Conjunctive Normal Form }- @cacheit def get_known_facts_cnf(): return And( %s ) # -{ Known facts in compressed sets }- @cacheit def get_known_facts_dict(): return { %s } z , z cSsg|] }t|qSr)str)rKarrrrMsz'compute_known_facts..)rfcSsg|]}t|dqS)r)rw)rKirrrrMscSs g|]}dt|dtdqS)zset(%s))rf)sortedrw)rKryrrrrMsc s,g|]$\}}dd||fddqS) z%s: %sF)Zsubsequent_indentZbreak_long_words)join)rKr]v)HANGrvrrrMs,) textwraprurvrr}rVrtr{itemsrwzip) Z known_factsrrruZ fact_stringZLINEZcnfcrsrkeysvaluesmr)rrvrcompute_known_factsXs rzsympy.assumptions.handlers.%s)rzsets.AskAntiHermitianHandler)r'zcalculus.AskFiniteHandler)r3ZAskCommutativeHandler)r!zsets.AskComplexHandler)r2zntheory.AskCompositeHandler)r/zntheory.AskEvenHandler)rzsets.AskExtendedRealHandler)rzsets.AskHermitianHandler)r zsets.AskImaginaryHandler)r$zsets.AskIntegerHandler)r&zsets.AskIrrationalHandler)r%zsets.AskRationalHandler)r+zorder.AskNegativeHandler)r,zorder.AskNonZeroHandler)r-zorder.AskNonPositiveHandler)r.zorder.AskNonNegativeHandler)r)zorder.AskZeroHandler)r*zorder.AskPositiveHandler)r1zntheory.AskPrimeHandler)rzsets.AskRealHandler)r0zntheory.AskOddHandler)r"zsets.AskAlgebraicHandler)r4zcommon.TautologicalHandler)r5zmatrices.AskSymmetricHandler)r6zmatrices.AskInvertibleHandler)r7zmatrices.AskOrthogonalHandler)r8zmatrices.AskUnitaryHandler)r9z#matrices.AskPositiveDefiniteHandler)r:z"matrices.AskUpperTriangularHandler)r;z"matrices.AskLowerTriangularHandler)r<zmatrices.AskDiagonalHandler)r=zmatrices.AskFullRankHandler)r>zmatrices.AskSquareHandler)r?z"matrices.AskIntegerElementsHandler)r@zmatrices.AskRealElementsHandler)rAz"matrices.AskComplexElementsHandlercCsddtjjDS)NcSs(g|] }|ds|tkstt|qS)__) startswithdeprecated_predicatesrkr`)rKattrrrrrMs z(get_known_facts_keys..)r` __class____dict__rrrrget_known_facts_keyssrc2Cstttjtjttjtjttjtjttj tjtjBttj tj Btj ttj tj ttj tj tj@tj@ttj tjttjtjttjtjttjtjBtjttjtjttjtjtj@ttjtjttjtjttjtjBtjttjtjttjtj ttjtjtjBtjBttjtjtj@ttjtjttjtjtjBttjtjtjBttjtjtjBttjtjttjtjttjtj@tjttjtjttjtjttjtj ttj!tjttjtjttj!tj"ttj!tj#ttj#tj$ttj"tj$ttj$tj"tj#Bttj"tj#@tj!ttj!tj%ttj&tj$ttjtj'ttjtj ttj%tj ttj'tj @tjttjtj(ttj)tj*ttj*tj+/S)N),rr r`r(r'rr!rr rr/r0r$r1r*r2r%r"r#r rr&r)r+r.r-r,r7r9r8rCr6r>r<r:r;rDr5rEr=rBr?r@rArrrrget_known_factss`                        r)rbraN)T)3rIZ __future__rrZ sympy.corerZsympy.core.cacherZsympy.core.relationalrZsympy.logic.boolalgrrr r r r r rZsympy.logic.inferencerZsympy.assumptions.assumerrrZsympy.core.decoratorsrZsympy.utilities.decoratorrrZpredicate_storagerJobjectrr`rNrhrdrorprtrZ _val_templateZ _handlersrjvaluerrZsympy.assumptions.ask_generatedrbrarrrrs   (    !a  7  6