假设¶

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

谓词¶

class sympy.assumptions.assume.Predicate(*args, **kwargs)[源代码][源代码]

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

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
二进制符号
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_free_symbols
free_symbols: 从自身的原子中返回那些自由符号。
func: 表达式中的顶级函数。
is_algebraic
is_antihermitian
is_commutative
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_complex
is_composite
is_even
is_extended_negative
is_extended_nonnegative
is_extended_nonpositive
is_extended_nonzero
is_extended_positive
is_extended_real
is_finite
is_hermitian
is_imaginary
is_infinite
is_integer
is_irrational
is_negative
is_noninteger
is_nonnegative
is_nonpositive
is_nonzero
is_odd
is_polar
is_positive
is_prime
is_rational
is_real
is_transcendental
is_zero
名称

方法

`__call__`(*args)
`as_content_primitive`([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
`as_dummy`()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
`as_set`()	重写布尔表达式为实数集的形式。
`atoms`(*types)	返回构成当前对象的原子。
`class_key`()	类的好顺序。
`compare`(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
`count`(query)	计算匹配的子表达式的数量。
`count_ops`([visual])	用于返回操作计数的 count_ops 的包装器。
`doit`(**hints)	评估默认情况下不评估的对象，如极限、积分、求和和乘积。
`dummy_eq`(other[, symbol])	比较两个表达式并处理哑符号。
`equals`(other)	如果给定的公式具有相同的真值表，则返回 `True`。
`eval`(args[, assumptions])	在给定的假设下评估 `self(*args)`。
`find`(query[, group])	查找所有匹配查询的子表达式。
`fromiter`(args, **assumptions)	从可迭代对象创建一个新对象。
`handler`
`has`(*patterns)	测试是否有任何子表达式匹配任何模式。
`has_free`(*patterns)	如果 self 包含对象 `x` 作为自由表达式，则返回 True，否则返回 False。
`has_xfree`(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
`is_same`(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
`match`(pattern[, old])	模式匹配。
`matches`(expr[, repl_dict, old])	用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
`rcall`(*args)	通过表达式树递归应用于参数。
`refine`([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
`register`(types, *kwargs)	将签名注册到处理程序。
`register_many`(types, *kwargs)	注册多个签名到同一个处理程序。
`replace`(query, value[, map, simultaneous, exact])	将 `self` 中匹配的子表达式替换为 `value`。
`rewrite`(*args[, deep])	使用定义的规则重写 self。
`simplify`(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
`sort_key`([order])	返回一个排序键。
`subs`(args, *kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
`xreplace`(rule)	替换表达式中对象的出现。

复制
could_extract_minus_sign
is_hypergeometric
to_nnf

参考文献

[1]

https://zh.wikipedia.org/wiki/谓词_(数学逻辑)

[2]

https://zh.wikipedia.org/wiki/性感质数

示例

应用并评估为布尔值：

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

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() 函数。

属性:

arg: 返回此假设使用的表达式。
args: 返回 ‘self’ 的参数元组。
arguments: 返回应用于谓词的参数。
assumptions0: 返回对象 \(type\) 假设。
二进制符号
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_free_symbols
free_symbols: 从自身的原子中返回那些自由符号。
func: 表达式中的顶级函数。
function: 返回谓词。
is_algebraic
is_antihermitian
is_commutative
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_complex
is_composite
is_even
is_extended_negative
is_extended_nonnegative
is_extended_nonpositive
is_extended_nonzero
is_extended_positive
is_extended_real
is_finite
is_hermitian
is_imaginary
is_infinite
is_integer
is_irrational
is_negative
is_noninteger
is_nonnegative
is_nonpositive
is_nonzero
is_odd
is_polar
is_positive
is_prime
is_rational
is_real
is_transcendental
is_zero

方法

`as_content_primitive`([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
`as_dummy`()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
`as_set`()	重写布尔表达式为实数集的形式。
`atoms`(*types)	返回构成当前对象的原子。
`class_key`()	类的好顺序。
`compare`(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
`count`(query)	计算匹配的子表达式的数量。
`count_ops`([visual])	用于返回操作计数的 count_ops 的包装器。
`doit`(**hints)	评估默认情况下不评估的对象，如极限、积分、求和和乘积。
`dummy_eq`(other[, symbol])	比较两个表达式并处理哑符号。
`equals`(other)	如果给定的公式具有相同的真值表，则返回 `True`。
`find`(query[, group])	查找所有匹配查询的子表达式。
`fromiter`(args, **assumptions)	从可迭代对象创建一个新对象。
`has`(*patterns)	测试是否有任何子表达式匹配任何模式。
`has_free`(*patterns)	如果 self 包含对象 `x` 作为自由表达式，则返回 True，否则返回 False。
`has_xfree`(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
`is_same`(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
`match`(pattern[, old])	模式匹配。
`matches`(expr[, repl_dict, old])	用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
`rcall`(*args)	通过表达式树递归应用于参数。
`refine`([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
`replace`(query, value[, map, simultaneous, exact])	将 `self` 中匹配的子表达式替换为 `value`。
`rewrite`(*args[, deep])	使用定义的规则重写 self。
`simplify`(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
`sort_key`([order])	返回一个排序键。
`subs`(args, *kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
`xreplace`(rule)	替换表达式中对象的出现。

复制
could_extract_minus_sign
is_hypergeometric
to_nnf

示例

>>> 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 包装。
假设布尔值，可选: 评估命题的本地假设。
上下文AssumptionsContext，可选: 评估命题的默认假设。默认情况下，这是 sympy.assumptions.global_assumptions 变量。

返回:

True, False, 或 None

Raises:

TypeError : 命题或假设不是有效的逻辑表达式。命题或假设不是有效的逻辑表达式。
ValueError假设不一致。

参见

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

注释

假设中的关系尚未实现（目前），因此以下内容不会产生有意义的结果。

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

然而，这是一个正在进行的工作。

示例

>>> 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 的第二个可选参数应为一个涉及 expr 中对象假设的布尔表达式。有效值包括：

Q.integer(x)

Q.positive(x)

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

等等。

Q 是一个保存已知谓词的对象。

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

你也可以定义一个上下文，这样就不必每次调用函数 ask() 时都传递该参数。这可以通过使用 sympy.assumptions 模块中的 assuming 上下文管理器来实现。:

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

内容¶

性能提升¶

在涉及符号系数的查询中，使用逻辑推理。改进 satisfiable 函数（sympy.logic.inference.satisfiable）的工作应能显著提高速度。

在一个请求中使用的逻辑推理可以用来加速后续查询，而当前系统并未利用这一点。例如，可以实现一个真值维护系统（https://en.wikipedia.org/wiki/Truth_maintenance_system）。

杂项¶

你可以在 sympy/assumptions/tests/ 目录中找到更多以测试形式出现的示例。