SymPy 1.13 中文文档（二十三）

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

逻辑

原文：docs.sympy.org/latest/reference/public/logic/index.html

目录

• 逻辑

• 集合

逻辑

原文链接：docs.sympy.org/latest/modules/logic.html

介绍

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 的逻辑模块还包括以下功能，可从其真值表中推导布尔表达式：

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

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

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

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

结果将是满足条件的函数之一（也许有多个）。

示例

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

参见

POSform

参考文献

[R600]

zh.wikipedia.org/wiki/奎因-麦克拉斯基算法

[R601]

zh.wikipedia.org/wiki/无关紧要的术语

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

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

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

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

结果将是满足条件的函数之一（也许有多个）。

示例

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

参见

SOPform

参考文献

[R602]

zh.wikipedia.org/wiki/奎因-麦克拉斯基算法

[R603]

zh.wikipedia.org/wiki/无关紧要的术语

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

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

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

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

严格来说，“Zhegalkin 单项式”是一组不同变量（包括空集）的乘积（逻辑 And），其乘积表示为 1（True）。“Zhegalkin 多项式”是 Zhegalkin 单项式集合的和（逻辑 Xor），其中空集表示为 0（False）。

参数：

变量：变量列表

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

示例

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

参考文献

[R604]

zh.wikipedia.org/wiki/Zhegalkin_polynomial

布尔函数

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

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

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。在逻辑模块中，当函数求值为 true 时，它们将返回这个类。

注意

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

另请参阅

sympy.logic.boolalg.BooleanFalse

as_set()

重写逻辑运算符和关系运算符以真实集合的术语表示。

举例

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

class sympy.logic.boolalg.BooleanFalse

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

这是 SymPy 版本的False，用于逻辑模块中。使用false而不是False的主要优势在于，像~和>>这样的简便布尔运算符会按预期在这个类上起作用，而对于False，它们会按位操作 0。在逻辑模块中，当它们评估为 false 时，函数将返回此类。

注释

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

另请参阅

sympy.logic.boolalg.BooleanTrue

as_set()

重写逻辑运算符和关系运算符以真实集合的术语表示。

举例

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

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

逻辑与功能。

当一个参数为 false 时，按顺序评估其参数，如果它们都为 true，则立即返回 false。

举例

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

注释

逻辑与操作符&作为便利性提供，但请注意其在这里的使用与 Python 中的正常用法不同，即它是位与。因此，And(a, b)和a & b将在a和b为整数时产生不同的结果。

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

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

逻辑或函数

按顺序评估其参数，如果一个参数为真，则立即返回 true，如果它们都为 false，则返回 false。

举例

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

注释

| 操作符是为了方便起见提供的，但请注意，它在这里的使用与 Python 中的正常用法不同，Python 中它表示按位或。因此，如果 a 和 b 是整数，Or(a, b) 和 a | b 将返回不同的结果。

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

class sympy.logic.boolalg.Not(arg)

逻辑 Not 函数（否定）

如果语句为 false 或 False，则返回 true；如果语句为 true 或 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)) 

注意

• ~ 操作符是为了方便起见提供的，但请注意，它在这里的使用与 Python 中的正常用法不同，Python 中它表示按位取反。特别地，~a 和 Not(a) 如果 a 是整数将不同。此外，由于 Python 中的布尔值是从 int 继承而来，~True 将与 ~1 相同，即 -2，其布尔值为 True。为避免此问题，请使用 SymPy 的布尔类型 true 和 false。

• 在 Python 3.12 中，对 Python 的布尔类型使用位取反操作符 ~ 已经不推荐使用，并将会发出警告。

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

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

逻辑 XOR（异或）函数。

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

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

示例

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

注意

^ 操作符是为了方便起见提供的，但请注意，它在这里的使用与 Python 中的正常用法不同，Python 中它表示按位异或。特别地，a ^ b 和 Xor(a, b) 如果 a 和 b 是整数将不同。

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

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

逻辑 NAND 函数。

它按顺序评估其参数，如果任何参数为 False，则立即返回 True；如果它们全部为 True，则返回 False。

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

示例

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

示例

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

示例

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

示例

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

注意

>> 和 << 操作符是为了方便起见提供的，但请注意，它们在这里的使用与 Python 中的正常用法不同，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 

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

等价关系。

Equivalent(A, B) 当且仅当 A 和 B 都为 True 或都为 False 时为 True。

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

对于两个参数，这相当于Xnor。

例子

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

If-then-else 子句。

ITE(A, B, C) 评估并返回 B 的结果，如果 A 为真则返回 C 的结果。所有参数必须是布尔值。

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

例子

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

例子

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

将expr转换为代数标准形式（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)

测试表达式是否为析取范式（DNF）。

示例

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

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

返回：

整数

门输入数

注意

此处只有标准门才算作布尔函数，包括：And、Or、Xor、Not和ITE（多路复用器）。Nand、Nor和Xnor将被计算为Not(And())等。

示例

>>> 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对象。

参数：

expr：布尔值

form：字符串（'cnf'或'dnf'）或None（默认）。

如果是'cnf'或'dnf'，则返回相应正规形式中的最简表达式；如果是None，则根据参数最少的形式返回答案（默认为 CNF）。

deep：布尔值（默认True）

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

force：布尔值（默认False）

由于简化在变量数量的指数时间内，对具有 8 个以上变量的表达式默认有一个限制。当表达式超过 8 个变量时，只进行符号化简化（由deep控制）。通过将force设置为True，可以移除此限制。请注意，这可能导致非常长的简化时间。

dontcare：布尔值

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

示例

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

参考文献

[R605]

不重要术语

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)

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

参数：

expr：布尔表达式

variables：变量列表

input：布尔值（默认为True）

指示是否返回输入组合。

示例

>>> 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]的所有位长度列表的序列，则传递非整数作为位数，例如 '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)

返回与项给定的基于二进制的 2 进制数相对应的整数。

参数：

项：字符串或 1 和 0 列表

示例

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

参数：

k：整数或 1 和 0 列表（补码模式）

变量：变量列表

示例

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

参考文献

[R606]

zh.wikipedia.org/wiki/正规范式#最大项的索引

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

返回第 k 个最小项。

最小项按变量的补码模式的二进制编码编号。此约定将直接形式分配值 1，补码形式分配值 0。

参数：

k：整数或 1 和 0 列表（补码模式）

变量：变量列表

示例

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

参考文献

[R607]

zh.wikipedia.org/wiki/正规范式#最小项的索引

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

返回第 k 个单项式。

单项式按变量的存在和不存在的二进制编码编号。此约定将变量的存在分配值 1，变量的不存在分配值 0。

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

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

参数：

k：整数或 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)

将某个布尔表达式的真值列表转换为在 ANF 中表示该布尔表达式的多项式模 2 的系数列表（排他或）（即“Zhegalkin 多项式”）。

在(n)个变量中，Zhegalkin 单项式有(2^n)个可能，因为每个单项式通过每个变量的有无来完全指定。

我们可以枚举所有的单项式。例如，具有四个变量(a, b, c, d)的布尔函数可以包含最多(2⁴ = 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是不可满足的，因为没有任何值可以使得这个句子为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 

集合

原文：docs.sympy.org/latest/modules/sets.html

基本集合

class sympy.sets.sets.Set(*args)

任何种类集合的基类。

Explanation

这不应直接用作项目的容器。它不像内置的set那样运行；请查看FiniteSet。

实数区间由Interval类表示，集合的并集由Union类表示。空集由EmptySet类表示，并作为单例S.EmptySet可用。

property boundary

集合的边界或前沿。

Explanation

如果一个点 x 在集合 S 的边界上，则 x 在 S 的边界上。

1. x 在 S 的闭包中。即，x 的每个邻域都包含 S 中的一个点。

2. x 不在集合 S 的内部。即，不存在一个以 x 为中心的开集，完全包含在 S 中。

这些是 S 的外部边缘上的点。如果 S 是开放的，则这些点实际上不需要包含在 S 内。

例如，一个区间的边界是其起始点和结束点。这一点不受区间是否开放的影响。

Examples

>>> from sympy import Interval
>>> Interval(0, 1).boundary
{0, 1}
>>> Interval(0, 1, True, False).boundary
{0, 1} 

property closure

返回集合的闭包的属性方法。闭包定义为集合本身与其边界的并集。

Examples

>>> from sympy import S, Interval
>>> S.Reals.closure
Reals
>>> Interval(0, 1).closure
Interval(0, 1) 

complement(universe)

相对于给定的宇宙，‘self’的补集。

Examples

>>> from sympy import Interval, S
>>> Interval(0, 1).complement(S.Reals)
Union(Interval.open(-oo, 0), Interval.open(1, oo)) 

>>> Interval(0, 1).complement(S.UniversalSet)
Complement(UniversalSet, Interval(0, 1)) 

contains(other)

返回一个 SymPy 值，指示other是否包含在self中：如果是，则返回true，否则返回false；若条件不满足（例如在 ConditionSet 和 FiniteSet/Intervals 的并集中），则返回一个未求值的Contains表达式。

Examples

>>> from sympy import Interval, S
>>> from sympy.abc import x 

>>> Interval(0, 1).contains(0.5)
True 

作为一种快捷方式，可以使用in操作符，但是除非明确获得肯定的 true 或 false，否则会引发错误。

>>> Interval(0, 1).contains(x)
(0 <= x) & (x <= 1)
>>> x in Interval(0, 1)
Traceback (most recent call last):
...
TypeError: did not evaluate to a bool: None 

‘in’的结果是一个布尔值，而不是 SymPy 值

>>> 1 in Interval(0, 2)
True
>>> _ is S.true
False 

property inf

self的下确界。

Examples

>>> from sympy import Interval, Union
>>> Interval(0, 1).inf
0
>>> Union(Interval(0, 1), Interval(2, 3)).inf
0 

property interior

返回集合的内部的属性方法。集合 S 的内部包含所有不属于 S 的边界的点。

Examples

>>> from sympy import Interval
>>> Interval(0, 1).interior
Interval.open(0, 1)
>>> Interval(0, 1).boundary.interior
EmptySet 

intersect(other)

返回‘self’和‘other’的交集。

Examples

>>> from sympy import Interval 

>>> Interval(1, 3).intersect(Interval(1, 2))
Interval(1, 2) 

>>> from sympy import imageset, Lambda, symbols, S
>>> n, m = symbols('n m')
>>> a = imageset(Lambda(n, 2*n), S.Integers)
>>> a.intersect(imageset(Lambda(m, 2*m + 1), S.Integers))
EmptySet 

intersection(other)

intersect()的别名。

property is_closed

一个用于检查集合是否闭合的属性方法。

Explanation

如果其补集是一个开集，那么一个集合是封闭的。对于实数的子集来说，其封闭性是相对于 R 及其标准拓扑结构来确定的。

Examples

>>> from sympy import Interval
>>> Interval(0, 1).is_closed
True 

is_disjoint(other)

如果self和other是不交集，则返回 True。

Examples

>>> from sympy import Interval
>>> Interval(0, 2).is_disjoint(Interval(1, 2))
False
>>> Interval(0, 2).is_disjoint(Interval(3, 4))
True 

References

[R837]

zh.wikipedia.org/wiki/不交集

property is_open

检查一个集合是否开放的属性方法。

Explanation

一个集合是开放的当且仅当它与其边界的交集为空。特别地，实数的子集 A 是开放的当且仅当 A 中的每个点都包含在一个 A 的开区间中。

Examples

>>> from sympy import S
>>> S.Reals.is_open
True
>>> S.Rationals.is_open
False 

is_proper_subset(other)

如果self是other的真子集，则返回 True。

示例

>>> from sympy import Interval
>>> Interval(0, 0.5).is_proper_subset(Interval(0, 1))
True
>>> Interval(0, 1).is_proper_subset(Interval(0, 1))
False 

is_proper_superset(other)

如果self是other的真超集，则返回 True。

示例

>>> from sympy import Interval
>>> Interval(0, 1).is_proper_superset(Interval(0, 0.5))
True
>>> Interval(0, 1).is_proper_superset(Interval(0, 1))
False 

is_subset(other)

如果self是other的子集，则返回 True。

示例

>>> from sympy import Interval
>>> Interval(0, 0.5).is_subset(Interval(0, 1))
True
>>> Interval(0, 1).is_subset(Interval(0, 1, left_open=True))
False 

is_superset(other)

如果self是other的超集，则返回 True。

示例

>>> from sympy import Interval
>>> Interval(0, 0.5).is_superset(Interval(0, 1))
False
>>> Interval(0, 1).is_superset(Interval(0, 1, left_open=True))
True 

isdisjoint(other)

is_disjoint()的别名

issubset(other)

is_subset()的别名

issuperset(other)

is_superset()的别名

property kind

集合的种类

解释

任何Set都将具有种类SetKind，其由集合元素的种类参数化。例如，大多数集合是数字集合，并且其种类为SetKind(NumberKind)。如果集合元素在种类上不同，则其种类为SetKind(UndefinedKind)。参见sympy.core.kind.Kind以了解种类系统的解释。

示例

>>> from sympy import Interval, Matrix, FiniteSet, EmptySet, ProductSet, PowerSet 

>>> FiniteSet(Matrix([1, 2])).kind
SetKind(MatrixKind(NumberKind)) 

>>> Interval(1, 2).kind
SetKind(NumberKind) 

>>> EmptySet.kind
SetKind() 

sympy.sets.powerset.PowerSet是一组集合的集合：

>>> PowerSet({1, 2, 3}).kind
SetKind(SetKind(NumberKind)) 

ProductSet代表其他集合元素的元组集合。其种类为sympy.core.containers.TupleKind，由这些集合元素的种类参数化：

>>> p = ProductSet(FiniteSet(1, 2), FiniteSet(3, 4))
>>> list(p)
[(1, 3), (2, 3), (1, 4), (2, 4)]
>>> p.kind
SetKind(TupleKind(NumberKind, NumberKind)) 

当集合的所有元素不具有相同种类时，种类将返回为SetKind(UndefinedKind)：

>>> FiniteSet(0, Matrix([1, 2])).kind
SetKind(UndefinedKind) 

集合元素的种类由SetKind的element_kind属性给出：

>>> Interval(1, 2).kind.element_kind
NumberKind 

另见

NumberKind, sympy.core.kind.UndefinedKind, sympy.core.containers.TupleKind, MatrixKind, sympy.matrices.expressions.sets.MatrixSet, sympy.sets.conditionset.ConditionSet, Rationals, Naturals, Integers, sympy.sets.fancysets.ImageSet, sympy.sets.fancysets.Range, sympy.sets.fancysets.ComplexRegion, sympy.sets.powerset.PowerSet, sympy.sets.sets.ProductSet, sympy.sets.sets.Interval, sympy.sets.sets.Union, sympy.sets.sets.Intersection, sympy.sets.sets.Complement, sympy.sets.sets.EmptySet, sympy.sets.sets.UniversalSet, sympy.sets.sets.FiniteSet, sympy.sets.sets.SymmetricDifference, sympy.sets.sets.DisjointUnion

property measure

self的（勒贝格）测度。

示例

>>> from sympy import Interval, Union
>>> Interval(0, 1).measure
1
>>> Union(Interval(0, 1), Interval(2, 3)).measure
2 

powerset()

找到self的幂集。

示例

>>> from sympy import EmptySet, FiniteSet, Interval 

空集的幂集：

>>> A = EmptySet
>>> A.powerset()
{EmptySet} 

有限集的幂集：

>>> A = FiniteSet(1, 2)
>>> a, b, c = FiniteSet(1), FiniteSet(2), FiniteSet(1, 2)
>>> A.powerset() == FiniteSet(a, b, c, EmptySet)
True 

区间的幂集：

>>> Interval(1, 2).powerset()
PowerSet(Interval(1, 2)) 

参考文献

[R838]

en.wikipedia.org/wiki/Power_set

property sup

self的最大值。

示例

>>> from sympy import Interval, Union
>>> Interval(0, 1).sup
1
>>> Union(Interval(0, 1), Interval(2, 3)).sup
3 

symmetric_difference(other)

返回self和other的对称差异。

示例

>>> from sympy import Interval, S
>>> Interval(1, 3).symmetric_difference(S.Reals)
Union(Interval.open(-oo, 1), Interval.open(3, oo))
>>> Interval(1, 10).symmetric_difference(S.Reals)
Union(Interval.open(-oo, 1), Interval.open(10, oo)) 

>>> from sympy import S, EmptySet
>>> S.Reals.symmetric_difference(EmptySet)
Reals 

参考文献

[R839]

en.wikipedia.org/wiki/Symmetric_difference

union(other)

返回self和other的并集。

示例

作为快捷方式，可以使用+运算符：

>>> from sympy import Interval, FiniteSet
>>> Interval(0, 1).union(Interval(2, 3))
Union(Interval(0, 1), Interval(2, 3))
>>> Interval(0, 1) + Interval(2, 3)
Union(Interval(0, 1), Interval(2, 3))
>>> Interval(1, 2, True, True) + FiniteSet(2, 3)
Union({3}, Interval.Lopen(1, 2)) 

同样地，可以使用-运算符进行集合差异：

>>> Interval(0, 2) - Interval(0, 1)
Interval.Lopen(1, 2)
>>> Interval(1, 3) - FiniteSet(2)
Union(Interval.Ropen(1, 2), Interval.Lopen(2, 3)) 

sympy.sets.sets.imageset(*args)

返回变换f下集合的图像。

解释

如果此函数无法计算图像，则返回一个未评估的 ImageSet 对象。

[{ f(x) \mid x \in \mathrm{self} }]

示例

>>> from sympy import S, Interval, imageset, sin, Lambda
>>> from sympy.abc import x 

>>> imageset(x, 2*x, Interval(0, 2))
Interval(0, 4) 

>>> imageset(lambda x: 2*x, Interval(0, 2))
Interval(0, 4) 

>>> imageset(Lambda(x, sin(x)), Interval(-2, 1))
ImageSet(Lambda(x, sin(x)), Interval(-2, 1)) 

>>> imageset(sin, Interval(-2, 1))
ImageSet(Lambda(x, sin(x)), Interval(-2, 1))
>>> imageset(lambda y: x + y, Interval(-2, 1))
ImageSet(Lambda(y, x + y), Interval(-2, 1)) 

应用于整数集合的表达式被简化，以显示尽可能少的负数，并将线性表达式转换为规范形式。如果不希望这样，则应使用未评估的 ImageSet。

>>> imageset(x, -2*x + 5, S.Integers)
ImageSet(Lambda(x, 2*x + 1), Integers) 

另请参阅

sympy.sets.fancysets.ImageSet

基本集合

class sympy.sets.sets.Interval(start, end, left_open=False, right_open=False)

将实数区间表示为一个集合。

用法：

返回具有起始点start和结束点end的区间。

对于left_open=True（默认left_open为False），区间左侧将是开放的。同样地，对于right_open=True，区间右侧将是开放的。

示例

>>> from sympy import Symbol, Interval
>>> Interval(0, 1)
Interval(0, 1)
>>> Interval.Ropen(0, 1)
Interval.Ropen(0, 1)
>>> Interval.Ropen(0, 1)
Interval.Ropen(0, 1)
>>> Interval.Lopen(0, 1)
Interval.Lopen(0, 1)
>>> Interval.open(0, 1)
Interval.open(0, 1) 

>>> a = Symbol('a', real=True)
>>> Interval(0, a)
Interval(0, a) 

注意

• 仅支持实数端点

• Interval(a, b)，其中 (a > b)，将返回空集

• 使用evalf()方法将区间转换为 mpmath 的mpi区间实例

参考文献

[R840]

zh.wikipedia.org/wiki/区间 _(数学)

classmethod Lopen(a, b)

返回不包含左边界的区间。

classmethod Ropen(a, b)

返回不包含右边界的区间。

as_relational(x)

用不等式和逻辑运算符重写一个区间。

property end

区间的右端点。

此属性与sup属性取相同值。

示例

>>> from sympy import Interval
>>> Interval(0, 1).end
1 

property is_left_unbounded

如果左端点为负无穷，则返回True。

property is_right_unbounded

如果右端点为正无穷，则返回True。

property left_open

如果区间左开放，则为True。

示例

>>> from sympy import Interval
>>> Interval(0, 1, left_open=True).left_open
True
>>> Interval(0, 1, left_open=False).left_open
False 

classmethod open(a, b)

返回一个不包含任何边界的区间。

property right_open

如果区间右开放，则为True。

示例

>>> from sympy import Interval
>>> Interval(0, 1, right_open=True).right_open
True
>>> Interval(0, 1, right_open=False).right_open
False 

property start

区间的左端点。

此属性与inf属性取相同值。

示例

>>> from sympy import Interval
>>> Interval(0, 1).start
0 

class sympy.sets.sets.FiniteSet(*args, **kwargs)

表示一组有限的 Sympy 表达式。

示例

>>> from sympy import FiniteSet, Symbol, Interval, Naturals0
>>> FiniteSet(1, 2, 3, 4)
{1, 2, 3, 4}
>>> 3 in FiniteSet(1, 2, 3, 4)
True
>>> FiniteSet(1, (1, 2), Symbol('x'))
{1, x, (1, 2)}
>>> FiniteSet(Interval(1, 2), Naturals0, {1, 2})
FiniteSet({1, 2}, Interval(1, 2), Naturals0)
>>> members = [1, 2, 3, 4]
>>> f = FiniteSet(*members)
>>> f
{1, 2, 3, 4}
>>> f - FiniteSet(2)
{1, 3, 4}
>>> f + FiniteSet(2, 5)
{1, 2, 3, 4, 5} 

参考文献

[R841]

zh.wikipedia.org/wiki/有限集合

as_relational(symbol)

用等式和逻辑运算符重写一个有限集。

复合集合

class sympy.sets.sets.Union(*args, **kwargs)

表示集合的并集作为Set。

示例

>>> from sympy import Union, Interval
>>> Union(Interval(1, 2), Interval(3, 4))
Union(Interval(1, 2), Interval(3, 4)) 

并集构造函数将始终尝试合并重叠的区间，如果可能的话。例如：

>>> Union(Interval(1, 2), Interval(2, 3))
Interval(1, 3) 

另请参阅

Intersection

参考文献

[R842]

zh.wikipedia.org/wiki/并集 _(集合论)

as_relational(symbol)

用等式和逻辑运算符重写并集。

class sympy.sets.sets.Intersection(*args, evaluate=None)

表示集合的交集作为Set。

示例

>>> from sympy import Intersection, Interval
>>> Intersection(Interval(1, 3), Interval(2, 4))
Interval(2, 3) 

我们经常使用.intersect方法

>>> Interval(1,3).intersect(Interval(2,4))
Interval(2, 3) 

另请参阅

Union

参考文献

[R843]

zh.wikipedia.org/wiki/交集 _(集合论)

as_relational(symbol)

用等式和逻辑运算符重写一个交集。

class sympy.sets.sets.ProductSet(*sets, **assumptions)

表示集合的笛卡尔积。

解释

给定多个集合作为可迭代或单个参数时返回笛卡尔积。

可以在任何集合上使用*运算符进行方便的简写。

例子

>>> from sympy import Interval, FiniteSet, ProductSet
>>> I = Interval(0, 5); S = FiniteSet(1, 2, 3)
>>> ProductSet(I, S)
ProductSet(Interval(0, 5), {1, 2, 3}) 

>>> (2, 2) in ProductSet(I, S)
True 

>>> Interval(0, 1) * Interval(0, 1) # The unit square
ProductSet(Interval(0, 1), Interval(0, 1)) 

>>> coin = FiniteSet('H', 'T')
>>> set(coin**2)
{(H, H), (H, T), (T, H), (T, T)} 

笛卡尔积不是可交换的或可结合的，例如：

>>> I*S == S*I
False
>>> (I*I)*I == I*(I*I)
False 

注意

• 将大多数操作传递到参数集合

参考

[R844]

zh.wikipedia.org/wiki/笛卡尔积

property is_iterable

一个测试集合是否可迭代的属性方法。如果集合可迭代，则返回 True，否则返回 False。

例子

>>> from sympy import FiniteSet, Interval
>>> I = Interval(0, 1)
>>> A = FiniteSet(1, 2, 3, 4, 5)
>>> I.is_iterable
False
>>> A.is_iterable
True 

class sympy.sets.sets.Complement(a, b, evaluate=True)

表示一个集合与另一个集合的集合差异或相对补集。

[A - B = {x \in A \mid x \notin B}]

例子

>>> from sympy import Complement, FiniteSet
>>> Complement(FiniteSet(0, 1, 2), FiniteSet(1))
{0, 2} 

参见

Intersection, Union

参考

[R845]

mathworld.wolfram.com/补集.html

as_relational(symbol)

用等式和逻辑运算符重写一个补集

static reduce(A, B)

简化一个Complement。

class sympy.sets.sets.SymmetricDifference(a, b, evaluate=True)

表示属于任一集合而不属于它们的交集的元素的集合。

例子

>>> from sympy import SymmetricDifference, FiniteSet
>>> SymmetricDifference(FiniteSet(1, 2, 3), FiniteSet(3, 4, 5))
{1, 2, 4, 5} 

参见

Complement, Union

参考

[R846]

zh.wikipedia.org/wiki/对称差

as_relational(symbol)

用等式和逻辑运算符重写对称差

class sympy.sets.sets.DisjointUnion(*sets)

表示有限个集合的不交并（也称为外不交并）。

例子

>>> from sympy import DisjointUnion, FiniteSet, Interval, Union, Symbol
>>> A = FiniteSet(1, 2, 3)
>>> B = Interval(0, 5)
>>> DisjointUnion(A, B)
DisjointUnion({1, 2, 3}, Interval(0, 5))
>>> DisjointUnion(A, B).rewrite(Union)
Union(ProductSet({1, 2, 3}, {0}), ProductSet(Interval(0, 5), {1}))
>>> C = FiniteSet(Symbol('x'), Symbol('y'), Symbol('z'))
>>> DisjointUnion(C, C)
DisjointUnion({x, y, z}, {x, y, z})
>>> DisjointUnion(C, C).rewrite(Union)
ProductSet({x, y, z}, {0, 1}) 

参考

zh.wikipedia.org/wiki/不交并

单例集合

class sympy.sets.sets.EmptySet

表示空集。空集作为单例S.EmptySet提供。

例子

>>> from sympy import S, Interval
>>> S.EmptySet
EmptySet 

>>> Interval(1, 2).intersect(S.EmptySet)
EmptySet 

参见

UniversalSet

参考

[R847]

zh.wikipedia.org/wiki/空集

class sympy.sets.sets.UniversalSet

表示所有事物的集合。通用集合作为单例S.UniversalSet提供。

例子

>>> from sympy import S, Interval
>>> S.UniversalSet
UniversalSet 

>>> Interval(1, 2).intersect(S.UniversalSet)
Interval(1, 2) 

参见

EmptySet

参考

[R848]

zh.wikipedia.org/wiki/通用集合

特殊集合

class sympy.sets.fancysets.Rationals

表示有理数。此集合也作为单例S.Rationals提供。

例子

>>> from sympy import S
>>> S.Half in S.Rationals
True
>>> iterable = iter(S.Rationals)
>>> [next(iterable) for i in range(12)]
[0, 1, -1, 1/2, 2, -1/2, -2, 1/3, 3, -1/3, -3, 2/3] 

class sympy.sets.fancysets.Naturals

表示自然数（或计数数），即从 1 开始的所有正整数。此集合也作为单例S.Naturals提供。

例子

>>> from sympy import S, Interval, pprint
>>> 5 in S.Naturals
True
>>> iterable = iter(S.Naturals)
>>> next(iterable)
1
>>> next(iterable)
2
>>> next(iterable)
3
>>> pprint(S.Naturals.intersect(Interval(0, 10)))
{1, 2, ..., 10} 

参见

Naturals0

非负整数（即包括 0）

Integers

还包括负整数

class sympy.sets.fancysets.Naturals0

表示全体非负整数，包括零。

参见

Naturals

正整数；不包括 0

整数集

还包括负整数

class sympy.sets.fancysets.Integers

表示所有整数：正数、负数和零。这个集合也可以作为单例 S.Integers。

示例

>>> from sympy import S, Interval, pprint
>>> 5 in S.Naturals
True
>>> iterable = iter(S.Integers)
>>> next(iterable)
0
>>> next(iterable)
1
>>> next(iterable)
-1
>>> next(iterable)
2 

>>> pprint(S.Integers.intersect(Interval(-4, 4)))
{-4, -3, ..., 4} 

另见

Naturals0

非负整数

整数集

正整数、负整数和零

class sympy.sets.fancysets.Reals

表示从负无穷到正无穷的所有实数，包括所有整数、有理数和无理数。这个集合也可以作为单例 S.Reals。

示例

>>> from sympy import S, Rational, pi, I
>>> 5 in S.Reals
True
>>> Rational(-1, 2) in S.Reals
True
>>> pi in S.Reals
True
>>> 3*I in S.Reals
False
>>> S.Reals.contains(pi)
True 

另见

复数区域

class sympy.sets.fancysets.Complexes

所有复数的集

示例

>>> from sympy import S, I
>>> S.Complexes
Complexes
>>> 1 + I in S.Complexes
True 

另见

实数集，复数区域

class sympy.sets.fancysets.ImageSet(flambda, *sets)

数学函数下集的映像。变换必须作为 Lambda 函数给出，它有与其操作的集合元素相同数量的参数，例如，在整数集上操作时有 1 个参数或者在复数区域上操作时有 2 个参数。

此函数通常不直接调用，但从 imageset 调用。

示例

>>> from sympy import Symbol, S, pi, Dummy, Lambda
>>> from sympy import FiniteSet, ImageSet, Interval 

>>> x = Symbol('x')
>>> N = S.Naturals
>>> squares = ImageSet(Lambda(x, x**2), N) # {x**2 for x in N}
>>> 4 in squares
True
>>> 5 in squares
False 

>>> FiniteSet(0, 1, 2, 3, 4, 5, 6, 7, 9, 10).intersect(squares)
{1, 4, 9} 

>>> square_iterable = iter(squares)
>>> for i in range(4):
...     next(square_iterable)
1
4
9
16 

如果您想要获取 x = 2、1/2 等值（请在将其作为参数传递之前检查 x 值是否在 base_set 中）

>>> squares.lamda(2)
4
>>> squares.lamda(S(1)/2)
1/4 

>>> n = Dummy('n')
>>> solutions = ImageSet(Lambda(n, n*pi), S.Integers) # solutions of sin(x) = 0
>>> dom = Interval(-1, 1)
>>> dom.intersect(solutions)
{0} 

另见

sympy.sets.sets.imageset

class sympy.sets.fancysets.Range(*args)

表示整数范围。可以作为 Range(stop)、Range(start, stop) 或 Range(start, stop, step) 调用；当未给出 step 时，默认为 1。

Range(stop) 相当于 Range(0, stop, 1)，并且停止值（与 Python 的 range 类似）不包括在 Range 值中。

>>> from sympy import Range
>>> list(Range(3))
[0, 1, 2] 

步长也可以为负数：

>>> list(Range(10, 0, -2))
[10, 8, 6, 4, 2] 

停止值被作为标准，因此等效的范围始终具有相同的参数：

>>> Range(0, 10, 3)
Range(0, 12, 3) 

允许无限范围。oo 和 -oo 从不包括在集合中（Range 总是 Integers 的子集）。如果起始点是无限的，则最终值为 stop - step。要反向迭代这样的范围，需要将其反转：

>>> from sympy import oo
>>> r = Range(-oo, 1)
>>> r[-1]
0
>>> next(iter(r))
Traceback (most recent call last):
...
TypeError: Cannot iterate over Range with infinite start
>>> next(iter(r.reversed))
0 

虽然 Range 是一个 集（并支持常规的集操作），它保持元素的顺序，并可用于需要使用 range 的上下文中。

>>> from sympy import Interval
>>> Range(0, 10, 2).intersect(Interval(3, 7))
Range(4, 8, 2)
>>> list(_)
[4, 6] 

虽然对范围的切片将始终返回一个范围（可能为空），但任何空交集都将返回一个空集：

>>> Range(3)[:0]
Range(0, 0, 1)
>>> Range(3).intersect(Interval(4, oo))
EmptySet
>>> Range(3).intersect(Range(4, oo))
EmptySet 

Range 将接受符号参数，但对于除了显示 Range 外的其他操作支持非常有限：

>>> from sympy import Symbol, pprint
>>> from sympy.abc import i, j, k
>>> Range(i, j, k).start
i
>>> Range(i, j, k).inf
Traceback (most recent call last):
...
ValueError: invalid method for symbolic range 

当使用整数符号时，将获得更大的成功：

>>> n = Symbol('n', integer=True)
>>> r = Range(n, n + 20, 3)
>>> r.inf
n
>>> pprint(r)
{n, n + 3, ..., n + 18} 

as_relational(x)

用等式和逻辑运算符重写一个范围。

property reversed

返回一个相反顺序的等效范围。

示例

>>> from sympy import Range
>>> Range(10).reversed
Range(9, -1, -1) 

class sympy.sets.fancysets.ComplexRegion(sets, polar=False)

表示所有复数的集合。它可以以标准形式的极坐标和直角坐标表示复平面的一个区域。

• 极坐标形式输入以复数平面中复数的模数 r 和角度 theta 的 ProductSet 或 Union of ProductSets 形式给出，并使用标志 polar=True。

  [Z = {z \in \mathbb{C} \mid z = r\times (\cos(\theta) + I\sin(\theta)), r \in [\texttt{r}], \theta \in [\texttt{theta}]}]

• 矩形形式输入以复数平面中复数的实部和虚部 x 和 y 的 ProductSet 或 Union of ProductSets 形式给出。默认输入类型为矩形形式。

[Z = {z \in \mathbb{C} \mid z = x + Iy, x \in [\operatorname{re}(z)], y \in [\operatorname{im}(z)]}]

例子

>>> from sympy import ComplexRegion, Interval, S, I, Union
>>> a = Interval(2, 3)
>>> b = Interval(4, 6)
>>> c1 = ComplexRegion(a*b)  # Rectangular Form
>>> c1
CartesianComplexRegion(ProductSet(Interval(2, 3), Interval(4, 6))) 

• c1 表示复平面中由四个顶点 (2, 4), (3, 4), (3, 6) 和 (2, 6) 包围的矩形区域。

>>> c = Interval(1, 8)
>>> c2 = ComplexRegion(Union(a*b, b*c))
>>> c2
CartesianComplexRegion(Union(ProductSet(Interval(2, 3), Interval(4, 6)), ProductSet(Interval(4, 6), Interval(1, 8)))) 

• c2 表示复平面中两个矩形区域的并集。其中一个区域由 c1 的坐标包围，另一个区域由坐标 (4, 1), (6, 1), (6, 8) 和 (4, 8) 包围。

>>> 2.5 + 4.5*I in c1
True
>>> 2.5 + 6.5*I in c1
False 

>>> r = Interval(0, 1)
>>> theta = Interval(0, 2*S.Pi)
>>> c2 = ComplexRegion(r*theta, polar=True)  # Polar Form
>>> c2  # unit Disk
PolarComplexRegion(ProductSet(Interval(0, 1), Interval.Ropen(0, 2*pi))) 

• c2 表示复平面中原点为圆心的单位圆内部的区域。

>>> 0.5 + 0.5*I in c2
True
>>> 1 + 2*I in c2
False 

>>> unit_disk = ComplexRegion(Interval(0, 1)*Interval(0, 2*S.Pi), polar=True)
>>> upper_half_unit_disk = ComplexRegion(Interval(0, 1)*Interval(0, S.Pi), polar=True)
>>> intersection = unit_disk.intersect(upper_half_unit_disk)
>>> intersection
PolarComplexRegion(ProductSet(Interval(0, 1), Interval(0, pi)))
>>> intersection == upper_half_unit_disk
True 

另请参阅

CartesianComplexRegion, PolarComplexRegion, Complexes

property a_interval

当 self 是矩形形式时，返回 (x) 的区间的并集，或者当 self 是极坐标形式时，返回 (r) 的区间的并集。

例子

>>> from sympy import Interval, ComplexRegion, Union
>>> a = Interval(2, 3)
>>> b = Interval(4, 5)
>>> c = Interval(1, 7)
>>> C1 = ComplexRegion(a*b)
>>> C1.a_interval
Interval(2, 3)
>>> C2 = ComplexRegion(Union(a*b, b*c))
>>> C2.a_interval
Union(Interval(2, 3), Interval(4, 5)) 

property b_interval

当 self 是矩形形式时，返回 (y) 的区间的并集，或者当 self 是极坐标形式时，返回 (theta) 的区间的并集。

例子

>>> from sympy import Interval, ComplexRegion, Union
>>> a = Interval(2, 3)
>>> b = Interval(4, 5)
>>> c = Interval(1, 7)
>>> C1 = ComplexRegion(a*b)
>>> C1.b_interval
Interval(4, 5)
>>> C2 = ComplexRegion(Union(a*b, b*c))
>>> C2.b_interval
Interval(1, 7) 

classmethod from_real(sets)

将给定的实数子集转换为复数区域。

例子

>>> from sympy import Interval, ComplexRegion
>>> unit = Interval(0,1)
>>> ComplexRegion.from_real(unit)
CartesianComplexRegion(ProductSet(Interval(0, 1), {0})) 

property psets

返回一个包含输入 self 的 ProductSets 的元组。

例子

>>> from sympy import Interval, ComplexRegion, Union
>>> a = Interval(2, 3)
>>> b = Interval(4, 5)
>>> c = Interval(1, 7)
>>> C1 = ComplexRegion(a*b)
>>> C1.psets
(ProductSet(Interval(2, 3), Interval(4, 5)),)
>>> C2 = ComplexRegion(Union(a*b, b*c))
>>> C2.psets
(ProductSet(Interval(2, 3), Interval(4, 5)), ProductSet(Interval(4, 5), Interval(1, 7))) 

property sets

返回原始输入集合给 self。

例子

>>> from sympy import Interval, ComplexRegion, Union
>>> a = Interval(2, 3)
>>> b = Interval(4, 5)
>>> c = Interval(1, 7)
>>> C1 = ComplexRegion(a*b)
>>> C1.sets
ProductSet(Interval(2, 3), Interval(4, 5))
>>> C2 = ComplexRegion(Union(a*b, b*c))
>>> C2.sets
Union(ProductSet(Interval(2, 3), Interval(4, 5)), ProductSet(Interval(4, 5), Interval(1, 7))) 

class sympy.sets.fancysets.CartesianComplexRegion(sets)

表示复平面上一个正方形区域的集合。

[Z = {z \in \mathbb{C} \mid z = x + Iy, x \in [\operatorname{re}(z)], y \in [\operatorname{im}(z)]}]

例子

>>> from sympy import ComplexRegion, I, Interval
>>> region = ComplexRegion(Interval(1, 3) * Interval(4, 6))
>>> 2 + 5*I in region
True
>>> 5*I in region
False 

另请参阅

ComplexRegion, PolarComplexRegion, Complexes

class sympy.sets.fancysets.PolarComplexRegion(sets)

表示复平面上一个极坐标区域的集合。

[Z = {z \in \mathbb{C} \mid z = r\times (\cos(\theta) + I\sin(\theta)), r \in [\texttt{r}], \theta \in [\texttt{theta}]}]

例子

>>> from sympy import ComplexRegion, Interval, oo, pi, I
>>> rset = Interval(0, oo)
>>> thetaset = Interval(0, pi)
>>> upper_half_plane = ComplexRegion(rset * thetaset, polar=True)
>>> 1 + I in upper_half_plane
True
>>> 1 - I in upper_half_plane
False 

另请参阅

ComplexRegion, CartesianComplexRegion, Complexes

sympy.sets.fancysets.normalize_theta_set(theta)

将实数集合 ( \theta ) 规范化到区间 ([0, 2\pi))。它返回集合中 (\theta) 的规范化值。对于区间，最多返回一个周期 ([0, 2\pi])，即对于等于 ([0, 10\pi]) 的 (\theta)，返回的规范化值将是 (0, 2\pi))。目前不支持端点为 pi 的非倍数的区间。

抛出：

未实现错误

尚未实现正规化 theta Set 的算法。

数值错误

输入无效，即输入不是实集。

运行时错误

这是一个错误，请报告给 GitHub 问题跟踪器。

示例

>>> from sympy.sets.fancysets import normalize_theta_set
>>> from sympy import Interval, FiniteSet, pi
>>> normalize_theta_set(Interval(9*pi/2, 5*pi))
Interval(pi/2, pi)
>>> normalize_theta_set(Interval(-3*pi/2, pi/2))
Interval.Ropen(0, 2*pi)
>>> normalize_theta_set(Interval(-pi/2, pi/2))
Union(Interval(0, pi/2), Interval.Ropen(3*pi/2, 2*pi))
>>> normalize_theta_set(Interval(-4*pi, 3*pi))
Interval.Ropen(0, 2*pi)
>>> normalize_theta_set(Interval(-3*pi/2, -pi/2))
Interval(pi/2, 3*pi/2)
>>> normalize_theta_set(FiniteSet(0, pi, 3*pi))
{0, pi} 
```  ## 幂集

```py
class sympy.sets.powerset.PowerSet(arg, evaluate=None)

代表幂集的符号对象。

参数：

arg：集合

进行幂操作的集合。

评估：布尔值

控制评估的标志。

如果禁用有限集的评估，则可以利用子集测试作为成员测试的优势。

注意事项

幂集 (\mathcal{P}(S)) 定义为包含 (S) 的所有子集的集合。

如果集合 (S) 是有限集，则其幂集将具有 (2^{\left| S \right|}) 个元素，其中 (\left| S \right|) 表示 (S) 的基数。

示例

>>> from sympy import PowerSet, S, FiniteSet 

有限集的幂集：

>>> PowerSet(FiniteSet(1, 2, 3))
PowerSet({1, 2, 3}) 

空集的幂集：

>>> PowerSet(S.EmptySet)
PowerSet(EmptySet)
>>> PowerSet(PowerSet(S.EmptySet))
PowerSet(PowerSet(EmptySet)) 

无限集的幂集：

>>> PowerSet(S.Reals)
PowerSet(Reals) 

对有限集的幂集进行显式形式的评估：

>>> PowerSet(FiniteSet(1, 2, 3)).rewrite(FiniteSet)
FiniteSet(EmptySet, {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {1, 2, 3}) 

引用

[[R849]

en.wikipedia.org/wiki/Power_set

[R850]

en.wikipedia.org/wiki/Axiom_of_power_set ## 条件集合

class sympy.sets.conditionset.ConditionSet(sym, condition, base_set=UniversalSet)

满足给定条件的元素集合。

[{x \mid \textrm{condition}(x) = \texttt{True}, x \in S}]

示例

>>> from sympy import Symbol, S, ConditionSet, pi, Eq, sin, Interval
>>> from sympy.abc import x, y, z 

>>> sin_sols = ConditionSet(x, Eq(sin(x), 0), Interval(0, 2*pi))
>>> 2*pi in sin_sols
True
>>> pi/2 in sin_sols
False
>>> 3*pi in sin_sols
False
>>> 5 in ConditionSet(x, x**2 > 4, S.Reals)
True 

如果值不在基本集合中，则结果为假：

>>> 5 in ConditionSet(x, x**2 > 4, Interval(2, 4))
False 

注意事项

应避免具有假设的符号，否则条件可能会在不考虑集合的情况下进行评估：

>>> n = Symbol('n', negative=True)
>>> cond = (n > 0); cond
False
>>> ConditionSet(n, cond, S.Integers)
EmptySet 

只有自由符号可以通过 (subs) 进行更改：

>>> c = ConditionSet(x, x < 1, {x, z})
>>> c.subs(x, y)
ConditionSet(x, x < 1, {y, z}) 

要检查 pi 是否在 c 中使用：

>>> pi in c
False 

如果未指定基本集合，则暗示通用集合：

>>> ConditionSet(x, x < 1).base_set
UniversalSet 

只能使用符号或类似符号的表达式：

>>> ConditionSet(x + 1, x + 1 < 1, S.Integers)
Traceback (most recent call last):
...
ValueError: non-symbol dummy not recognized in condition 

当基本集合为 ConditionSet 时，如果可能的话，符号将被统一，并优先考虑最外层的符号：

>>> ConditionSet(x, x < y, ConditionSet(z, z + y < 2, S.Integers))
ConditionSet(x, (x < y) & (x + y < 2), Integers) 

class sympy.sets.conditionset.Contains(x, s, evaluate=None)

断言 x 是集合 S 的元素。

示例

>>> from sympy import Symbol, Integer, S, Contains
>>> Contains(Integer(2), S.Integers)
True
>>> Contains(Integer(-2), S.Naturals)
False
>>> i = Symbol('i', integer=True)
>>> Contains(i, S.Naturals)
Contains(i, Naturals) 

引用

[R851]

en.wikipedia.org/wiki/Element_%28mathematics%29

SetKind

class sympy.sets.conditionset.SetKind(element_kind=None)

SetKind 是所有集合的种类

每个 Set 实例都将有一个由元素的种类 SetKind 参数化的参数。元素的种类可能是 NumberKind，或者 TupleKind 或其他某些种类。当不是所有元素都具有相同的种类时，元素的种类将被给定为 UndefinedKind。

参数：

element_kind：种类（可选）

集合元素的类型。在定义良好的集合中，所有元素将具有相同的类型。否则，类型应为sympy.core.kind.UndefinedKind。element_kind 参数是可选的，但只能在EmptySet的情况下省略，其类型仅为SetKind()

示例

>>> from sympy import Interval
>>> Interval(1, 2).kind
SetKind(NumberKind)
>>> Interval(1,2).kind.element_kind
NumberKind 

另请参见

sympy.core.kind.NumberKind, sympy.matrices.kind.MatrixKind, sympy.core.containers.TupleKind

集合的迭代

对于集合的并集，({a, b} \cup {x, y}) 可以视为 ({a, b, x, y}) 进行迭代，无论元素的唯一性如何，但是对于集合的交集，假设 ({a, b} \cap {x, y}) 是 (\varnothing) 或 ({a, b }) 并不总是有效的，因为其中的一些 (a), (b), (x) 或 (y) 可能不是交集的元素。

对涉及交集、补集或对称差的集合元素进行迭代会产生（可能重复的）集合元素，前提是所有元素都已知是集合的元素。如果任何元素不能确定是集合的成员，则迭代会产生TypeError。这与x in y会产生错误的情况相同。

有一些原因可以这样实现，即使这破坏了与 Python 集合迭代器工作方式的一致性。我们要记住，像FiniteSet(*s)从现有的 sympy 集合中推导出的集合可能是常见用法。这种方法会使FiniteSet(*s)与任何符号集合处理方法（如FiniteSet(*simplify(s))）保持一致。