Predicates

Common

class sympy.assumptions.predicates.common.IsTruePredicate(*args, **kwargs)[source]

Generic predicate.

Explanation

ask(Q.is_true(x)) is true iff x is true. This only makes sense if x is a boolean object.

Examples

>>> from sympy import ask, Q
>>> from sympy.abc import x, y
>>> ask(Q.is_true(True))
True

Wrapping another applied predicate just returns the applied predicate.

>>> Q.is_true(Q.even(x))
Q.even(x)

Wrapping binary relation classes in SymPy core returns applied binary relational predicates.

>>> from sympy import Eq, Gt
>>> Q.is_true(Eq(x, y))
Q.eq(x, y)
>>> Q.is_true(Gt(x, y))
Q.gt(x, y)

Notes

This class is designed to wrap the boolean objects so that they can behave as if they are applied predicates. Consequently, wrapping another applied predicate is unnecessary and thus it just returns the argument. Also, binary relation classes in SymPy core have binary predicates to represent themselves and thus wrapping them with Q.is_true converts them to these applied predicates.

Handler

Multiply dispatched method: IsTrueHandler

Wrapper allowing to query the truth value of a boolean expression.

handler = <dispatched IsTrueHandler>
class sympy.assumptions.predicates.common.CommutativePredicate(*args, **kwargs)[source]

Commutative predicate.

Explanation

ask(Q.commutative(x)) is true iff x commutes with any other object with respect to multiplication operation.

Handler

Multiply dispatched method: CommutativeHandler

Handler for key ‘commutative’.

handler = <dispatched CommutativeHandler>

Calculus

class sympy.assumptions.predicates.calculus.FinitePredicate(*args, **kwargs)[source]

Finite number predicate.

Explanation

Q.finite(x) is true if x is a number but neither an infinity nor a NaN. In other words, ask(Q.finite(x)) is true for all numerical x having a bounded absolute value.

Examples

>>> from sympy import Q, ask, S, oo, I, zoo
>>> from sympy.abc import x
>>> ask(Q.finite(oo))
False
>>> ask(Q.finite(-oo))
False
>>> ask(Q.finite(zoo))
False
>>> ask(Q.finite(1))
True
>>> ask(Q.finite(2 + 3*I))
True
>>> ask(Q.finite(x), Q.positive(x))
True
>>> print(ask(Q.finite(S.NaN)))
None

Handler

Multiply dispatched method: FiniteHandler

Handler for Q.finite. Test that an expression is bounded respect to all its variables.

References

handler = <dispatched FiniteHandler>
class sympy.assumptions.predicates.calculus.InfinitePredicate(*args, **kwargs)[source]

Infinite number predicate.

Q.infinite(x) is true iff the absolute value of x is infinity.

Handler

Multiply dispatched method: InfiniteHandler

Handler for Q.infinite key.

handler = <dispatched InfiniteHandler>

Matrix

class sympy.assumptions.predicates.matrices.SymmetricPredicate(*args, **kwargs)[source]

Symmetric matrix predicate.

Explanation

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

Handler

Multiply dispatched method: SymmetricHandler

Handler for Q.symmetric.

References

handler = <dispatched SymmetricHandler>
class sympy.assumptions.predicates.matrices.InvertiblePredicate(*args, **kwargs)[source]

Invertible matrix predicate.

Explanation

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

Handler

Multiply dispatched method: InvertibleHandler

Handler for Q.invertible.

References

handler = <dispatched InvertibleHandler>
class sympy.assumptions.predicates.matrices.OrthogonalPredicate(*args, **kwargs)[source]

Orthogonal matrix predicate.

Explanation

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

Handler

Multiply dispatched method: OrthogonalHandler

Handler for key ‘orthogonal’.

References

handler = <dispatched OrthogonalHandler>
class sympy.assumptions.predicates.matrices.UnitaryPredicate(*args, **kwargs)[source]

Unitary matrix predicate.

Explanation

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

Handler

Multiply dispatched method: UnitaryHandler

Handler for key ‘unitary’.

References

handler = <dispatched UnitaryHandler>
class sympy.assumptions.predicates.matrices.PositiveDefinitePredicate(*args, **kwargs)[source]

Positive definite matrix predicate.

Explanation

If \(M\) is a \(n \times n\) symmetric real matrix, it is said to be positive definite if \(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

Handler

Multiply dispatched method: PositiveDefiniteHandler

Handler for key ‘positive_definite’.

References

handler = <dispatched PositiveDefiniteHandler>
class sympy.assumptions.predicates.matrices.UpperTriangularPredicate(*args, **kwargs)[source]

Upper triangular matrix predicate.

Explanation

A matrix \(M\) is called upper triangular matrix if \(M_{ij}=0\) for \(i<j\).

Examples

>>> from sympy import Q, ask, ZeroMatrix, Identity
>>> ask(Q.upper_triangular(Identity(3)))
True
>>> ask(Q.upper_triangular(ZeroMatrix(3, 3)))
True

Handler

Multiply dispatched method: UpperTriangularHandler

Handler for key ‘upper_triangular’.

References

handler = <dispatched UpperTriangularHandler>
class sympy.assumptions.predicates.matrices.LowerTriangularPredicate(*args, **kwargs)[source]

Lower triangular matrix predicate.

Explanation

A matrix \(M\) is called lower triangular matrix if \(M_{ij}=0\) for \(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

Handler

Multiply dispatched method: LowerTriangularHandler

Handler for key ‘lower_triangular’.

References

handler = <dispatched LowerTriangularHandler>
class sympy.assumptions.predicates.matrices.DiagonalPredicate(*args, **kwargs)[source]

Diagonal matrix predicate.

Explanation

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

Handler

Multiply dispatched method: DiagonalHandler

Handler for key ‘diagonal’.

References

handler = <dispatched DiagonalHandler>
class sympy.assumptions.predicates.matrices.FullRankPredicate(*args, **kwargs)[source]

Fullrank matrix predicate.

Explanation

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

Handler

Multiply dispatched method: FullRankHandler

Handler for key ‘fullrank’.

handler = <dispatched FullRankHandler>
class sympy.assumptions.predicates.matrices.SquarePredicate(*args, **kwargs)[source]

Square matrix predicate.

Explanation

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

Handler

Multiply dispatched method: SquareHandler

Handler for Q.square.

References

handler = <dispatched SquareHandler>
class sympy.assumptions.predicates.matrices.IntegerElementsPredicate(*args, **kwargs)[source]

Integer elements matrix predicate.

Explanation

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

Handler

Multiply dispatched method: IntegerElementsHandler

Handler for key ‘integer_elements’.

handler = <dispatched IntegerElementsHandler>
class sympy.assumptions.predicates.matrices.RealElementsPredicate(*args, **kwargs)[source]

Real elements matrix predicate.

Explanation

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

Handler

Multiply dispatched method: RealElementsHandler

Handler for key ‘real_elements’.

handler = <dispatched RealElementsHandler>
class sympy.assumptions.predicates.matrices.ComplexElementsPredicate(*args, **kwargs)[source]

Complex elements matrix predicate.

Explanation

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

Handler

Multiply dispatched method: ComplexElementsHandler

Handler for key ‘complex_elements’.

handler = <dispatched ComplexElementsHandler>
class sympy.assumptions.predicates.matrices.SingularPredicate(*args, **kwargs)[source]

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

Handler

Multiply dispatched method: SingularHandler

Predicate fore key ‘singular’.

References

handler = <dispatched SingularHandler>
class sympy.assumptions.predicates.matrices.NormalPredicate(*args, **kwargs)[source]

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

Handler

Multiply dispatched method: NormalHandler

Predicate fore key ‘normal’.

References

handler = <dispatched NormalHandler>
class sympy.assumptions.predicates.matrices.TriangularPredicate(*args, **kwargs)[source]

Triangular matrix predicate.

Explanation

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

Handler

Multiply dispatched method: TriangularHandler

Predicate fore key ‘triangular’.

References

handler = <dispatched TriangularHandler>
class sympy.assumptions.predicates.matrices.UnitTriangularPredicate(*args, **kwargs)[source]

Unit triangular matrix predicate.

Explanation

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

Handler

Multiply dispatched method: UnitTriangularHandler

Predicate fore key ‘unit_triangular’.

handler = <dispatched UnitTriangularHandler>

Number Theory

class sympy.assumptions.predicates.ntheory.EvenPredicate(*args, **kwargs)[source]

Even number predicate.

Explanation

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

Handler

Multiply dispatched method: EvenHandler

Handler for key ‘even’.

handler = <dispatched EvenHandler>
class sympy.assumptions.predicates.ntheory.OddPredicate(*args, **kwargs)[source]

Odd number predicate.

Explanation

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

Handler

Multiply dispatched method: OddHandler

Handler for key ‘odd’. Test that an expression represents an odd number.

handler = <dispatched OddHandler>
class sympy.assumptions.predicates.ntheory.PrimePredicate(*args, **kwargs)[source]

Prime number predicate.

Explanation

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

Handler

Multiply dispatched method: PrimeHandler

Handler for key ‘prime’. Test that an expression represents a prime number. When the expression is an exact number, the result (when True) is subject to the limitations of isprime() which is used to return the result.

handler = <dispatched PrimeHandler>
class sympy.assumptions.predicates.ntheory.CompositePredicate(*args, **kwargs)[source]

Composite number predicate.

Explanation

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

Handler

Multiply dispatched method: CompositeHandler

Handler for key ‘composite’.

handler = <dispatched CompositeHandler>

Order

class sympy.assumptions.predicates.order.PositivePredicate(*args, **kwargs)[source]

Positive real number predicate.

Explanation

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

Handler

Multiply dispatched method: PositiveHandler

Handler for key ‘positive’. Test that an expression is strictly greater than zero.

handler = <dispatched PositiveHandler>
class sympy.assumptions.predicates.order.NegativePredicate(*args, **kwargs)[source]

Negative number predicate.

Explanation

Q.negative(x) is true iff x is a real number and \(x < 0\), that is, it is in the interval \((-\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

Handler

Multiply dispatched method: NegativeHandler

Handler for Q.negative. Test that an expression is strictly less than zero.

handler = <dispatched NegativeHandler>
class sympy.assumptions.predicates.order.ZeroPredicate(*args, **kwargs)[source]

Zero number predicate.

Explanation

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
>>> print(ask(Q.zero(0*oo)))
None
>>> ask(Q.zero(1))
False
>>> ask(Q.zero(x*y), Q.zero(x) | Q.zero(y))
True

Handler

Multiply dispatched method: ZeroHandler

Handler for key ‘zero’.

handler = <dispatched ZeroHandler>
class sympy.assumptions.predicates.order.NonZeroPredicate(*args, **kwargs)[source]

Nonzero real number predicate.

Explanation

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))
False

Handler

Multiply dispatched method: NonZeroHandler

Handler for key ‘nonzero’. Test that an expression is not identically zero.

handler = <dispatched NonZeroHandler>
class sympy.assumptions.predicates.order.NonPositivePredicate(*args, **kwargs)[source]

Nonpositive real number predicate.

Explanation

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

Handler

Multiply dispatched method: NonPositiveHandler

Handler for key ‘nonpositive’.

handler = <dispatched NonPositiveHandler>
class sympy.assumptions.predicates.order.NonNegativePredicate(*args, **kwargs)[source]

Nonnegative real number predicate.

Explanation

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

Handler

Multiply dispatched method: NonNegativeHandler

Handler for Q.nonnegative.

handler = <dispatched NonNegativeHandler>

Sets

class sympy.assumptions.predicates.sets.IntegerPredicate(*args, **kwargs)[source]

Integer predicate.

Explanation

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

Handler

Multiply dispatched method: IntegerHandler

Handler for Q.integer.

Test that an expression belongs to the field of integer numbers.

References

handler = <dispatched IntegerHandler>
class sympy.assumptions.predicates.sets.RationalPredicate(*args, **kwargs)[source]

Rational number predicate.

Explanation

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

Handler

Multiply dispatched method: RationalHandler

Handler for Q.rational.

Test that an expression belongs to the field of rational numbers.

References

handler = <dispatched RationalHandler>
class sympy.assumptions.predicates.sets.IrrationalPredicate(*args, **kwargs)[source]

Irrational number predicate.

Explanation

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

Handler

Multiply dispatched method: IrrationalHandler

Handler for Q.irrational.

Test that an expression is irrational numbers.

References

handler = <dispatched IrrationalHandler>
class sympy.assumptions.predicates.sets.RealPredicate(*args, **kwargs)[source]

Real number predicate.

Explanation

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

Handler

Multiply dispatched method: RealHandler

Handler for Q.real.

Test that an expression belongs to the field of real numbers.

References

handler = <dispatched RealHandler>
class sympy.assumptions.predicates.sets.ExtendedRealPredicate(*args, **kwargs)[source]

Extended real predicate.

Explanation

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

Handler

Multiply dispatched method: ExtendedRealHandler

Handler for Q.extended_real.

Test that an expression belongs to the field of extended real

numbers, that is real numbers union {Infinity, -Infinity}.

handler = <dispatched ExtendedRealHandler>
class sympy.assumptions.predicates.sets.HermitianPredicate(*args, **kwargs)[source]

Hermitian predicate.

Explanation

ask(Q.hermitian(x)) is true iff x belongs to the set of Hermitian operators.

Handler

Multiply dispatched method: HermitianHandler

Handler for Q.hermitian.

Test that an expression belongs to the field of Hermitian operators.

References

handler = <dispatched HermitianHandler>
class sympy.assumptions.predicates.sets.ComplexPredicate(*args, **kwargs)[source]

Complex number predicate.

Explanation

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

Handler

Multiply dispatched method: ComplexHandler

Handler for Q.complex.

Test that an expression belongs to the field of complex numbers.

References

handler = <dispatched ComplexHandler>
class sympy.assumptions.predicates.sets.ImaginaryPredicate(*args, **kwargs)[source]

Imaginary number predicate.

Explanation

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

Handler

Multiply dispatched method: ImaginaryHandler

Handler for Q.imaginary.

Test that an expression belongs to the field of imaginary numbers,

that is, numbers in the form x*I, where x is real.

References

handler = <dispatched ImaginaryHandler>
class sympy.assumptions.predicates.sets.AntihermitianPredicate(*args, **kwargs)[source]

Antihermitian predicate.

Explanation

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.

Handler

Multiply dispatched method: AntiHermitianHandler

Handler for Q.antihermitian.

Test that an expression belongs to the field of anti-Hermitian

operators, that is, operators in the form x*I, where x is Hermitian.

References

handler = <dispatched AntiHermitianHandler>
class sympy.assumptions.predicates.sets.AlgebraicPredicate(*args, **kwargs)[source]

Algebraic number predicate.

Explanation

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

Handler

Multiply dispatched method: AskAlgebraicpredicateHandler

Handler for key AskAlgebraicpredicateHandler

References

AlgebraicHandler = <dispatched AlgebraicHandler>
handler = <dispatched AskAlgebraicpredicateHandler>
class sympy.assumptions.predicates.sets.TranscendentalPredicate(*args, **kwargs)[source]

Transcedental number predicate.

Explanation

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.

Handler

Multiply dispatched method: Transcendental

Handler for Q.transcendental key.

handler = <dispatched Transcendental>