逻辑

介绍

SymPy 的逻辑模块允许使用符号和布尔值来形成和操作逻辑表达式。

形成逻辑表达式

你可以使用标准的 Python 运算符 & (And)、| (Or)、~ (Not) 构建布尔表达式:

>>> from sympy import *
>>> x, y = symbols('x,y')
>>> y | (x & y)
y | (x & y)
>>> x | y
x | y
>>> ~x
~x

你也可以使用 >> 和 << 形成推论:

>>> x >> y
Implies(x, y)
>>> x << y
Implies(y, x)

与SymPy中的大多数类型一样，布尔表达式继承自 Basic:

>>> (y & x).subs({x: True, y: True})
True
>>> (x | y).atoms()
{x, y}

逻辑模块还包括以下功能，用于从真值表推导布尔表达式：

sympy.logic.boolalg.SOPform(variables, minterms, dontcares=None)

SOPform 函数使用简化对和消除冗余组的算法，将生成 ‘1’（最小项）的所有输入组合列表转换为最小的乘积和形式。

变量必须作为第一个参数给出。

返回一个逻辑的 Or 函数（即，“乘积和”或“SOP”形式），以获得所需的结果。如果有可以忽略的输入，也将它们作为列表传递。

结果将是满足条件（可能有很多）的函数之一。

参见

POSform

参考文献

[1]

https://en.wikipedia.org/wiki/Quine-McCluskey_algorithm

[2]

https://en.wikipedia.org/wiki/无关项

示例

>>> from sympy.logic import SOPform
>>> from sympy import symbols
>>> w, x, y, z = symbols('w x y z')
>>> minterms = [[0, 0, 0, 1], [0, 0, 1, 1],
...             [0, 1, 1, 1], [1, 0, 1, 1], [1, 1, 1, 1]]
>>> dontcares = [[0, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 1]]
>>> SOPform([w, x, y, z], minterms, dontcares)
(y & z) | (~w & ~x)

这些术语也可以表示为整数：

>>> minterms = [1, 3, 7, 11, 15]
>>> dontcares = [0, 2, 5]
>>> SOPform([w, x, y, z], minterms, dontcares)
(y & z) | (~w & ~x)

它们也可以使用字典来指定，这些字典不需要完全指定：

>>> minterms = [{w: 0, x: 1}, {y: 1, z: 1, x: 0}]
>>> SOPform([w, x, y, z], minterms)
(x & ~w) | (y & z & ~x)

或组合：

>>> minterms = [4, 7, 11, [1, 1, 1, 1]]
>>> dontcares = [{w : 0, x : 0, y: 0}, 5]
>>> SOPform([w, x, y, z], minterms, dontcares)
(w & y & z) | (~w & ~y) | (x & z & ~w)

sympy.logic.boolalg.POSform(variables, minterms, dontcares=None)

POSform 函数使用简化对和消除冗余组的算法，将生成 ‘1’（最小项）的所有输入组合列表转换为最小的和积形式。

变量必须作为第一个参数给出。

返回一个逻辑的 And 函数（即，“和的乘积”或“POS”形式），以获得所需的结果。如果有可以忽略的输入，也将它们作为列表传递。

结果将是满足条件（可能有很多）的函数之一。

参见

SOPform

参考文献

[1]

https://en.wikipedia.org/wiki/Quine-McCluskey_algorithm

[2]

https://en.wikipedia.org/wiki/无关项

示例

>>> from sympy.logic import POSform
>>> from sympy import symbols
>>> w, x, y, z = symbols('w x y z')
>>> minterms = [[0, 0, 0, 1], [0, 0, 1, 1], [0, 1, 1, 1],
...             [1, 0, 1, 1], [1, 1, 1, 1]]
>>> dontcares = [[0, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 1]]
>>> POSform([w, x, y, z], minterms, dontcares)
z & (y | ~w)

这些术语也可以表示为整数：

>>> minterms = [1, 3, 7, 11, 15]
>>> dontcares = [0, 2, 5]
>>> POSform([w, x, y, z], minterms, dontcares)
z & (y | ~w)

它们也可以使用字典来指定，这些字典不需要完全指定：

>>> minterms = [{w: 0, x: 1}, {y: 1, z: 1, x: 0}]
>>> POSform([w, x, y, z], minterms)
(x | y) & (x | z) & (~w | ~x)

或组合：

>>> minterms = [4, 7, 11, [1, 1, 1, 1]]
>>> dontcares = [{w : 0, x : 0, y: 0}, 5]
>>> POSform([w, x, y, z], minterms, dontcares)
(w | x) & (y | ~w) & (z | ~y)

sympy.logic.boolalg.ANFform(variables, truthvalues)

ANFform 函数将真值列表转换为代数正规形式（ANF）。

变量必须作为第一个参数给出。

返回 True、False、逻辑 And 函数（即“Zhegalkin 单项式”）或逻辑 Xor 函数（即“Zhegalkin 多项式”）。当 True 和 False 分别由 1 和 0 表示时，And 是乘法，而 Xor 是加法。

形式上，“Zhegalkin 单项式”是有限个不同变量的乘积（逻辑与），包括空集，其乘积记为 1（真）。“Zhegalkin 多项式”是 Zhegalkin 单项式的集合的和（逻辑异或），空集记为 0（假）。

参数:

变量变量列表

真值1 和 0 的列表（真值表的结果列）

参考文献

[1]

https://en.wikipedia.org/wiki/Zhegalkin_polynomial

示例

>>> from sympy.logic.boolalg import ANFform
>>> from sympy.abc import x, y
>>> ANFform([x], [1, 0])
x ^ True
>>> ANFform([x, y], [0, 1, 1, 1])
x ^ y ^ (x & y)

布尔函数

class sympy.logic.boolalg.Boolean(*args)

布尔对象是逻辑操作有意义的对象。

属性:

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

方法

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

as_set()

重写布尔表达式为实数集的形式。

示例

>>> from sympy import Symbol, Eq, Or, And
>>> x = Symbol('x', real=True)
>>> Eq(x, 0).as_set()
{0}
>>> (x > 0).as_set()
Interval.open(0, oo)
>>> And(-2 < x, x < 2).as_set()
Interval.open(-2, 2)
>>> Or(x < -2, 2 < x).as_set()
Union(Interval.open(-oo, -2), Interval.open(2, oo))

equals(other)

如果给定的公式具有相同的真值表，则返回 True。要使两个公式相等，它们必须具有相同的文字。

示例

>>> from sympy.abc import A, B, C
>>> from sympy import And, Or, Not
>>> (A >> B).equals(~B >> ~A)
True
>>> Not(And(A, B, C)).equals(And(Not(A), Not(B), Not(C)))
False
>>> Not(And(A, Not(A))).equals(Or(B, Not(B)))
False

class sympy.logic.boolalg.BooleanTrue

SymPy 版本的 True，一个可以通过 S.true 访问的单例。

这是 SymPy 版本的 True，用于逻辑模块。使用 true 而不是 True 的主要优势是，像 ~ 和 >> 这样的简写布尔运算符将按预期在此类上工作，而在 True 上它们对 1 进行按位操作。逻辑模块中的函数在评估为真时将返回此类。

属性:

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

否定

方法

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(*a, **kw)
sort_key([order])	返回一个排序键。
subs(*args, **kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
xreplace(rule)	替换表达式中对象的出现。

复制
could_extract_minus_sign
展开
is_hypergeometric
to_nnf

参见

sympy.logic.boolalg.BooleanFalse

注释

在SymPy的各种上下文中，何时使用 True 以及何时使用 S.true 可能会引起一些混淆。需要记住的重要一点是，sympify(True) 返回 S.true。这意味着在大多数情况下，你可以直接使用 True，它会在必要时自动转换为 S.true，类似于你通常可以使用 1 代替 S.One。

经验法则是：

如果所讨论的布尔值可以被任意符号 Boolean 替换，例如 Or(x, y) 或 x > 1，请使用 S.true。否则，请使用 True。

换句话说，只有在布尔值被用作真值的符号表示的情况下，才使用 S.true。例如，如果对象最终出现在任何表达式的 .args 中，那么它必须必然是 S.true 而不是 True，因为 .args 的元素必须是 Basic。另一方面，== 在 SymPy 中不是符号操作，因为它总是返回 True 或 False，并且是以结构相等而不是数学相等的方式返回，所以它应该返回 True。假设系统应该使用 True 和 False。除了不满足上述经验法则外，假设系统使用三值逻辑（True、False、None），而 S.true 和 S.false 表示二值逻辑。如果有疑问，使用 True。

S.true == True is True.

虽然 S.true is True 是 False，但 S.true == True 是 True，所以如果有任何疑问关于函数或表达式会返回 S.true 还是 True，只需使用 == 而不是 is 来进行比较，这样在任何情况下都能正常工作。最后，对于布尔标志，最好直接使用 if x 而不是 if x is True。引用 PEP 8 的话：

不要使用 == 将布尔值与 True 或 False 进行比较。

• 是的: if greeting:

• 不: if greeting == True:

• 更糟糕的是：if greeting is True:

示例

>>> from sympy import sympify, true, false, Or
>>> sympify(True)
True
>>> _ is True, _ is true
(False, True)

>>> Or(true, false)
True
>>> _ is true
True

Python 运算符对 true 给出布尔结果，但对 True 给出按位结果。

>>> ~true, ~True  
(False, -2)
>>> true >> true, True >> True
(True, 0)

as_set()

用实数集重写逻辑运算符和关系运算符。

示例

>>> from sympy import true
>>> true.as_set()
UniversalSet

class sympy.logic.boolalg.BooleanFalse

SymPy 版本的 False，一个可以通过 S.false 访问的单例。

这是 False 的 SymPy 版本，用于逻辑模块。使用 false 而不是 False 的主要优势是，像 ~ 和 >> 这样的简写布尔操作将按预期在此类上工作，而 False 则会按位操作 0。逻辑模块中的函数在评估为假时将返回此类。

属性:

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

否定

方法

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(*a, **kw)
sort_key([order])	返回一个排序键。
subs(*args, **kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
xreplace(rule)	替换表达式中对象的出现。

复制
could_extract_minus_sign
展开
is_hypergeometric
to_nnf

参见

sympy.logic.boolalg.BooleanTrue

注释

请参阅 sympy.logic.boolalg.BooleanTrue 中的注释部分

示例

>>> from sympy import sympify, true, false, Or
>>> sympify(False)
False
>>> _ is False, _ is false
(False, True)

>>> Or(true, false)
True
>>> _ is true
True

Python 运算符对 false 给出布尔结果，但对 False 给出按位结果。

>>> ~false, ~False  
(True, -1)
>>> false >> false, False >> False
(True, 0)

as_set()

用实数集重写逻辑运算符和关系运算符。

示例

>>> from sympy import false
>>> false.as_set()
EmptySet

class sympy.logic.boolalg.And(*args)

逻辑与函数。

它按顺序评估其参数，当一个参数为假时立即返回假，如果所有参数都为真则返回真。

属性:

args

返回 ‘self’ 的参数元组。

assumptions0

返回对象 \(type\) 假设。

二进制符号

canonical_variables

返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。

expr_free_symbols

func

表达式中的顶级函数。

is_algebraic

is_antihermitian

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 的包装器。
diff(*symbols, **assumptions)
doit(**hints)
dummy_eq(other[, symbol])	比较两个表达式并处理哑符号。
equals(other)	如果给定的公式具有相同的真值表，则返回 True。
eval(*args)	返回应用于参数 args 的 cls 的规范形式。
find(query[, group])	查找所有匹配查询的子表达式。
flatten(seq)	返回序列，使得序列中没有任何元素的类型为 \(cls\)。
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。
make_args(expr)	返回一组参数，使得 cls(*arg_set) == expr。
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)
sort_key([order])	返回一个排序键。
subs(*args, **kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
xreplace(**_)

binary_check_and_simplify
复制
could_extract_minus_sign
is_hypergeometric
to_anf
to_nnf

注释

& 运算符作为便利提供，但请注意，它在这里的使用与在 Python 中的正常使用不同，后者是按位与。因此，And(a, b) 和 a & b 如果 a 和 b 是整数，将产生不同的结果。

>>> And(x, y).subs(x, 1)
y

示例

>>> from sympy.abc import x, y
>>> from sympy import And
>>> x & y
x & y

class sympy.logic.boolalg.Or(*args)

逻辑或函数

它按顺序评估其参数，当一个参数为真时立即返回真，如果所有参数都为假则返回假。

属性:

args

返回 ‘self’ 的参数元组。

assumptions0

返回对象 \(type\) 假设。

二进制符号

canonical_variables

返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。

expr_free_symbols

func

表达式中的顶级函数。

is_algebraic

is_antihermitian

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 的包装器。
diff(*symbols, **assumptions)
doit(**hints)
dummy_eq(other[, symbol])	比较两个表达式并处理哑符号。
equals(other)	如果给定的公式具有相同的真值表，则返回 True。
eval(*args)	返回应用于参数 args 的 cls 的规范形式。
find(query[, group])	查找所有匹配查询的子表达式。
flatten(seq)	返回序列，使得序列中没有任何元素的类型为 \(cls\)。
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。
make_args(expr)	返回一组参数，使得 cls(*arg_set) == expr。
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)
sort_key([order])	返回一个排序键。
subs(*args, **kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
xreplace(**_)

binary_check_and_simplify
复制
could_extract_minus_sign
is_hypergeometric
to_anf
to_nnf

注释

| 运算符作为便利工具提供，但请注意，它在这里的使用与在 Python 中的常规用法不同，后者是按位或。因此，如果 a 和 b 是整数，Or(a, b) 和 a | b 将返回不同的结果。

>>> Or(x, y).subs(x, 0)
y

示例

>>> from sympy.abc import x, y
>>> from sympy import Or
>>> x | y
x | y

class sympy.logic.boolalg.Not(arg)

逻辑非函数（否定）

如果语句为 false 或 False，则返回 true。如果语句为 true 或 True，则返回 false。

属性:

args

返回 ‘self’ 的参数元组。

assumptions0

返回对象 \(type\) 假设。

二进制符号

canonical_variables

返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。

expr_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

方法

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 的包装器。
diff(*symbols, **assumptions)
doit(**hints)	评估默认情况下不评估的对象，如极限、积分、求和和乘积。
dummy_eq(other[, symbol])	比较两个表达式并处理哑符号。
equals(other)	如果给定的公式具有相同的真值表，则返回 True。
eval(arg)
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)
sort_key([order])	返回一个排序键。
subs(*args, **kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
xreplace(**_)

binary_check_and_simplify
复制
could_extract_minus_sign
is_hypergeometric
to_anf
to_nnf

注释

• ~ 运算符作为便利工具提供，但请注意，它在这里的使用与在 Python 中的正常使用不同，后者是按位取反。特别是，如果 a 是整数，~a 和 Not(a) 将不同。此外，由于布尔值在 Python 中是 int 的子类，~True 等同于 ~1，即 -2，其布尔值为 True。为了避免这个问题，请使用 SymPy 布尔类型 true 和 false。

• 从 Python 3.12 开始，对 Python bool 使用按位非运算符 ~ 已被弃用，并将发出警告。

>>> from sympy import true
>>> ~True  
-2
>>> ~true
False

示例

>>> from sympy import Not, And, Or
>>> from sympy.abc import x, A, B
>>> Not(True)
False
>>> Not(False)
True
>>> Not(And(True, False))
True
>>> Not(Or(True, False))
False
>>> Not(And(And(True, x), Or(x, False)))
~x
>>> ~x
~x
>>> Not(And(Or(A, B), Or(~A, ~B)))
~((A | B) & (~A | ~B))

class sympy.logic.boolalg.Xor(*args)

逻辑异或（exclusive OR）函数。

如果参数中奇数个为 True，其余为 False，则返回 True。

如果参数中偶数个为 True，其余为 False，则返回 False。

属性:

args

返回 ‘self’ 的参数元组。

assumptions0

返回对象 \(type\) 假设。

二进制符号

canonical_variables

返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。

expr_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

方法

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 的包装器。
diff(*symbols, **assumptions)
doit(**hints)	评估默认情况下不评估的对象，如极限、积分、求和和乘积。
dummy_eq(other[, symbol])	比较两个表达式并处理哑符号。
equals(other)	如果给定的公式具有相同的真值表，则返回 True。
eval(*args)	返回应用于参数 args 的 cls 的规范形式。
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)
sort_key([order])	返回一个排序键。
subs(*args, **kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
xreplace(**_)

binary_check_and_simplify
复制
could_extract_minus_sign
is_hypergeometric
to_anf
to_nnf

注释

^ 运算符作为便利提供，但请注意，它在这里的使用与在Python中的正常使用不同，后者是按位异或。特别是，如果 a 和 b 是整数，a ^ b 和 Xor(a, b) 将不同。

>>> Xor(x, y).subs(y, 0)
x

示例

>>> from sympy.logic.boolalg import Xor
>>> from sympy import symbols
>>> x, y = symbols('x y')
>>> Xor(True, False)
True
>>> Xor(True, True)
False
>>> Xor(True, False, True, True, False)
True
>>> Xor(True, False, True, False)
False
>>> x ^ y
x ^ y

class sympy.logic.boolalg.Nand(*args)

逻辑与非功能。

它按顺序评估其参数，如果其中任何一个为 False，则立即返回 True，如果它们都为 True，则返回 False。

如果任何一个参数为 False 则返回 True，如果所有参数都为 True 则返回 False

属性:

args

返回 ‘self’ 的参数元组。

assumptions0

返回对象 \(type\) 假设。

二进制符号

canonical_variables

返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。

expr_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

方法

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 的包装器。
diff(*symbols, **assumptions)
doit(**hints)	评估默认情况下不评估的对象，如极限、积分、求和和乘积。
dummy_eq(other[, symbol])	比较两个表达式并处理哑符号。
equals(other)	如果给定的公式具有相同的真值表，则返回 True。
eval(*args)
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)
sort_key([order])	返回一个排序键。
subs(*args, **kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
xreplace(**_)

binary_check_and_simplify
复制
could_extract_minus_sign
is_hypergeometric
to_anf
to_nnf

示例

>>> from sympy.logic.boolalg import Nand
>>> from sympy import symbols
>>> x, y = symbols('x y')
>>> Nand(False, True)
True
>>> Nand(True, True)
False
>>> Nand(x, y)
~(x & y)

class sympy.logic.boolalg.Nor(*args)

逻辑 NOR 函数。

它会按顺序评估其参数，如果其中任何一个为 True，则立即返回 False，如果所有参数都为 False，则返回 True。

如果任何参数为 True 则返回 False 如果所有参数为 False 则返回 True

属性:

args

返回 ‘self’ 的参数元组。

assumptions0

返回对象 \(type\) 假设。

二进制符号

canonical_variables

返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。

expr_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

方法

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 的包装器。
diff(*symbols, **assumptions)
doit(**hints)	评估默认情况下不评估的对象，如极限、积分、求和和乘积。
dummy_eq(other[, symbol])	比较两个表达式并处理哑符号。
equals(other)	如果给定的公式具有相同的真值表，则返回 True。
eval(*args)
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)
sort_key([order])	返回一个排序键。
subs(*args, **kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
xreplace(**_)

binary_check_and_simplify
复制
could_extract_minus_sign
is_hypergeometric
to_anf
to_nnf

示例

>>> from sympy.logic.boolalg import Nor
>>> from sympy import symbols
>>> x, y = symbols('x y')

>>> Nor(True, False)
False
>>> Nor(True, True)
False
>>> Nor(False, True)
False
>>> Nor(False, False)
True
>>> Nor(x, y)
~(x | y)

class sympy.logic.boolalg.Xnor(*args)

逻辑 XNOR 函数。

如果参数中奇数个为True，其余为False，则返回False。

如果参数中有偶数个为 True，其余为 False，则返回 True。

属性:

args

返回 ‘self’ 的参数元组。

assumptions0

返回对象 \(type\) 假设。

二进制符号

canonical_variables

返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。

expr_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

方法

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 的包装器。
diff(*symbols, **assumptions)
doit(**hints)	评估默认情况下不评估的对象，如极限、积分、求和和乘积。
dummy_eq(other[, symbol])	比较两个表达式并处理哑符号。
equals(other)	如果给定的公式具有相同的真值表，则返回 True。
eval(*args)
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)
sort_key([order])	返回一个排序键。
subs(*args, **kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
xreplace(**_)

binary_check_and_simplify
复制
could_extract_minus_sign
is_hypergeometric
to_anf
to_nnf

示例

>>> from sympy.logic.boolalg import Xnor
>>> from sympy import symbols
>>> x, y = symbols('x y')
>>> Xnor(True, False)
False
>>> Xnor(True, True)
True
>>> Xnor(True, False, True, True, False)
False
>>> Xnor(True, False, True, False)
True

class sympy.logic.boolalg.Implies(*args)

逻辑蕴含。

A 蕴含 B 等价于 如果 A 则 B。数学上，它写作 \(A \Rightarrow B\)，等价于 \(\neg A \vee B\) 或 ~A | B。

接受两个布尔参数；A 和 B。如果 A 为 True 且 B 为 False，则返回 False。否则返回 True。

属性:

args

返回 ‘self’ 的参数元组。

assumptions0

返回对象 \(type\) 假设。

二进制符号

canonical_variables

返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。

expr_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

方法

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 的包装器。
diff(*symbols, **assumptions)
doit(**hints)	评估默认情况下不评估的对象，如极限、积分、求和和乘积。
dummy_eq(other[, symbol])	比较两个表达式并处理哑符号。
equals(other)	如果给定的公式具有相同的真值表，则返回 True。
eval(*args)
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)
sort_key([order])	返回一个排序键。
subs(*args, **kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
xreplace(**_)

binary_check_and_simplify
复制
could_extract_minus_sign
is_hypergeometric
to_anf
to_nnf

注释

>> 和 << 运算符作为便利工具提供，但请注意，它们在这里的使用与在Python中的正常使用不同，后者用于位移。因此，如果 a 和 b 是整数，Implies(a, b) 和 a >> b 将返回不同的结果。特别是，由于Python将 True 和 False 视为整数，True >> True 将与 1 >> 1 相同，即0，其真值为False。为避免此问题，请使用SymPy对象 true 和 false。

>>> from sympy import true, false
>>> True >> False
1
>>> true >> false
False

示例

>>> from sympy.logic.boolalg import Implies
>>> from sympy import symbols
>>> x, y = symbols('x y')

>>> Implies(True, False)
False
>>> Implies(False, False)
True
>>> Implies(True, True)
True
>>> Implies(False, True)
True
>>> x >> y
Implies(x, y)
>>> y << x
Implies(x, y)

class sympy.logic.boolalg.Equivalent(*args)

等价关系。

Equivalent(A, B) 在 A 和 B 都为 True 或都为 False 时为 True。

如果所有参数在逻辑上等价，则返回 True。否则返回 False。

对于两个参数，这等价于 Xnor。

属性:

args

返回 ‘self’ 的参数元组。

assumptions0

返回对象 \(type\) 假设。

二进制符号

canonical_variables

返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。

expr_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

方法

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 的包装器。
diff(*symbols, **assumptions)
doit(**hints)	评估默认情况下不评估的对象，如极限、积分、求和和乘积。
dummy_eq(other[, symbol])	比较两个表达式并处理哑符号。
equals(other)	如果给定的公式具有相同的真值表，则返回 True。
eval(*args)	返回应用于参数 args 的 cls 的规范形式。
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)
sort_key([order])	返回一个排序键。
subs(*args, **kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
xreplace(**_)

binary_check_and_simplify
复制
could_extract_minus_sign
is_hypergeometric
to_anf
to_nnf

示例

>>> from sympy.logic.boolalg import Equivalent, And
>>> from sympy.abc import x
>>> Equivalent(False, False, False)
True
>>> Equivalent(True, False, False)
False
>>> Equivalent(x, And(x, True))
True

class sympy.logic.boolalg.ITE(*args)

如果-那么-否则 子句。

ITE(A, B, C) 在 A 为真时计算并返回 B 的结果，否则返回 C 的结果。所有参数必须是布尔值。

从逻辑门的角度来看，ITE 对应于一个 2 对 1 的多路复用器，其中 A 是选择信号。

属性:

args

返回 ‘self’ 的参数元组。

assumptions0

返回对象 \(type\) 假设。

二进制符号

canonical_variables

返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。

expr_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

方法

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 的包装器。
diff(*symbols, **assumptions)
doit(**hints)	评估默认情况下不评估的对象，如极限、积分、求和和乘积。
dummy_eq(other[, symbol])	比较两个表达式并处理哑符号。
equals(other)	如果给定的公式具有相同的真值表，则返回 True。
eval(*args)
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)
sort_key([order])	返回一个排序键。
subs(*args, **kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
xreplace(**_)

binary_check_and_simplify
复制
could_extract_minus_sign
is_hypergeometric
to_anf
to_nnf

示例

>>> from sympy.logic.boolalg import ITE, And, Xor, Or
>>> from sympy.abc import x, y, z
>>> ITE(True, False, True)
False
>>> ITE(Or(True, False), And(True, True), Xor(True, True))
True
>>> ITE(x, y, z)
ITE(x, y, z)
>>> ITE(True, x, y)
x
>>> ITE(False, x, y)
y
>>> ITE(x, y, y)
y

尝试使用非布尔类型的参数将生成一个 TypeError：

>>> ITE(True, [], ())
Traceback (most recent call last):
...
TypeError: expecting bool, Boolean or ITE, not `[]`

class sympy.logic.boolalg.Exclusive(*args)

如果只有一个或没有参数为真，则为真。

Exclusive(A, B, C) 等价于 ~(A & B) & ~(A & C) & ~(B & C)。

对于两个参数，这等价于 Xor。

属性:

args

返回 ‘self’ 的参数元组。

assumptions0

返回对象 \(type\) 假设。

二进制符号

canonical_variables

返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。

expr_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

方法

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 的包装器。
diff(*symbols, **assumptions)
doit(**hints)	评估默认情况下不评估的对象，如极限、积分、求和和乘积。
dummy_eq(other[, symbol])	比较两个表达式并处理哑符号。
equals(other)	如果给定的公式具有相同的真值表，则返回 True。
eval(*args)
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)
sort_key([order])	返回一个排序键。
subs(*args, **kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
xreplace(**_)

binary_check_and_simplify
复制
could_extract_minus_sign
is_hypergeometric
to_anf
to_nnf

示例

>>> from sympy.logic.boolalg import Exclusive
>>> Exclusive(False, False, False)
True
>>> Exclusive(False, True, False)
True
>>> Exclusive(False, True, True)
False

以下函数可用于处理代数、合取、析取和否定范式：

sympy.logic.boolalg.to_anf(expr, deep=True)

将表达式转换为代数正规形式（ANF）。

ANF 是一种规范范式，这意味着两个等价的公式将转换为相同的 ANF。

一个逻辑表达式在ANF中，如果它具有以下形式

\[1 \oplus a \oplus b \oplus ab \oplus abc\]

即它可以是：

• 纯粹真实，

• 完全错误，

• 变量的结合,

• 异或运算。

异或只能包含真值、变量或变量的合取。不允许使用否定。

如果 deep 是 False，布尔表达式的参数被视为变量，即只有顶层表达式被转换为 ANF。

示例

>>> from sympy.logic.boolalg import And, Or, Not, Implies, Equivalent
>>> from sympy.logic.boolalg import to_anf
>>> from sympy.abc import A, B, C
>>> to_anf(Not(A))
A ^ True
>>> to_anf(And(Or(A, B), Not(C)))
A ^ B ^ (A & B) ^ (A & C) ^ (B & C) ^ (A & B & C)
>>> to_anf(Implies(Not(A), Equivalent(B, C)), deep=False)
True ^ ~A ^ (~A & (Equivalent(B, C)))

sympy.logic.boolalg.to_cnf(expr, simplify=False, force=False)

将命题逻辑句子 expr 转换为合取范式：((A | ~B | ...) & (B | C | ...) & ...)。如果 simplify 为 True，则使用 Quine-McCluskey 算法将 expr 评估为其最简单的 CNF 形式；这可能需要很长时间。如果变量超过 8 个，则必须将 force 标志设置为 True 以进行简化（默认值为 False）。

示例

>>> from sympy.logic.boolalg import to_cnf
>>> from sympy.abc import A, B, D
>>> to_cnf(~(A | B) | D)
(D | ~A) & (D | ~B)
>>> to_cnf((A | B) & (A | ~A), True)
A | B

sympy.logic.boolalg.to_dnf(expr, simplify=False, force=False)

将命题逻辑句子 expr 转换为析取范式：((A & ~B & ...) | (B & C & ...) | ...)。如果 simplify 为 True，则使用 Quine-McCluskey 算法将 expr 评估为其最简单的 DNF 形式；这可能需要很长时间。如果变量超过 8 个，则必须将 force 标志设置为 True 以进行简化（默认值为 False）。

示例

>>> from sympy.logic.boolalg import to_dnf
>>> from sympy.abc import A, B, C
>>> to_dnf(B & (A | C))
(A & B) | (B & C)
>>> to_dnf((A & B) | (A & ~B) | (B & C) | (~B & C), True)
A | C

sympy.logic.boolalg.to_nnf(expr, simplify=True)

将 expr 转换为否定范式 (NNF)。

一个逻辑表达式在NNF中，如果它只包含 And、Or 和 Not，并且 Not 只应用于字面量。如果 simplify 是 True，结果不包含冗余子句。

示例

>>> from sympy.abc import A, B, C, D
>>> from sympy.logic.boolalg import Not, Equivalent, to_nnf
>>> to_nnf(Not((~A & ~B) | (C & D)))
(A | B) & (~C | ~D)
>>> to_nnf(Equivalent(A >> B, B >> A))
(A | ~B | (A & ~B)) & (B | ~A | (B & ~A))

sympy.logic.boolalg.is_anf(expr)

检查 expr 是否在代数正规形式（ANF）中。

一个逻辑表达式在ANF中，如果它具有以下形式

\[1 \oplus a \oplus b \oplus ab \oplus abc\]

即它是纯粹的真、纯粹的假、变量的合取或变量的异或。异或只能包含真、变量或变量的合取。不允许使用否定。

示例

>>> from sympy.logic.boolalg import And, Not, Xor, true, is_anf
>>> from sympy.abc import A, B, C
>>> is_anf(true)
True
>>> is_anf(A)
True
>>> is_anf(And(A, B, C))
True
>>> is_anf(Xor(A, Not(B)))
False

sympy.logic.boolalg.is_cnf(expr)

测试一个表达式是否为合取范式。

示例

>>> from sympy.logic.boolalg import is_cnf
>>> from sympy.abc import A, B, C
>>> is_cnf(A | B | C)
True
>>> is_cnf(A & B & C)
True
>>> is_cnf((A & B) | C)
False

sympy.logic.boolalg.is_dnf(expr)

测试一个表达式是否为析取范式。

示例

>>> from sympy.logic.boolalg import is_dnf
>>> from sympy.abc import A, B, C
>>> is_dnf(A | B | C)
True
>>> is_dnf(A & B & C)
True
>>> is_dnf((A & B) | C)
True
>>> is_dnf(A & (B | C))
False

sympy.logic.boolalg.is_nnf(expr, simplified=True)

检查 expr 是否为否定范式 (NNF)。

逻辑表达式在NNF中，如果它仅包含 And、Or 和 Not，并且 Not 仅应用于字面量。如果 simplified 为 True，则检查结果是否包含冗余子句。

示例

>>> from sympy.abc import A, B, C
>>> from sympy.logic.boolalg import Not, is_nnf
>>> is_nnf(A & B | ~C)
True
>>> is_nnf((A | ~A) & (B | C))
False
>>> is_nnf((A | ~A) & (B | C), False)
True
>>> is_nnf(Not(A & B) | C)
False
>>> is_nnf((A >> B) & (B >> A))
False

sympy.logic.boolalg.gateinputcount(expr)

返回实现布尔表达式的逻辑门的输入总数。

返回:

整数

门输入的数量

示例

>>> from sympy.logic import And, Or, Nand, Not, gateinputcount
>>> from sympy.abc import x, y, z
>>> expr = And(x, y)
>>> gateinputcount(expr)
2
>>> gateinputcount(Or(expr, z))
4

注意 Nand 会自动评估为 Not(And()) 所以

>>> gateinputcount(Nand(x, y, z))
4
>>> gateinputcount(Not(And(x, y, z)))
4

尽管可以通过使用 evaluate=False 来避免这种情况

>>> gateinputcount(Nand(x, y, z, evaluate=False))
3

还要注意，比较将被视为布尔变量：

>>> gateinputcount(And(x > z, y >= 2))
2

像一个符号一样： >>> gateinputcount(x) 0

简化与等价测试

sympy.logic.boolalg.simplify_logic(

expr,

form=None,

deep=True,

force=False,

dontcare=None,

)

此函数将布尔函数简化为SOP或POS形式的最简版本。返回类型是SymPy中的 Or 或 And 对象。

参数:

表达式布尔值

形式 : 字符串 ('cnf' 或 'dnf') 或 None (默认)。字符串 (

如果 'cnf' 或 'dnf'，则返回相应范式中最简单的表达式；如果 None，则根据参数最少的格式返回答案（默认情况下为CNF）。

deep : bool (默认 True)bool (默认)

指示是否递归简化输入中包含的任何非布尔函数。

force : bool (默认 False)bool (默认)

由于简化操作在变量数量上需要指数级的时间，因此默认情况下对包含8个变量的表达式设有限制。当表达式包含超过8个变量时，仅进行符号简化（由``deep``控制）。通过将``force``设置为``True``，可以移除此限制。请注意，这可能会导致非常长的简化时间。

dontcare布尔值

在假设此表达式为真的输入是无关的情况下优化表达式。这在例如分段条件中很有用，后续条件不需要考虑被先前条件转换的输入。例如，如果先前条件是 And(A, B)，则可以在 And(A, B) 的无关条件下简化 expr。

参考文献

[1]

https://en.wikipedia.org/wiki/无关项

示例

>>> from sympy.logic import simplify_logic
>>> from sympy.abc import x, y, z
>>> b = (~x & ~y & ~z) | ( ~x & ~y & z)
>>> simplify_logic(b)
~x & ~y
>>> simplify_logic(x | y, dontcare=y)
x

SymPy 的 simplify() 函数也可以用于将逻辑表达式简化为最简形式。

sympy.logic.boolalg.bool_map(bool1, bool2)

返回 bool1 的简化版本，以及使得两个表达式 bool1 和 bool2 对于每个变量之间的一些对应关系表示相同的逻辑行为的变量映射。如果存在多个这样的映射，则返回其中一个。

例如，对于映射 {x: a, y: b} 或 {x: b, y: a}，And(x, y) 在逻辑上等价于 And(a, b)。如果不存在这样的映射，则返回 False。

示例

>>> from sympy import SOPform, bool_map, Or, And, Not, Xor
>>> from sympy.abc import w, x, y, z, a, b, c, d
>>> function1 = SOPform([x, z, y],[[1, 0, 1], [0, 0, 1]])
>>> function2 = SOPform([a, b, c],[[1, 0, 1], [1, 0, 0]])
>>> bool_map(function1, function2)
(y & ~z, {y: a, z: b})

结果不一定是唯一的，但它们是规范的。在这里，(w, z) 可以是 (a, d) 或 (d, a)：

>>> eq =  Or(And(Not(y), w), And(Not(y), z), And(x, y))
>>> eq2 = Or(And(Not(c), a), And(Not(c), d), And(b, c))
>>> bool_map(eq, eq2)
((x & y) | (w & ~y) | (z & ~y), {w: a, x: b, y: c, z: d})
>>> eq = And(Xor(a, b), c, And(c,d))
>>> bool_map(eq, eq.subs(c, x))
(c & d & (a | b) & (~a | ~b), {a: a, b: b, c: d, d: x})

操作表达式

以下函数可用于操作布尔表达式：

sympy.logic.boolalg.distribute_and_over_or(expr)

给定一个由文字的合取和析取组成的句子 expr，返回一个等价的CNF句子。

示例

>>> from sympy.logic.boolalg import distribute_and_over_or, And, Or, Not
>>> from sympy.abc import A, B, C
>>> distribute_and_over_or(Or(A, And(Not(B), Not(C))))
(A | ~B) & (A | ~C)

sympy.logic.boolalg.distribute_or_over_and(expr)

给定一个由文字的合取和析取组成的句子 expr，返回一个等价的 DNF 句子。

请注意，输出并未简化。

示例

>>> from sympy.logic.boolalg import distribute_or_over_and, And, Or, Not
>>> from sympy.abc import A, B, C
>>> distribute_or_over_and(And(Or(Not(A), B), C))
(B & C) | (C & ~A)

sympy.logic.boolalg.distribute_xor_over_and(expr)

给定一个包含文字的合取和异或析取的句子 expr ，返回一个等价的异或析取。

请注意，输出并未简化。

示例

>>> from sympy.logic.boolalg import distribute_xor_over_and, And, Xor, Not
>>> from sympy.abc import A, B, C
>>> distribute_xor_over_and(And(Xor(Not(A), B), C))
(B & C) ^ (C & ~A)

sympy.logic.boolalg.eliminate_implications(expr)

将 Implies 和 Equivalent 转换为 And、Or 和 Not。也就是说，返回一个等价于 expr 的表达式，但只包含 &、| 和 ~ 作为逻辑运算符。

示例

>>> from sympy.logic.boolalg import Implies, Equivalent,          eliminate_implications
>>> from sympy.abc import A, B, C
>>> eliminate_implications(Implies(A, B))
B | ~A
>>> eliminate_implications(Equivalent(A, B))
(A | ~B) & (B | ~A)
>>> eliminate_implications(Equivalent(A, B, C))
(A | ~C) & (B | ~A) & (C | ~B)

真值表及相关函数

可以为布尔函数创建一个真值表。

sympy.logic.boolalg.truth_table(expr, variables, input=True)

返回输入变量的所有可能配置的生成器，以及这些值的布尔表达式的结果。

参数:

表达式布尔表达式

变量变量列表

输入 : bool (默认 True)bool (默认)

指示是否返回输入组合。

示例

>>> from sympy.logic.boolalg import truth_table
>>> from sympy.abc import x,y
>>> table = truth_table(x >> y, [x, y])
>>> for t in table:
...     print('{0} -> {1}'.format(*t))
[0, 0] -> True
[0, 1] -> True
[1, 0] -> False
[1, 1] -> True

>>> table = truth_table(x | y, [x, y])
>>> list(table)
[([0, 0], False), ([0, 1], True), ([1, 0], True), ([1, 1], True)]

如果 input 是 False，truth_table 只返回一个真值列表。在这种情况下，变量的对应输入值可以从给定输出的索引推断出来。

>>> from sympy.utilities.iterables import ibin
>>> vars = [y, x]
>>> values = truth_table(x >> y, vars, input=False)
>>> values = list(values)
>>> values
[True, False, True, True]

>>> for i, value in enumerate(values):
...     print('{0} -> {1}'.format(list(zip(
...     vars, ibin(i, len(vars)))), value))
[(y, 0), (x, 0)] -> True
[(y, 0), (x, 1)] -> False
[(y, 1), (x, 0)] -> True
[(y, 1), (x, 1)] -> True

对于真值表位置的整数表示、零和一的列表以及符号之间的映射，可以使用以下函数：

sympy.logic.boolalg.integer_to_term(n, bits=None, str=False)

返回一个长度为 bits 的列表，对应于 n 的二进制值，其中较小的位在右边（最后）。如果省略了 bits，长度将是表示 n 所需的数量。如果希望位以相反的顺序排列，请使用返回列表的 [::-1] 切片。

如果需要从 [0, 0,..., 0] 到 [1, 1, ..., 1] 的所有比特长度列表的序列，请为 bits 传递一个非整数，例如 'all'。

如果需要位 字符串，请传递 str=True。

示例

>>> from sympy.utilities.iterables import ibin
>>> ibin(2)
[1, 0]
>>> ibin(2, 4)
[0, 0, 1, 0]

如果所有对应于 0 到 2**n - 1 的列表，传递一个非整数的位数：

>>> bits = 2
>>> for i in ibin(2, 'all'):
...     print(i)
(0, 0)
(0, 1)
(1, 0)
(1, 1)

如果需要一个给定长度的比特字符串，请使用 str=True:

>>> n = 123
>>> bits = 10
>>> ibin(n, bits, str=True)
'0001111011'
>>> ibin(n, bits, str=True)[::-1]  # small bits left
'1101111000'
>>> list(ibin(3, 'all', str=True))
['000', '001', '010', '011', '100', '101', '110', '111']

sympy.logic.boolalg.term_to_integer(term)

返回一个整数，该整数对应于由 term 给出的以2为底的数字。

参数:

术语一个字符串或由0和1组成的列表

示例

>>> from sympy.logic.boolalg import term_to_integer
>>> term_to_integer([1, 0, 0])
4
>>> term_to_integer('100')
4

sympy.logic.boolalg.bool_maxterm(k, variables)

返回第 k 个极大项。

每个最大项根据与最小项使用的相反的传统二进制编码分配一个索引。最大项约定将值0分配给直接形式，将1分配给补形式。

参数:

kint 或 1 和 0 的列表（补全模式）

变量变量列表

参考文献

[1]

https://en.wikipedia.org/wiki/Canonical_normal_form#Indexing_maxterms

示例

>>> from sympy.logic.boolalg import bool_maxterm
>>> from sympy.abc import x, y, z
>>> bool_maxterm([1, 0, 1], [x, y, z])
y | ~x | ~z
>>> bool_maxterm(6, [x, y, z])
z | ~x | ~y

sympy.logic.boolalg.bool_minterm(k, variables)

返回第 k 个最小项。

最小项通过变量补码模式的二进制编码进行编号。这种约定将直接形式的值赋为1，将补码形式的值赋为0。

参数:

kint 或 1 和 0 的列表（补全模式）

变量变量列表

参考文献

[1]

https://en.wikipedia.org/wiki/Canonical_normal_form#Indexing_minterms

示例

>>> from sympy.logic.boolalg import bool_minterm
>>> from sympy.abc import x, y, z
>>> bool_minterm([1, 0, 1], [x, y, z])
x & z & ~y
>>> bool_minterm(6, [x, y, z])
x & y & ~z

sympy.logic.boolalg.bool_monomial(k, variables)

返回第 k 个单项式。

单项式通过二进制编码来编号，表示变量的存在和缺失。这种约定将变量的存在赋值为1，将变量的缺失赋值为0。

每个布尔函数都可以由一个Zhegalkin多项式（代数标准形式）唯一表示。具有`n`个变量的布尔函数的Zhegalkin多项式最多可以包含`2^n`个单项式。我们可以枚举所有单项式。每个单项式完全由每个变量的存在或不存在来指定。

例如，包含四个变量 (a, b, c, d) 的布尔函数最多可以包含 \(2^4 = 16\) 个单项式。第13个单项式是乘积 a & b & d，因为在二进制中13是1, 1, 0, 1。

参数:

kint 或 1 和 0 的列表

变量变量列表

示例

>>> from sympy.logic.boolalg import bool_monomial
>>> from sympy.abc import x, y, z
>>> bool_monomial([1, 0, 1], [x, y, z])
x & z
>>> bool_monomial(6, [x, y, z])
x & y

sympy.logic.boolalg.anf_coeffs(truthvalues)

将布尔表达式的真值列表转换为多项式模2（异或）的系数列表，该多项式表示布尔表达式的ANF（即“Zhegalkin多项式”）。

在 \(n\) 个变量中，有 \(2^n\) 个可能的 Zhegalkin 单项式，因为每个单项式完全由每个变量的存在或不存在来指定。

我们可以枚举所有的单项式。例如，具有四个变量 (a, b, c, d) 的布尔函数可以包含多达 \(2^4 = 16\) 个单项式。第13个单项式是乘积 a & b & d，因为13的二进制表示是1, 1, 0, 1。

给定单项式在多项式中的存在与否对应于该单项式的系数分别为1或0。

示例

>>> from sympy.logic.boolalg import anf_coeffs, bool_monomial, Xor
>>> from sympy.abc import a, b, c
>>> truthvalues = [0, 1, 1, 0, 0, 1, 0, 1]
>>> coeffs = anf_coeffs(truthvalues)
>>> coeffs
[0, 1, 1, 0, 0, 0, 1, 0]
>>> polynomial = Xor(*[
...     bool_monomial(k, [a, b, c])
...     for k, coeff in enumerate(coeffs) if coeff == 1
... ])
>>> polynomial
b ^ c ^ (a & b)

sympy.logic.boolalg.to_int_repr(clauses, symbols)

将CNF格式的子句转换为整数表示形式。

示例

>>> from sympy.logic.boolalg import to_int_repr
>>> from sympy.abc import x, y
>>> to_int_repr([x | y, y], [x, y]) == [{1, 2}, {2}]
True

推理

此模块实现了命题逻辑中的一些推理程序。

函数 satisfiable 将测试给定的布尔表达式是否可满足，也就是说，你可以为变量赋值以使句子 True。

例如，表达式 x & ~x 是不可满足的，因为没有 x 的值能使这个句子为 True。另一方面，(x | y) & (x | ~y) & (~x | y) 在 x 和 y 都为 True 时是可满足的。

>>> from sympy.logic.inference import satisfiable
>>> from sympy import Symbol
>>> x = Symbol('x')
>>> y = Symbol('y')
>>> satisfiable(x & ~x)
False
>>> satisfiable((x | y) & (x | ~y) & (~x | y))
{x: True, y: True}

如你所见，当一个句子是可满足的时，它会返回一个使该句子为 True 的模型。如果它是不可满足的，它将返回 False。

sympy.logic.inference.satisfiable(

expr,

algorithm=None,

all_models=False,

minimal=False,

use_lra_theory=False,

)

检查命题句子的可满足性。成功时返回一个模型。对于明显为真的表达式，返回 {true: true}。

在将 all_models 设置为 True 的情况下，如果给定的表达式是可满足的，则返回模型的生成器。然而，如果表达式是不可满足的，则返回包含单个元素 False 的生成器。

示例

>>> from sympy.abc import A, B
>>> from sympy.logic.inference import satisfiable
>>> satisfiable(A & ~B)
{A: True, B: False}
>>> satisfiable(A & ~A)
False
>>> satisfiable(True)
{True: True}
>>> next(satisfiable(A & ~A, all_models=True))
False
>>> models = satisfiable((A >> B) & B, all_models=True)
>>> next(models)
{A: False, B: True}
>>> next(models)
{A: True, B: True}
>>> def use_models(models):
...     for model in models:
...         if model:
...             # Do something with the model.
...             print(model)
...         else:
...             # Given expr is unsatisfiable.
...             print("UNSAT")
>>> use_models(satisfiable(A >> ~A, all_models=True))
{A: False}
>>> use_models(satisfiable(A ^ A, all_models=True))
UNSAT