SymPy 1.13 中文文档（八）

原文：docs.sympy.org/latest/index.html

假设

原文：docs.sympy.org/latest/modules/assumptions/index.html

一个模块用于实现逻辑谓词和假设系统。

谓词

class sympy.assumptions.assume.Predicate(*args, **kwargs)

数学谓词的基类。它还充当未定义谓词对象的构造函数。

解释

谓词是返回布尔值的函数[1]。

谓词函数是对象，并且是谓词类的实例。当谓词应用于参数时，返回AppliedPredicate实例。这仅包装参数并保持未评估状态。要获取应用谓词的真值，请使用函数ask。

谓词的评估通过多重分派完成。您可以注册新的处理程序到谓词以支持新类型。

SymPy 中的每个谓词都可以通过Q的属性访问。例如，Q.even返回检查参数是否为偶数的谓词。

要定义一个可评估的谓词，必须子类化此类，创建其实例，并将其注册到Q。之后，通过参数类型分派处理程序。

如果直接使用此类构造谓词，则将获得不能分派的UndefinedPredicate。这在构建不需要评估的布尔表达式时很有用。

示例

应用和评估布尔值：

>>> from sympy import Q, ask
>>> ask(Q.prime(7))
True

您可以通过子类化和分派来定义新的谓词。这里，我们以性质素数[2]为例定义一个谓词。

>>> from sympy import Predicate, Integer
>>> class SexyPrimePredicate(Predicate):
...     name = "sexyprime"
>>> Q.sexyprime = SexyPrimePredicate()
>>> @Q.sexyprime.register(Integer, Integer)
... def _(int1, int2, assumptions):
...     args = sorted([int1, int2])
...     if not all(ask(Q.prime(a), assumptions) for a in args):
...         return False
...     return args[1] - args[0] == 6
>>> ask(Q.sexyprime(5, 11))
True

直接构造返回UndefinedPredicate，可以应用但不能分派。

>>> from sympy import Predicate, Integer
>>> Q.P = Predicate("P")
>>> type(Q.P)
<class 'sympy.assumptions.assume.UndefinedPredicate'>
>>> Q.P(1)
Q.P(1)
>>> Q.P.register(Integer)(lambda expr, assump: True)
Traceback (most recent call last):
  ...
TypeError: <class 'sympy.assumptions.assume.UndefinedPredicate'> cannot be dispatched.

参考文献

[R7]

zh.wikipedia.org/wiki/%E8%B0%93%E8%AF%8D

[R8]

zh.wikipedia.org/wiki/%E5%AF%86%E5%88%A9%E5%A5%87%E8%B0%93

eval(args, assumptions=True)

在给定假设下评估self(*args)。

这仅使用直接解决方法，不使用逻辑推理。

handler = <dispatched AskPredicateHandler>

classmethod register(*types, **kwargs)

注册签名到处理程序。

classmethod register_many(*types, **kwargs)

向同一处理程序注册多个签名。

class sympy.assumptions.assume.AppliedPredicate(predicate, *args)

将Predicate应用于参数所产生的表达式类。AppliedPredicate仅仅包装其参数并保持未评估状态。要评估它，请使用ask()函数。

示例

>>> from sympy import Q, ask
>>> Q.integer(1)
Q.integer(1)

function属性返回谓词，arguments属性返回参数元组。

>>> type(Q.integer(1))
<class 'sympy.assumptions.assume.AppliedPredicate'>
>>> Q.integer(1).function
Q.integer
>>> Q.integer(1).arguments
(1,)

可以使用ask将应用的谓词评估为布尔值：

>>> ask(Q.integer(1))
True

property arg

返回此假设所用的表达式。

示例

>>> from sympy import Q, Symbol
>>> x = Symbol('x')
>>> a = Q.integer(x + 1)
>>> a.arg
x + 1

property arguments

返回应用于谓词的参数。

property function

返回谓词。

查询

查询用于询问关于表达式的信息。这的主要方法是ask()：

sympy.assumptions.ask.ask(proposition, assumptions=True, context={})

使用假设评估命题的函数。

参数：

命题：布尔值

将评估为布尔值的命题。如果不是AppliedPredicate，它将被Q.is_true包装。

假设：布尔值，可选

评估命题的局部假设。

context：AssumptionsContext，可选

默认假设用于评估proposition。默认情况下，这是sympy.assumptions.global_assumptions变量。

True、False或None

Raises:

TypeError：proposition或assumptions不是有效的逻辑表达式。

ValueError：假设不一致。

解释

如果可以确定真值，则此函数将评估proposition为True或False。否则，它将返回None。

它应该从refine()中区分出来，当应用于proposition时，简化参数为符号Boolean而不是 Python 内置的True、False或None。

语法

ask(proposition)

在全局假设上下文中评估proposition。

ask(proposition, assumptions)

在全局假设上下文中，根据assumptions评估proposition。

示例

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

如果无法确定真值，则返回None。

>>> print(ask(Q.odd(3*x))) # cannot determine unless we know x
None

如果假设不一致，则引发ValueError。

>>> ask(Q.integer(x), Q.even(x) & Q.odd(x))
Traceback (most recent call last):
  ...
ValueError: inconsistent assumptions Q.even(x) & Q.odd(x)

注意事项

假设关系尚未实现（但），因此以下内容将不会给出有意义的结果。

>>> ask(Q.positive(x), x > 0)

然而，这还在进展中。

另请参阅

sympy.assumptions.refine.refine

使用假设简化。如果无法确定真值，则proposition不会简化为None。

ask的第二个可选参数应为涉及expr中对象假设的布尔表达式。有效值包括：

Q.integer(x)

Q.positive(x)

Q.integer(x) & Q.positive(x)

等等。

Q是一个持有已知谓词的对象。

有关逻辑模块的文档，请参阅完整的有效布尔表达式列表。

您还可以定义上下文，这样您就不必每次都将该参数传递给函数ask()。这可以通过使用模块sympy.assumptions中的假设上下文管理器来完成。

>>> from sympy import *
>>> x = Symbol('x')
>>> y = Symbol('y')
>>> facts = Q.positive(x), Q.positive(y)
>>> with assuming(*facts):
...     print(ask(Q.positive(2*x + y)))
True

内容

询问
假设
精化
谓词

性能改进

在涉及符号系数的查询中，使用逻辑推理。致力于改进可满足功能（sympy.logic.inference.satisfiable）应导致显著的速度改进。

一个 ask 中使用的逻辑推理可以用来加快进一步查询的速度，但当前系统未利用这一点。例如，可以实现真值维护系统（en.wikipedia.org/wiki/Truth_maintenance_system）。

杂项

您可以在目录sympy/assumptions/tests/中找到更多示例。

问

原文：docs.sympy.org/latest/modules/assumptions/ask.html

用于查询关于假设的 SymPy 对象的模块。

class sympy.assumptions.ask.AssumptionKeys

这个类包含了ask系统中所有支持的键。它应该通过实例sympy.Q来访问。

sympy.assumptions.ask.ask(proposition, assumptions=True, context={})

用于带有假设的命题评估的函数。

参数：

proposition：布尔值

将被评估为布尔值的命题。如果不是AppliedPredicate，它将被Q.is_true包装。

assumptions：布尔值，可选

用于评估proposition的本地假设。

context：AssumptionsContext，可选

用于评估proposition的默认假设。默认情况下，这是sympy.assumptions.global_assumptions变量。

True、False或None

引发：

TypeError：proposition或assumptions不是有效的逻辑表达式。

ValueError：假设不一致。

解释

这个函数在能够确定真值时将命题评估为True或False。如果不能确定，将返回None。

这应该与refine()区分开来，当应用于命题时，它将简化参数为符号Boolean，而不是 Python 内置的True、False或None。

Syntax

ask(proposition)

在全局假设上评估proposition。

ask(proposition, assumptions)

在全局假设上评估proposition关于assumptions。

示例

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

如果无法确定真值，将返回None。

>>> print(ask(Q.odd(3*x))) # cannot determine unless we know x
None

如果假设不一致，将引发ValueError。

>>> ask(Q.integer(x), Q.even(x) & Q.odd(x))
Traceback (most recent call last):
  ...
ValueError: inconsistent assumptions Q.even(x) & Q.odd(x)

注意事项

假设中的关系尚未实现（但是），因此以下内容不会给出有意义的结果。

>>> ask(Q.positive(x), x > 0)

然而，这还在进行中。

另请参阅

sympy.assumptions.refine.refine

使用假设进行简化。如果无法确定真值，命题不会简化为None。

sympy.assumptions.ask.register_handler(key, handler)

在 ask 系统中注册一个处理程序。键必须是字符串，处理程序必须是继承自 AskHandler 类的类。

自版本 1.8 起已弃用：改用 multipledispatch 处理程序。参见Predicate。

sympy.assumptions.ask.remove_handler(key, handler)

从 ask 系统中删除处理程序。

自版本 1.8 起已弃用：改用 multipledispatch 处理程序。参见Predicate。

假设

原文：docs.sympy.org/latest/modules/assumptions/assume.html

实现谓词和假设上下文的模块。

class sympy.assumptions.assume.AppliedPredicate(predicate, *args)

通过将Predicate应用于参数的表达式类。AppliedPredicate仅仅包装其参数并保持未评估状态。要评估它，请使用ask()函数。

示例

>>> from sympy import Q, ask
>>> Q.integer(1)
Q.integer(1)

function属性返回谓词，arguments属性返回参数元组。

>>> type(Q.integer(1))
<class 'sympy.assumptions.assume.AppliedPredicate'>
>>> Q.integer(1).function
Q.integer
>>> Q.integer(1).arguments
(1,)

应用谓词可以用ask来评估为布尔值：

>>> ask(Q.integer(1))
True

property arg

返回此假设使用的表达式。

示例

>>> from sympy import Q, Symbol
>>> x = Symbol('x')
>>> a = Q.integer(x + 1)
>>> a.arg
x + 1

property arguments

返回应用于谓词的参数。

property function

返回谓词。

class sympy.assumptions.assume.AssumptionsContext

设置包含应用于ask()函数的默认假设的集合。

解释

这用于表示全局假设，但您也可以使用此类创建自己的局部假设上下文。基本上它是 Python 集合的薄包装，因此请参阅其文档以获取高级用法。

示例

默认的假设上下文是global_assumptions，最初是空的：

>>> from sympy import ask, Q
>>> from sympy.assumptions import global_assumptions
>>> global_assumptions
AssumptionsContext()

您可以添加默认的假设：

>>> from sympy.abc import x
>>> global_assumptions.add(Q.real(x))
>>> global_assumptions
AssumptionsContext({Q.real(x)})
>>> ask(Q.real(x))
True

并移除它们：

>>> global_assumptions.remove(Q.real(x))
>>> print(ask(Q.real(x)))
None

clear()方法移除每一个假设：

>>> global_assumptions.add(Q.positive(x))
>>> global_assumptions
AssumptionsContext({Q.positive(x)})
>>> global_assumptions.clear()
>>> global_assumptions
AssumptionsContext()

另见

assuming

add(*assumptions)

添加假设。

class sympy.assumptions.assume.Predicate(*args, **kwargs)

数学谓词的基类。它还用作未定义谓词对象的构造函数。

解释

谓词是返回布尔值的函数 [1]。

谓词函数是对象，是谓词类的实例。当谓词应用于参数时，返回AppliedPredicate实例。这仅仅是包装了参数并保持未评估状态。要获取应用谓词的真值，请使用函数ask。

谓词的评估是通过多重分派完成的。您可以注册新的处理程序到谓词以支持新类型。

SymPy 中的每个谓词都可以通过Q的属性访问。例如，Q.even返回检查参数是否为偶数的谓词。

要定义一个可以评估的谓词，您必须子类化此类，并对其进行实例化，并将其注册到Q。然后，按参数类型分派处理程序。

如果直接使用此类构造谓词，您将得到不能分派的UndefinedPredicate。当您构建不需要评估的布尔表达式时，这是有用的。

示例

应用和评估为布尔值：

>>> from sympy import Q, ask
>>> ask(Q.prime(7))
True

您可以通过子类化和分派来定义新的谓词。在这里，我们定义一个性感素数 [2] 作为示例。

>>> from sympy import Predicate, Integer
>>> class SexyPrimePredicate(Predicate):
...     name = "sexyprime"
>>> Q.sexyprime = SexyPrimePredicate()
>>> @Q.sexyprime.register(Integer, Integer)
... def _(int1, int2, assumptions):
...     args = sorted([int1, int2])
...     if not all(ask(Q.prime(a), assumptions) for a in args):
...         return False
...     return args[1] - args[0] == 6
>>> ask(Q.sexyprime(5, 11))
True

直接构造返回UndefinedPredicate，可以应用但不能分派。

>>> from sympy import Predicate, Integer
>>> Q.P = Predicate("P")
>>> type(Q.P)
<class 'sympy.assumptions.assume.UndefinedPredicate'>
>>> Q.P(1)
Q.P(1)
>>> Q.P.register(Integer)(lambda expr, assump: True)
Traceback (most recent call last):
  ...
TypeError: <class 'sympy.assumptions.assume.UndefinedPredicate'> cannot be dispatched.

参考

[R5]

en.wikipedia.org/wiki/Predicate_%28mathematical_logic%29

[R6]

en.wikipedia.org/wiki/Sexy_prime

eval(args, assumptions=True)

在给定假设条件下评估self(*args)。

这只使用直接解析方法，而不是逻辑推理。

handler = <dispatched AskPredicateHandler>

classmethod register(*types, **kwargs)

将签名注册到处理程序。

classmethod register_many(*types, **kwargs)

将多个签名注册到同一处理程序。

class sympy.assumptions.assume.UndefinedPredicate(name, handlers=None)

谓词无处理程序。

解释

此谓词是通过直接使用Predicate进行构造生成的。它没有处理程序，通过 SAT 求解器对其进行参数评估。

示例

>>> from sympy import Predicate, Q
>>> Q.P = Predicate('P')
>>> Q.P.func
<class 'sympy.assumptions.assume.UndefinedPredicate'>
>>> Q.P.name
Str('P')

sympy.assumptions.assume.assuming(*assumptions)

假设的上下文管理器。

示例

>>> from sympy import assuming, Q, ask
>>> from sympy.abc import x, y
>>> print(ask(Q.integer(x + y)))
None
>>> with assuming(Q.integer(x), Q.integer(y)):
...     print(ask(Q.integer(x + y)))
True

精炼

原文：docs.sympy.org/latest/modules/assumptions/refine.html

sympy.assumptions.refine.refine(expr, assumptions=True)

使用假设简化表达式。

解释

与 simplify() 不同，后者在没有任何假设的情况下执行结构化简化，而此函数将表达式转换为仅在特定假设下有效的形式。请注意，在精炼过程中通常不执行 simplify()。

优化布尔表达式涉及将其简化为 S.true 或 S.false。与 ask() 不同，如果无法确定真值，表达式将不会被简化。

示例

>>> from sympy import refine, sqrt, Q
>>> from sympy.abc import x
>>> refine(sqrt(x**2), Q.real(x))
Abs(x)
>>> refine(sqrt(x**2), Q.positive(x))
x

>>> refine(Q.real(x), Q.positive(x))
True
>>> refine(Q.positive(x), Q.real(x))
Q.positive(x)

另见

sympy.simplify.simplify.simplify 的处理程序。

没有假设的结构化简化。

sympy.assumptions.ask.ask 的处理程序。

使用假设查询布尔表达式。

sympy.assumptions.refine.refine_Pow(expr, assumptions)

Pow 实例的处理程序。

示例

>>> from sympy import 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

对于 -1 的幂，指数的偶数部分可以简化：

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

sympy.assumptions.refine.refine_abs(expr, assumptions)

绝对值的处理程序。

示例

>>> from sympy import Q, 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

sympy.assumptions.refine.refine_arg(expr, assumptions)

复数参数的处理程序。

解释

>>> from sympy.assumptions.refine import refine_arg
>>> from sympy import Q, arg
>>> from sympy.abc import x
>>> refine_arg(arg(x), Q.positive(x))
0
>>> refine_arg(arg(x), Q.negative(x))
pi

sympy.assumptions.refine.refine_atan2(expr, assumptions)

atan2 函数的处理程序。

示例

>>> from sympy import Q, 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
>>> refine_atan2(atan2(y,x), Q.zero(y) & Q.negative(x))
pi
>>> refine_atan2(atan2(y,x), Q.positive(y) & Q.zero(x))
pi/2
>>> refine_atan2(atan2(y,x), Q.negative(y) & Q.zero(x))
-pi/2
>>> refine_atan2(atan2(y,x), Q.zero(y) & Q.zero(x))
nan

sympy.assumptions.refine.refine_im(expr, assumptions)

虚部的处理程序。

解释

>>> from sympy.assumptions.refine import refine_im
>>> from sympy import Q, im
>>> from sympy.abc import x
>>> refine_im(im(x), Q.real(x))
0
>>> refine_im(im(x), Q.imaginary(x))
-I*x

sympy.assumptions.refine.refine_matrixelement(expr, assumptions)

对称部分的处理程序。

示例

>>> from sympy.assumptions.refine import refine_matrixelement
>>> from sympy import MatrixSymbol, Q
>>> X = MatrixSymbol('X', 3, 3)
>>> refine_matrixelement(X[0, 1], Q.symmetric(X))
X[0, 1]
>>> refine_matrixelement(X[1, 0], Q.symmetric(X))
X[0, 1]

sympy.assumptions.refine.refine_re(expr, assumptions)

实部的处理程序。

示例

>>> from sympy.assumptions.refine import refine_re
>>> from sympy import Q, re
>>> from sympy.abc import x
>>> refine_re(re(x), Q.real(x))
x
>>> refine_re(re(x), Q.imaginary(x))
0

sympy.assumptions.refine.refine_sign(expr, assumptions)

符号的处理程序。

示例

>>> from sympy.assumptions.refine import refine_sign
>>> from sympy import Symbol, Q, sign, im
>>> x = Symbol('x', real = True)
>>> expr = sign(x)
>>> refine_sign(expr, Q.positive(x) & Q.nonzero(x))
1
>>> refine_sign(expr, Q.negative(x) & Q.nonzero(x))
-1
>>> refine_sign(expr, Q.zero(x))
0
>>> y = Symbol('y', imaginary = True)
>>> expr = sign(y)
>>> refine_sign(expr, Q.positive(im(y)))
I
>>> refine_sign(expr, Q.negative(im(y)))
-I

谓词

原文：docs.sympy.org/latest/modules/assumptions/predicates.html

Common

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

通用谓词。

解释

ask(Q.is_true(x)) 是当且仅当 x 为真时为真。这只有当 x 是布尔对象时才有意义。

示例

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

多余地再次包装另一个应用的谓词只会返回应用的谓词。

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

在 SymPy 核心中将二元关系类包装为应用的二元关系谓词。

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

注释

这个类被设计成包装布尔对象，使它们能够表现得像应用的谓词一样。因此，多余地再次包装另一个应用的谓词是不必要的，因此它只返回参数。此外，SymPy 核心中的二元关系类具有用于表示自身的二元谓词，因此用 Q.is_true 包装它们会将它们转换为这些应用的谓词。

Handler

Multiply dispatched method: IsTrueHandler

包装器允许查询布尔表达式的真值。

handler = <dispatched IsTrueHandler>

class sympy.assumptions.predicates.common.CommutativePredicate(*args, **kwargs)

可交换谓词。

解释

ask(Q.commutative(x)) 是当且仅当 x 在乘法运算中与任何其他对象都可交换时为真。

Handler

Multiply dispatched method: CommutativeHandler

Handler for key ‘commutative’.

handler = <dispatched CommutativeHandler>

微积分

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

有限数谓词。

解释

Q.finite(x) 是当且仅当 x 是一个数但既不是无穷也不是 NaN 时为真。换句话说，对于所有有界绝对值的数值 x，ask(Q.finite(x)) 都为真。

示例

>>> 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.

参考文献

[R9]

en.wikipedia.org/wiki/Finite

handler = <dispatched FiniteHandler>

class sympy.assumptions.predicates.calculus.InfinitePredicate(*args, **kwargs)

无穷数谓词。

Q.infinite(x) 是当且仅当 x 的绝对值为无穷时为真。

Handler

Multiply dispatched method: InfiniteHandler

Handler for Q.infinite key.

handler = <dispatched InfiniteHandler>

矩阵

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

对称矩阵谓词。

解释

Q.symmetric(x) 是当且仅当 x 是方阵且等于其转置时为真。每个方阵对角矩阵都是对称矩阵。

示例

>>> 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.

参考文献

[R10]

en.wikipedia.org/wiki/Symmetric_matrix

handler = <dispatched SymmetricHandler>

class sympy.assumptions.predicates.matrices.InvertiblePredicate(*args, **kwargs)

可逆矩阵谓词。

解释

Q.invertible(x) 是当且仅当 x 是可逆矩阵时为真。一个方阵只有在其行列式为非零时才称为可逆矩阵。

示例

>>> 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.

参考文献

[R11]

en.wikipedia.org/wiki/Invertible_matrix

handler = <dispatched InvertibleHandler>

class sympy.assumptions.predicates.matrices.OrthogonalPredicate(*args, **kwargs)

正交矩阵谓词。

解释

Q.orthogonal(x) 是当且仅当 x 是正交矩阵时为真。一个方阵 M 是正交矩阵，如果它满足 M^TM = MM^T = I，其中 M^T 是 M 的转置矩阵，I 是单位矩阵。需要注意的是，正交矩阵必定可逆。

示例

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

处理键为‘orthogonal’的处理器。

参考文献

[R12]

en.wikipedia.org/wiki/Orthogonal_matrix

handler = <dispatched OrthogonalHandler>

class sympy.assumptions.predicates.matrices.UnitaryPredicate(*args, **kwargs)

酉矩阵断言。

解释

Q.unitary(x) 当且仅当 x 是一个酉矩阵时为真。酉矩阵是正交矩阵的类比。一个复元素矩阵 M 是酉矩阵如果 :math:M^TM = MM^T= I，其中 :math:M^T 是 M 的共轭转置矩阵。

例子

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

处理器

多重分派方法：UnitaryHandler

处理键为‘unitary’的处理器。

参考文献

[R13]

en.wikipedia.org/wiki/Unitary_matrix

handler = <dispatched UnitaryHandler>

class sympy.assumptions.predicates.matrices.PositiveDefinitePredicate(*args, **kwargs)

正定矩阵断言。

解释

如果 (M) 是一个 (n \times n) 的对称实矩阵，当对于每个非零的 (n) 维实数列向量 (Z)，(Z^TMZ) 都是正数时，称其为正定矩阵。

例子

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

处理器

多重分派方法：PositiveDefiniteHandler

处理键为‘positive_definite’的处理器。

参考文献

[R14]

en.wikipedia.org/wiki/Positive-definite_matrix

handler = <dispatched PositiveDefiniteHandler>

class sympy.assumptions.predicates.matrices.UpperTriangularPredicate(*args, **kwargs)

上三角矩阵断言。

解释

如果矩阵 (M) 满足 (M_{ij}=0) 对于 (i<j)，则称其为上三角矩阵。

例子

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

处理器

多重分派方法：UpperTriangularHandler

处理键为‘upper_triangular’的处理器。

参考文献

[R15]

mathworld.wolfram.com/UpperTriangularMatrix.html

handler = <dispatched UpperTriangularHandler>

class sympy.assumptions.predicates.matrices.LowerTriangularPredicate(*args, **kwargs)

下三角矩阵断言。

解释

如果矩阵 (M) 满足 (M_{ij}=0) 对于 (i>j)，则称其为下三角矩阵。

例子

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

处理器

多重分派方法：LowerTriangularHandler

处理键为‘lower_triangular’的处理器。

参考文献

[R16]

mathworld.wolfram.com/LowerTriangularMatrix.html

handler = <dispatched LowerTriangularHandler>

class sympy.assumptions.predicates.matrices.DiagonalPredicate(*args, **kwargs)

对角矩阵断言。

解释

Q.diagonal(x) 当且仅当 x 是一个对角矩阵时为真。对角矩阵是主对角线以外的元素全部为零的矩阵。

例子

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

处理器

多重分派方法：DiagonalHandler

处理键为‘diagonal’的处理器。

参考文献

[R17]

en.wikipedia.org/wiki/Diagonal_matrix

handler = <dispatched DiagonalHandler>

class sympy.assumptions.predicates.matrices.FullRankPredicate(*args, **kwargs)

全秩矩阵断言。

解释

Q.fullrank(x) 当且仅当 x 是一个满秩矩阵时为真。矩阵的所有行和列线性无关时称其为满秩矩阵。一个方阵的行列式非零时，称其为满秩矩阵。

例子

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

处理器

多重分派方法：FullRankHandler

处理键为‘fullrank’的处理器。

handler = <dispatched FullRankHandler>

class sympy.assumptions.predicates.matrices.SquarePredicate(*args, **kwargs)

方阵断言。

解释

Q.square(x) 当且仅当 x 是一个方阵时为真。方阵是行数和列数相等的矩阵。

例子

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

处理器

多重分派方法：SquareHandler

处理键为 Q.square 的处理器。

参考文献

[R18]

en.wikipedia.org/wiki/Square_matrix

handler = <dispatched SquareHandler>

class sympy.assumptions.predicates.matrices.IntegerElementsPredicate(*args, **kwargs)

整数元素矩阵断言。

解释

Q.integer_elements(x) 当x的所有元素都是整数时为真。

示例

>>> from sympy import Q, ask, MatrixSymbol
>>> X = MatrixSymbol('X', 4, 4)
>>> ask(Q.integer(X[1, 2]), Q.integer_elements(X))
True

处理器

多重分发方法：IntegerElementsHandler

处理器用于关键字‘integer_elements’。

handler = <dispatched IntegerElementsHandler>

class sympy.assumptions.predicates.matrices.RealElementsPredicate(*args, **kwargs)

实元素矩阵谓词。

解释

Q.real_elements(x) 当x的所有元素都是实数时为真。

示例

>>> from sympy import Q, ask, MatrixSymbol
>>> X = MatrixSymbol('X', 4, 4)
>>> ask(Q.real(X[1, 2]), Q.real_elements(X))
True

处理器

多重分发方法：RealElementsHandler

处理器用于关键字‘real_elements’。

handler = <dispatched RealElementsHandler>

class sympy.assumptions.predicates.matrices.ComplexElementsPredicate(*args, **kwargs)

复杂元素矩阵谓词。

解释

Q.complex_elements(x) 当x的所有元素都是复数时为真。

示例

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

处理器

多重分发方法：ComplexElementsHandler

处理器用于关键字‘complex_elements’。

handler = <dispatched ComplexElementsHandler>

class sympy.assumptions.predicates.matrices.SingularPredicate(*args, **kwargs)

奇异矩阵谓词。

矩阵奇异当且仅当其行列式的值为 0。

示例

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

处理器

多重分发方法：SingularHandler

关键字‘singular’的谓词。

参考文献

[R19]

mathworld.wolfram.com/SingularMatrix.html

handler = <dispatched SingularHandler>

class sympy.assumptions.predicates.matrices.NormalPredicate(*args, **kwargs)

正规矩阵谓词。

矩阵是正规的当且仅当它与其共轭转置交换。

示例

>>> from sympy import Q, ask, MatrixSymbol
>>> X = MatrixSymbol('X', 4, 4)
>>> ask(Q.normal(X), Q.unitary(X))
True

处理器

多重分发方法：NormalHandler

关键字‘normal’的谓词。

参考文献

[R20]

zh.wikipedia.org/wiki/正规矩阵

handler = <dispatched NormalHandler>

class sympy.assumptions.predicates.matrices.TriangularPredicate(*args, **kwargs)

三角矩阵谓词。

解释

Q.triangular(X) 当X是下三角或上三角时为真。

示例

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

处理器

多重分发方法：TriangularHandler

关键字‘triangular’的谓词。

参考文献

[R21]

zh.wikipedia.org/wiki/三角矩阵

handler = <dispatched TriangularHandler>

class sympy.assumptions.predicates.matrices.UnitTriangularPredicate(*args, **kwargs)

单位三角形矩阵谓词。

解释

单位三角形矩阵是一个对角线上有 1 的三角形矩阵。

示例

>>> from sympy import Q, ask, MatrixSymbol
>>> X = MatrixSymbol('X', 4, 4)
>>> ask(Q.triangular(X), Q.unit_triangular(X))
True

处理器

多重分发方法：UnitTriangularHandler

关键字‘unit_triangular’的谓词。

handler = <dispatched UnitTriangularHandler>

数论

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

偶数谓词。

解释

ask(Q.even(x)) 当x属于偶数集合时为真。

示例

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

处理器

多重分发方法：EvenHandler

处理器用于关键字‘even’。

handler = <dispatched EvenHandler>

class sympy.assumptions.predicates.ntheory.OddPredicate(*args, **kwargs)

奇数谓词。

解释

ask(Q.odd(x)) 当x属于奇数集合时为真。

示例

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

处理器

多重分发方法：OddHandler

处理器用于关键字‘odd’。测试一个表达式是否表示一个奇数。

handler = <dispatched OddHandler>

class sympy.assumptions.predicates.ntheory.PrimePredicate(*args, **kwargs)

质数谓词。

解释

ask(Q.prime(x)) 当x是大于 1 且没有除了1和自身外的正除数的自然数时为真。

示例

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

处理器

多重分发方法：PrimeHandler

处理器用于关键字‘prime’。测试一个表达式是否表示一个质数。当表达式是一个确切的数时，结果（为真时）受 isprime()的限制，该函数用于返回结果。

handler = <dispatched PrimeHandler>

class sympy.assumptions.predicates.ntheory.CompositePredicate(*args, **kwargs)

复合数谓词。

解释

ask(Q.composite(x)) 当x是一个正整数且除了1和自身外至少有一个正除数时为真。

示例

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

处理器

多重分发方法：CompositeHandler

处理器用于关键字‘composite’。

handler = <dispatched CompositeHandler>

顺序

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

正实数谓词。

解释

Q.positive(x) 当且仅当 x 是实数且 ( x > 0 ) 时为真，即 x 在区间 ((0, \infty)) 内。特别地，无穷不是正数。

关于正数的几个重要事实：

注意 Q.nonpositive 和 ~Q.positive 不是相同的。

事物。 ~Q.positive(x) 简单地表示 x 不是正数，而 Q.nonpositive(x) 表示 x 是实数且不是正数，即 Q.nonpositive(x) 在逻辑上等价于 (Q.negative(x) | Q.zero(x))。例如，~Q.positive(I) 为真，而 Q.nonpositive(I) 为假。
查看有关 Q.real 的文档以获取更多信息

相关事实。

示例

>>> 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 = <dispatched PositiveHandler>

class sympy.assumptions.predicates.order.NegativePredicate(*args, **kwargs)

负数谓词。

解释

Q.negative(x) 当且仅当 x 是实数且 ( x < 0 ) 时为真，即 x 在区间 ((-\infty, 0)) 内。特别注意负无穷不是负数。

关于负数的几个重要事实：

注意 Q.nonnegative 和 ~Q.negative 不是相同的。

事物。 ~Q.negative(x) 简单地表示 x 不是负数，而 Q.nonnegative(x) 表示 x 是实数且不是负数，即 Q.nonnegative(x) 在逻辑上等价于 Q.zero(x) | Q.positive(x)。例如，~Q.negative(I) 为真，而 Q.nonnegative(I) 为假。
查看有关 Q.real 的文档以获取更多信息。

相关事实。

示例

>>> 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 = <dispatched NegativeHandler>

class sympy.assumptions.predicates.order.ZeroPredicate(*args, **kwargs)

零数谓词。

解释

ask(Q.zero(x)) 当且仅当 x 的值为零时为真。

示例

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

处理程序

多重分派方法：零处理程序

键为‘zero’的处理程序。

handler = <dispatched ZeroHandler>

class sympy.assumptions.predicates.order.NonZeroPredicate(*args, **kwargs)

非零实数谓词。

解释

ask(Q.nonzero(x)) 当且仅当 x 是实数且 x 不为零时为真。特别注意，如果 x 不是实数，则 Q.nonzero(x) 为假。如果要求不带任何实数假设的非零否定，请使用 ~Q.zero(x)。

关于非零数的几个重要事实：

Q.nonzero 在逻辑上等价于 Q.positive | Q.negative。
查看有关 Q.real 的文档以获取更多信息

相关事实。

示例

>>> 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 = <dispatched NonZeroHandler>

class sympy.assumptions.predicates.order.NonPositivePredicate(*args, **kwargs)

非正实数谓词。

解释

ask(Q.nonpositive(x)) 当且仅当 x 属于包括零的负数集时为真。

注意 Q.nonpositive 和 ~Q.positive 不是相同的。

事物。 ~Q.positive(x) 简单地表示 x 不是正数，而 Q.nonpositive(x) 表示 x 是实数且不是正数，即 Q.nonpositive(x) 在逻辑上等价于 (Q.negative(x) | Q.zero(x))。例如，~Q.positive(I) 为真，而 Q.nonpositive(I) 为假。

示例

>>> 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 = <dispatched NonPositiveHandler>

class sympy.assumptions.predicates.order.NonNegativePredicate(*args, **kwargs)

非负实数谓词。

解释

ask(Q.nonnegative(x)) 当且仅当 x 属于包括零在内的正数集时为真。

请注意，Q.nonnegative 和 ~Q.negative 不是相同的

事情。~Q.negative(x) 简单地意味着 x 不是负数，而 Q.nonnegative(x) 意味着 x 是实数且不为负数，即 Q.nonnegative(x) 在逻辑上等价于 Q.zero(x) | Q.positive(x)。因此，例如，~Q.negative(I) 为真，而 Q.nonnegative(I) 为假。

例子

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

处理

多重调度方法：非负数处理器

处理 Q.nonnegative。

handler = <dispatched NonNegativeHandler>

集合

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

整数谓词。

解释

Q.integer(x) 当且仅当 x 属于整数集合时为真。

例子

>>> from sympy import Q, ask, S
>>> ask(Q.integer(5))
True
>>> ask(Q.integer(S(1)/2))
False

处理

多重调度方法：整数处理器

处理 Q.integer。

测试表达式是否属于整数域。

参考资料

[R22]

en.wikipedia.org/wiki/Integer

handler = <dispatched IntegerHandler>

class sympy.assumptions.predicates.sets.RationalPredicate(*args, **kwargs)

有理数谓词。

解释

Q.rational(x) 当且仅当 x 属于有理数集合时为真。

例子

>>> from sympy import ask, Q, pi, S
>>> ask(Q.rational(0))
True
>>> ask(Q.rational(S(1)/2))
True
>>> ask(Q.rational(pi))
False

处理

多重调度方法：有理数处理器

处理 Q.rational。

测试表达式是否属于有理数域。

参考资料

[R23]

en.wikipedia.org/wiki/Rational_number

handler = <dispatched RationalHandler>

class sympy.assumptions.predicates.sets.IrrationalPredicate(*args, **kwargs)

无理数谓词。

解释

Q.irrational(x) 当且仅当 x 是任何不能表示为整数比的实数时为真。

例子

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

处理

多重调度方法：无理数处理器

处理 Q.irrational。

测试表达式是否是无理数。

参考资料

[R24]

en.wikipedia.org/wiki/Irrational_number

handler = <dispatched IrrationalHandler>

class sympy.assumptions.predicates.sets.RealPredicate(*args, **kwargs)

实数谓词。

解释

Q.real(x) 当且仅当 x 是实数时为真，即它在区间 ((-\infty, \infty)) 内。请注意，特别是无穷大不是实数。如果要考虑这些，请使用 Q.extended_real。

关于实数的几个重要事实：

每个实数要么是正数、负数或零。此外，

因为这些集合两两不交，每个实数恰好是这三个集合中的一个。
每个实数也是复数。
每个实数都是有限的。
每个实数要么是有理数要么是无理数。
每个实数要么是代数的要么是超越的。
事实 Q.negative、Q.zero、Q.positive，

Q.nonnegative、Q.nonpositive、Q.nonzero、Q.integer、Q.rational 和 Q.irrational 都意味着 Q.real，就像暗示这些事实的所有事实一样。
事实 Q.algebraic 和 Q.transcendental 不意味着

Q.real；它们暗示 Q.complex。代数或超越数可能是实数也可能不是。
“非”事实（即 Q.nonnegative、Q.nonzero，

Q.nonpositive 和 Q.noninteger）与事实不等同，而是事实和Q.real。例如，Q.nonnegative 意味着 ~Q.negative & Q.real。因此，例如，I 不是非负、非零或非正。

例子

>>> from sympy import Q, ask, symbols
>>> x = symbols('x')
>>> ask(Q.real(x), Q.positive(x))
True
>>> ask(Q.real(0))
True

处理

多重分派方法：RealHandler

Q.real 的处理器。

测试一个表达式是否属于实数域。

参考文献

[R25]

en.wikipedia.org/wiki/Real_number

handler = <dispatched RealHandler>

class sympy.assumptions.predicates.sets.ExtendedRealPredicate(*args, **kwargs)

扩展实数判断。

解释

Q.extended_real(x) 当且仅当 x 是实数或 ({-\infty, \infty}) 时为真。

有关相关事实的 Q.real 文档，请参阅文档。

例子

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

处理器

多重分派方法：ExtendedRealHandler

Q.extended_real 的处理器。

测试一个表达式是否属于扩展实数域

数字，即实数并集 {Infinity, -Infinity}。

handler = <dispatched ExtendedRealHandler>

class sympy.assumptions.predicates.sets.HermitianPredicate(*args, **kwargs)

厄尔米特数判断。

解释

ask(Q.hermitian(x)) 当且仅当 x 属于厄尔米特操作符集合时为真。

处理器

多重分派方法：HermitianHandler

Q.hermitian 的处理器。

测试一个表达式是否属于厄尔米特操作符域。

参考文献

[R26]

mathworld.wolfram.com/HermitianOperator.html

handler = <dispatched HermitianHandler>

class sympy.assumptions.predicates.sets.ComplexPredicate(*args, **kwargs)

复数判断。

解释

Q.complex(x) 当且仅当 x 属于复数集合时为真。请注意每个复数都是有限的。

例子

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

处理器

多重分派方法：ComplexHandler

Q.complex 的处理器。

测试一个表达式是否属于复数域。

参考文献

[R27]

en.wikipedia.org/wiki/Complex_number

handler = <dispatched ComplexHandler>

class sympy.assumptions.predicates.sets.ImaginaryPredicate(*args, **kwargs)

虚数判断。

解释

Q.imaginary(x) 当且仅当 x 可以写成实数乘以虚数单位 I 时为真。请注意 0 不被认为是虚数。

例子

>>> from sympy import Q, ask, I
>>> ask(Q.imaginary(3*I))
True
>>> ask(Q.imaginary(2 + 3*I))
False
>>> ask(Q.imaginary(0))
False

处理器

多重分派方法：ImaginaryHandler

Q.imaginary 的处理器。

测试一个表达式是否属于虚数域，

即形如 x*I 的数，其中 x 是实数。

参考文献

[R28]

en.wikipedia.org/wiki/Imaginary_number

handler = <dispatched ImaginaryHandler>

class sympy.assumptions.predicates.sets.AntihermitianPredicate(*args, **kwargs)

反埃尔米特数判断。

解释

Q.antihermitian(x) 当且仅当 x 属于反阿尔米特操作符域时为真，即形如 x*I 的操作符，其中 x 是厄尔米特的。

处理器

多重分派方法：AntiHermitianHandler

Q.antihermitian 的处理器。

测试一个表达式是否属于反厄尔米特操作符域

操作符，即形如 x*I 的操作符，其中 x 是厄尔米特的。

参考文献

[R29]

mathworld.wolfram.com/HermitianOperator.html

handler = <dispatched AntiHermitianHandler>

class sympy.assumptions.predicates.sets.AlgebraicPredicate(*args, **kwargs)

代数数判断。

解释

Q.algebraic(x) 当且仅当 x 属于代数数集合时为真。如果存在多项式 p(x)\in \mathbb{Q}[x] 使得 p(x) = 0，则 x 是代数的。

例子

>>> from sympy import ask, Q, sqrt, I, pi
>>> ask(Q.algebraic(sqrt(2)))
True
>>> ask(Q.algebraic(I))
True
>>> ask(Q.algebraic(pi))
False

处理器

多重分派方法：AskAlgebraicpredicateHandler

AskAlgebraicpredicateHandler 的关键处理器

参考文献

[R30]

en.wikipedia.org/wiki/Algebraic_number

AlgebraicHandler = <dispatched AlgebraicHandler>

handler = <dispatched AskAlgebraicpredicateHandler>

class sympy.assumptions.predicates.sets.TranscendentalPredicate(*args, **kwargs)

超越数述词。

解释

Q.transcendental(x) 当且仅当 x 属于超越数集时为真。超越数是一个既非代数的实数也非复数。

处理程序

多重派发方法：超越数

Q.transcendental 键的处理程序。

handler = <dispatched Transcendental>

SymPy-1-13-中文文档-八-

SymPy 1.13 中文文档（八）

假设

谓词

查询

内容

性能改进

杂项

问

假设

精炼

谓词

Common

微积分

矩阵

数论

顺序

集合