查看源代码 sofs (stdlib v6.2)
用于操作集合的集合的函数。
此模块提供对表示为集合的有限集合和关系的操作。直观地说，集合是元素的集合；每个元素都属于该集合，并且该集合包含每个元素。
此模块使用的表示 sofs 的数据应被其他模块视为不透明的。从抽象的角度来看，表示形式是现有 Erlang 术语的复合类型。请参阅关于数据类型的说明。任何假设知道格式的代码都在如履薄冰。
给定一个集合 A 和一个句子 S(x)，其中 x 是一个自由变量，可以形成一个新的集合 B，其元素恰好是 A 中满足 S(x) 的元素，这表示为 B = {x in A : S(x)}。句子使用逻辑运算符“存在”（或“存在一些”）、“对于所有”、“与”、“或”、“非”来表达。如果已知存在一个包含所有指定元素的集合（如本模块中始终存在的情况），则表示为 B = {x : S(x)}。
包含元素 a、b 和 c 的无序集合表示为 {a, b, c}。此表示法不要与元组混淆。
a 和 b 的有序对，其中第一个坐标是 a，第二个坐标是 b，表示为 (a, b)。有序对是一个包含两个元素的有序集合。在本模块中，有序集合可以包含一个、两个或多个元素，并使用括号括住这些元素。
无序集合和有序集合是正交的，再次说明是在本模块中；没有哪个无序集合等于任何有序集合。
空集不包含任何元素。
如果集合 A 和集合 B 包含相同的元素，则集合 A 等于集合 B，表示为 A = B。如果两个有序集合包含相同数量的元素，并且在每个坐标处都具有相等的元素，则它们相等。
如果 A 包含 B 包含的所有元素，则集合 B 是集合 A 的子集。
两个集合 A 和 B 的并集是包含 A 的所有元素和 B 的所有元素的最小集合。
两个集合 A 和 B 的交集是包含 A 中属于 B 的所有元素的集合。
如果两个集合的交集是空集，则它们是不相交的。
两个集合 A 和 B 的差集是包含 A 中不属于 B 的所有元素的集合。
两个集合的对称差集是包含属于两个集合之一但不属于两个集合的元素的集合。
一个集合的集合的并集是包含属于集合中的至少一个集合的所有元素的最小集合。
一个非空集合的集合的交集是包含属于集合中每个集合的所有元素的集合。
两个集合 X 和 Y 的笛卡尔积，表示为 X × Y，是集合 {a : a = (x, y) 对于某些 x in X 和某些 y in Y}。
关系是 X × Y 的子集。令 R 为关系。(x, y) 属于 R 的事实写为 x R y。由于关系是集合，因此最后一项（子集、并集等）的定义也适用于关系。
R 的定义域是集合 {x : 对于某些 y in Y，x R y}。
R 的值域是集合 {y : 对于某些 x in X，x R y}。
R 的逆关系是集合 {a : a = (y, x) 对于某些 (x, y) in R}。
如果 A 是 X 的子集，则 A 在 R 下的像是集合 {y : 对于某些 x in A，x R y}。如果 B 是 Y 的子集，则 B 的原像是集合 {x : 对于某些 y in B，x R y}。
如果 R 是从 X 到 Y 的关系，而 S 是从 Y 到 Z 的关系，则 R 和 S 的相对积是从 X 到 Z 的关系 T，定义为当且仅当 Y 中存在一个元素 y 使得 x R y 且 y S z 时，x T z。
R 对 A 的限制是集合 S，定义为当且仅当 A 中存在一个元素 x 使得 x R y 时，x S y。
如果 S 是 R 对 A 的限制，则 R 是 S 对 X 的扩展。
如果 X = Y，则 R 称为 X 中的关系。
X 中关系 R 的域是 R 的定义域和 R 的值域的并集。
如果 R 是 X 中的关系，并且 S 定义为当 x R y 且不 x = y 时，x S y，则 S 是与 R 对应的严格关系。相反，如果 S 是 X 中的关系，并且 R 定义为当 x S y 或 x = y 时，x R y，则 R 是与 S 对应的弱关系。
如果对于 X 的每个元素 x，都有 x R x，则 X 中的关系 R 是自反的；如果 x R y 意味着 y R x，则它是对称的；如果 x R y 且 y R z 意味着 x R z，则它是传递的。
函数 F 是一个关系，是 X × Y 的子集，使得 F 的定义域等于 X，并且对于 X 中的每个 x，在 Y 中都存在唯一的元素 y，使得 (x, y) 在 F 中。后一个条件可以表述为：如果 x F y 且 x F z，则 y = z。在本模块中，不要求 F 的定义域等于 X 才能将关系视为函数。
当 F 是一个函数时，我们写 F(x) = y 而不是写 (x, y) in F 或 x F y，并且说 F 将 x 映射到 y，或者说 F 在 x 处的值为 y。
由于函数是关系，因此最后一项（定义域、值域等）的定义也适用于函数。
如果函数 F 的逆关系是一个函数 F'，则 F' 称为 F 的逆。
如果 F1 的值域是 F2 的定义域的子集，则两个函数 F1 和 F2 的相对积称为 F1 和 F2 的复合。
有时，当函数的值域比函数本身更重要时，该函数称为族。
族的定义域称为索引集，值域称为索引集。
如果 x 是从 I 到 X 的族，则 x[i] 表示函数在索引 i 处的值。术语“X 中的族”用于这样的族。
当索引集是集合 X 的子集集合时，我们称 x 为 X 的子集族。
如果 x 是 X 的子集族，则 x 的值域的并集称为族 x 的并集。
如果 x 是非空的（索引集是非空的），则族 x 的交集是 x 的值域的交集。
在本模块中，唯一考虑的族是某个集合 X 的子集族；在下面，单词“族”用于这样的子集族。
集合 X 的划分是 X 的非空子集的集合 S，其并集为 X，并且其元素是两两不相交的。
集合中的关系如果是自反的、对称的和传递的，则它是等价关系。
如果 R 是 X 中的等价关系，并且 x 是 X 的一个元素，则 x 关于 R 的等价类是所有使得 x R y 成立的 X 的元素 y 的集合。等价类构成 X 的划分。相反，如果 C 是 X 的划分，则如果 X 的任意两个元素属于相同的等价类，则成立的关系是由划分 C 引起的等价关系。
如果 R 是 X 中的等价关系，则规范映射是将 X 的每个元素映射到其等价类的函数。
我们称有序集 (x[1], ..., x[n]) 的集合为(n 元)关系，并说该关系是 笛卡尔积 X[1] × ... × X[n] 的子集，其中 x[i] 是 X[i] 的元素，1 <= i <= n。
n 元关系 R 在坐标 i 上的投影是集合 {x[i] : (x[1], ..., x[i], ..., x[n]) 在 R 中，对于某些 x[j] in X[j]，1 <= j <= n 且不 i = j}。二元关系 R 在第一和第二坐标上的投影分别是 R 的定义域和值域。
二元关系的相对积可以推广到 n 元关系，如下所示。令 TR 为从 X 到 Y[i] 的二元关系的有序集 (R[1], ..., R[n])，而 S 为从 (Y[1] × ... × Y[n]) 到 Z 的二元关系。TR 和 S 的相对积是从 X 到 Z 的二元关系 T，定义为当且仅当对于每个 1 <= i <= n，在 Y[i] 中存在一个元素 y[i]，使得 x R[i] y[i] 并且 (y[1], ..., y[n]) S z 时，x T z。现在令 TR 为从 X[i] 到 Y[i] 的二元关系的有序集 (R[1], ..., R[n])，而 S 为 X[1] × ... × X[n] 的子集。TR 和 S 的多重相对积定义为集合 {z : z = ((x[1], ..., x[n]), (y[1],...,y[n])) 对于某些 (x[1], ..., x[n]) in S 和某些 (x[i], y[i]) 在 R[i] 中，1 <= i <= n}。
n 元关系 R 和 m 元关系 S 在坐标 i 和 j 上的自然连接定义为集合 {z : z = (x[1], ..., x[n], y[1], ..., y[j-1], y[j+1], ..., y[m]) 对于某些 (x[1], ..., x[n]) in R 和某些 (y[1], ..., y[m]) in S，使得 x[i] = y[j]}。
此模块识别的集合由关系 Sets 的元素表示，该关系定义为最小集合，使得
- 对于每个原子 T，除了 '_'，以及每个项 X，(T, X) 属于 Sets（原子集合）。
- (['_'], []) 属于 Sets（无类型空集）。
- 对于每个元组 T = {T[1], ..., T[n]} 和每个元组 X = {X[1], ..., X[n]}，如果对于每个 1 <= i <= n，(T[i], X[i]) 属于 Sets，则 (T, X) 属于 Sets（有序集合）。
- 对于每个项 T，如果 X 是空列表或一个不包含重复元素的非空排序列表 [X[1], ..., X[n]]，并且对于每个 1 <= i <= n，(T, X[i]) 属于 Sets，则 ([T], X) 属于 Sets（类型化的无序集合）。
一个外部集合是 Sets 的值域中的一个元素。
一个类型是 Sets 的定义域中的一个元素。
如果 S 是 Sets 的一个元素 (T, X)，则 T 是 X 的一个有效类型，T 是 S 的类型，X 是 S 的外部集合。
from_term/2从一个类型和一个转换为外部集合的 Erlang 项创建一个集合。由 Sets 表示的集合是函数 Set 从 Sets 到 Erlang 项和 Erlang 项集合的值域的元素。
- Set(T,Term) = Term，其中 T 是一个原子。
- Set({T[1], ..., T[n]}, {X[1], ..., X[n]}) = (Set(T[1], X[1]), ..., Set(T[n], X[n]))
- Set([T], [X[1], ..., X[n]]) = {Set(T, X[1]), ..., Set(T, X[n])}
- Set([T], []) = {}
当没有混淆的风险时，Sets 的元素与其表示的集合等同。例如，如果 U 是以 S1 和 S2 作为参数调用
union/2的结果，则称 U 为 S1 和 S2 的并集。更精确的表达是 Set(U) 是 Set(S1) 和 Set(S2) 的并集。
这些类型用于实现集合必须满足的各种条件。举例来说，考虑两个集合 R 和 S 的相对乘积，回想一下，如果 R 是到 Y 的二元关系，而 S 是从 Y 出发的二元关系，则定义 R 和 S 的相对乘积。实现相对乘积的函数 relative_product/2，通过将 [{A,B}] 与第一个参数（例如 Arg1）的类型匹配，将 [{C,D}] 与第二个参数（例如 Arg2）的类型匹配，来检查参数是否表示二元关系。[{A,B}] 与 Arg1 的类型匹配这一事实被解释为 Arg1 表示从 X 到 Y 的二元关系，其中 X 定义为所有 Set(x) 集合，其中 x 是 Sets 中的某个元素，其类型为 A，Y 也类似。同样，Arg2 被解释为表示从 W 到 Z 的二元关系。最后，检查 B 是否与 C 匹配，这足以确保 W 等于 Y。未类型化的空集会单独处理：它的类型 ['_'] 与任何无序集合的类型匹配。
此模块的一些函数（drestriction/3、family_projection/2、partition/2、partition_family/2、projection/2、restriction/3、substitution/2）接受 Erlang 函数作为修改给定无序集合的每个元素的方法。 这样的函数（以下称为 SetFun）可以指定为函数对象 (fun)、元组 {external, Fun} 或整数。
- 如果 SetFun 指定为 fun，则该 fun 将应用于给定集合的每个元素，并且返回值被假定为一个集合。
- 如果 SetFun 指定为元组
{external, Fun}，则 Fun 将应用于给定集合的每个元素的外部集合，并且返回值被假定为一个外部集合。在当前实现中，将无序集合的元素选择为外部集合并从外部集合列表组装一个新的无序集合，比修改每个元素作为集合更有效。但是，只有当无序集合的元素是原子或有序集合时，才能使用此优化。还必须满足以下条件：元素的类型与 Fun 的某个子句匹配（创建的集合的类型是将 Fun 应用于给定集合的类型的结果），并且 Fun 除了选择、复制或重新排列元素的各个部分外，什么都不做。 - 将 SetFun 指定为整数 I 等同于指定
{external, fun(X) -> element(I, X) end}，但最好使用整数 I，因为它使得可以更有效地处理这种情况。
SetFun 的示例
fun sofs:union/1
fun(S) -> sofs:partition(1, S) end
{external, fun(A) -> A end}
{external, fun({A,_,C}) -> {C,A} end}
{external, fun({_,{_,C}}) -> C end}
{external, fun({_,{_,{_,E}=C}}) -> {E,{E,C}} end}
2SetFun 应用于无序集合元素的顺序没有指定，并且可能会在此模块的未来版本中更改。
此模块函数的执行时间主要取决于对列表进行排序的时间。当不需要排序时，执行时间在最坏情况下与输入参数和返回值的总大小成正比。一些函数以恒定时间执行：from_external/2、is_empty_set/1、is_set/1、is_sofs_set/1、to_external/1、type/1。
当给定格式错误的参数或类型不兼容的集合时，此模块的函数会使用 badarg、bad_function 或 type_mismatch 消息退出进程。
比较外部集合时，使用运算符 ==/2。
另请参阅
摘要
函数
返回包含元素 (E, Set) 的二元关系，其中 Set 属于 SetOfSets，E 属于 Set。
返回函数 Function1 和 Function2 的复合。
创建一个 函数，该函数将集合 Set 的每个元素映射到 AnySet。
返回二元关系 BinRel1 的逆。
返回集合 Set1 和 Set2 的差集。
返回二元关系 BinRel 的域。
返回二元关系 BinRel1 与 BinRel1 在 Set 上的限制之间的差集。
返回 Set1 的一个子集，其中包含那些不产生 Set2 中元素的元素（应用 SetFun 的结果）。
创建一个子集族。如果结果是一个族，则 family(F, T) 等效于 from_term(F, T)。
如果 Family1 和 Family2 是族，则 Family3 是一个族，其索引集等于 Family1 的索引集，如果 Family2 映射了 i，则 Family3[i] 是 Family1[i] 和 Family2[i] 之间的差集，否则为 Family1[i]。
如果 Family1 和 Family2 是族，那么 Family3 是一个族，其索引集是 Family1 和 Family2 的索引集的交集，并且 Family3[i] 是 Family1[i] 和 Family2[i] 的交集。
如果 Family1 是一个族，那么 Family2 是一个与 Family1 具有相同索引集的族，使得 Family2[i] 是以 Family1[i] 为参数调用 SetFun 的结果。
从族 Family 创建一个有向图。对于 Family 的每个对 (a, {b[1], ..., b[n]})，顶点 a 和边 (a, b[i]) (1 <= i <= n) 被添加到新创建的有向图中。
如果 Family 是一个族，那么 BinRel 是一个二元关系，包含所有 (i, x) 对，其中 i 属于 Family 的索引集，x 属于 Family[i]。
如果 Family1 和 Family2 是族，那么 Family3 是一个族，其索引集是 Family1 和 Family2 的索引集的并集，并且如果 i 在两者中都有映射，则 Family3[i] 是 Family1[i] 和 Family2[i] 的并集，否则为 Family1[i] 或 Family2[i]。
返回二元关系 BinRel 的域。
返回包含列表 ListOfSets 的集合的无序集合。
返回在二元关系 BinRel 下集合 Set1 的像。
返回集合的集合 SetOfSets 的交集。
返回 Set1 和 Set2 的交集。
返回族 Family 的交集。
返回函数 Function1 的逆。
返回在二元关系 BinRel 下 Set1 的逆像。
如果二元关系 BinRel 是一个函数或无类型空集，则返回 true，否则返回 false。
如果 Set1 和 Set2 是不相交的，则返回 true，否则返回 false。
如果 AnySet 是一个空无序集合，则返回 true，否则返回 false。
如果 AnySet1 和 AnySet2 相等，则返回 true，否则返回 false。下面的例子表明，在比较集合是否相等时，使用 ==/2
如果 AnySet 看起来是一个无序集合，则返回 true，如果 AnySet 是一个有序集合、原子集合或任何其他项，则返回 false。
如果 Term 看起来是一个无序集合、一个有序集合或一个原子集合，则返回 true，否则返回 false。
如果 Set1 是 Set2 的子集，则返回 true，否则返回 false。
如果项 Term 是一个类型，则返回 true。
返回关系 Relation1 和 Relation2 在坐标 I 和 J 上的自然连接。
如果 TupleOfBinRels 是一个非空二元关系元组 {R[1], ..., R[n]}，并且 BinRel1 是一个二元关系，那么 BinRel2 是有序集合 (R[i], ..., R[n]) 和 BinRel1 的多次相对乘积。
返回有序或无序集合 ASet 的元素数量。
返回集合的集合 SetOfSets 的并集的划分，其中如果两个元素属于 SetOfSets 的相同元素，则认为它们是相等的。
返回 Set 的划分，其中如果应用 SetFun 的结果相等，则认为两个元素是相等的。
返回一对集合，它们被视为构成集合，形成 Set1 的一个划分。如果将 SetFun 应用于 Set1 的一个元素的结果给出了 Set2 中的一个元素，则该元素属于 Set3，否则该元素属于 Set4。
返回非空集合元组 TupleOfSets 的笛卡尔积。如果 (x[1], ..., x[n]) 是 n 元关系 Relation 的一个元素，那么 x[i] 是从 TupleOfSets 的元素 i 中提取的。
返回 Set1 和 Set2 的笛卡尔积。
返回通过将 Set1 的每个元素替换为将 SetFun 应用于该元素的结果而创建的集合。
返回二元关系 BinRel 的值域。
等效于 relation(Tuples, Type)，其中 Type 使用 Tuples 的第一个元组的大小（如果存在这样的元组）。
创建一个关系。如果 T 是一个类型且结果是一个关系，则 relation(R, T) 等效于 from_term(R, T)。
如果 ListOfBinRels 是一个非空二元关系列表 [R[1], ..., R[n]] 且 BinRel1 是一个二元关系，那么 BinRel2 是有序集合 (R[i], ..., R[n]) 和 BinRel1 的相对乘积。
返回二元关系 BinRel1 在 Set 上的限制。
返回 Set1 的子集，该子集包含那些将 SetFun 应用后，结果在 Set2 中的元素。
创建一个无序集合。set(L, T) 等价于 from_term(L, T)，如果结果是一个无序集合。
返回一个集合，其中包含 Set1 中每个 Fun 返回 true 的元素。如果 Fun 是一个元组 {external, Fun2}，则 Fun2 应用于每个元素的外部集合，否则 Fun 应用于每个元素。
返回对应于二元关系 BinRel1 的严格关系。
返回一个函数，其定义域为 Set1。定义域中元素的值是将 SetFun 应用于该元素的结果。
返回 Set1 和 Set2 的对称差（或布尔和）。
返回一个三元集合组
返回原子集合、有序集合或无序集合的外部集合。
返回有序集合 ASet 的元素作为集合的元组，并返回无序集合 ASet 的元素作为排序后的无重复集合列表。
返回原子集合、有序集合或无序集合的类型。
返回集合的集合 SetOfSets 的并集。
返回 Set1 和 Set2 的并集。
返回族 Family 的并集。
类型
-type a_function() :: relation().
一个 函数。
-opaque a_set()
一个 无序集合。
任何类型的集合（也包括原子集合）。
-type binary_relation() :: relation().
一个 二元关系。
-type external_set() :: term().
一个 外部集合。
-type family() :: a_function().
一个 族（子集的族）。
-opaque ordset()
一个 有序集合。
-type relation() :: a_set().
一个 n 元关系。
-type set_fun() :: pos_integer() | {external, fun((external_set()) -> external_set())} | fun((anyset()) -> anyset()).
一个 SetFun。
-type set_of_sets() :: a_set().
一个由无序集合组成的 无序集合。
-type spec_fun() :: {external, fun((external_set()) -> boolean())} | fun((anyset()) -> boolean()).
-type tuple_of(_T) :: tuple().
一个元素类型为 T 的元组。
-type type() :: term().
一个 类型。
函数
-spec a_function(Tuples) -> Function when Function :: a_function(), Tuples :: [tuple()].
-spec a_function(Tuples, Type) -> Function when Function :: a_function(), Tuples :: [tuple()], Type :: type().
创建一个函数。
a_function(F, T) 等价于 from_term(F, T)，如果结果是一个函数。
-spec canonical_relation(SetOfSets) -> BinRel when BinRel :: binary_relation(), SetOfSets :: set_of_sets().
返回包含元素 (E, Set) 的二元关系，其中 Set 属于 SetOfSets，E 属于 Set。
如果 SetOfSets 是集合 X 的一个划分，并且 R 是由 SetOfSets 诱导的 X 中的等价关系，则返回的关系是从 X 到关于 R 的等价类的规范映射。
1> Ss = sofs:from_term([[a,b],[b,c]]),
CR = sofs:canonical_relation(Ss),
sofs:to_external(CR).
[{a,[a,b]},{b,[a,b]},{b,[b,c]},{c,[b,c]}]-spec composite(Function1, Function2) -> Function3 when Function1 :: a_function(), Function2 :: a_function(), Function3 :: a_function().
返回函数 Function1 和 Function2 的复合。
1> F1 = sofs:a_function([{a,1},{b,2},{c,2}]),
F2 = sofs:a_function([{1,x},{2,y},{3,z}]),
F = sofs:composite(F1, F2),
sofs:to_external(F).
[{a,x},{b,y},{c,y}]-spec constant_function(Set, AnySet) -> Function when AnySet :: anyset(), Function :: a_function(), Set :: a_set().
创建一个 函数，该函数将集合 Set 的每个元素映射到 AnySet。
1> S = sofs:set([a,b]),
E = sofs:from_term(1),
R = sofs:constant_function(S, E),
sofs:to_external(R).
[{a,1},{b,1}]-spec converse(BinRel1) -> BinRel2 when BinRel1 :: binary_relation(), BinRel2 :: binary_relation().
返回二元关系 BinRel1 的逆。
1> R1 = sofs:relation([{1,a},{2,b},{3,a}]),
R2 = sofs:converse(R1),
sofs:to_external(R2).
[{a,1},{a,3},{b,2}]返回集合 Set1 和 Set2 的差集。
-spec digraph_to_family(Graph) -> Family when Graph :: digraph:graph(), Family :: family().
-spec digraph_to_family(Graph, Type) -> Family when Graph :: digraph:graph(), Family :: family(), Type :: type().
从有向图 Graph 创建一个族。 Graph 的每个顶点 a 都用一个对 (a, {b[1], ..., b[n]}) 表示，其中 b[i] 是 a 的出邻居。假设 Type 是族的外部集合的有效类型。
如果 G 是一个有向图，则 G 的顶点和边与 family_to_digraph(digraph_to_family(G)) 的顶点和边相同。
-spec domain(BinRel) -> Set when BinRel :: binary_relation(), Set :: a_set().
返回二元关系 BinRel 的域。
1> R = sofs:relation([{1,a},{1,b},{2,b},{2,c}]),
S = sofs:domain(R),
sofs:to_external(S).
[1,2]-spec drestriction(BinRel1, Set) -> BinRel2 when BinRel1 :: binary_relation(), BinRel2 :: binary_relation(), Set :: a_set().
返回二元关系 BinRel1 与 BinRel1 在 Set 上的限制之间的差集。
1> R1 = sofs:relation([{1,a},{2,b},{3,c}]),
S = sofs:set([2,4,6]),
R2 = sofs:drestriction(R1, S),
sofs:to_external(R2).
[{1,a},{3,c}]-spec drestriction(SetFun, Set1, Set2) -> Set3 when SetFun :: set_fun(), Set1 :: a_set(), Set2 :: a_set(), Set3 :: a_set().
返回 Set1 的一个子集，其中包含那些不产生 Set2 中元素的元素（应用 SetFun 的结果）。
1> SetFun = {external, fun({_A,B,C}) -> {B,C} end},
R1 = sofs:relation([{a,aa,1},{b,bb,2},{c,cc,3}]),
R2 = sofs:relation([{bb,2},{cc,3},{dd,4}]),
R3 = sofs:drestriction(SetFun, R1, R2),
sofs:to_external(R3).
[{a,aa,1}]drestriction(F, S1, S2) 等价于 difference(S1, restriction(F, S1, S2))。
-spec empty_set() -> Set when Set :: a_set().
-spec extension(BinRel1, Set, AnySet) -> BinRel2 when AnySet :: anyset(), BinRel1 :: binary_relation(), BinRel2 :: binary_relation(), Set :: a_set().
返回 BinRel1 的扩展，使得对于 Set 中每个不属于 BinRel1 域的元素 E，BinRel2 包含对 (E, AnySet)。
1> S = sofs:set([b,c]),
A = sofs:empty_set(),
R = sofs:family([{a,[1,2]},{b,[3]}]),
X = sofs:extension(R, S, A),
sofs:to_external(X).
[{a,[1,2]},{b,[3]},{c,[]}]创建一个子集族。如果结果是一个族，则 family(F, T) 等效于 from_term(F, T)。
-spec family_difference(Family1, Family2) -> Family3 when Family1 :: family(), Family2 :: family(), Family3 :: family().
如果 Family1 和 Family2 是族，则 Family3 是一个族，其索引集等于 Family1 的索引集，如果 Family2 映射了 i，则 Family3[i] 是 Family1[i] 和 Family2[i] 之间的差集，否则为 Family1[i]。
1> F1 = sofs:family([{a,[1,2]},{b,[3,4]}]),
F2 = sofs:family([{b,[4,5]},{c,[6,7]}]),
F3 = sofs:family_difference(F1, F2),
sofs:to_external(F3).
[{a,[1,2]},{b,[3]}]如果 Family1 是一个族，并且对于 Family1 的索引集中的每个 i，Family1[i] 都是一个二元关系，那么 Family2 是一个与 Family1 具有相同索引集的族，使得 Family2[i] 是 Family1[i] 的定义域。
1> FR = sofs:from_term([{a,[{1,a},{2,b},{3,c}]},{b,[]},{c,[{4,d},{5,e}]}]),
F = sofs:family_domain(FR),
sofs:to_external(F).
[{a,[1,2,3]},{b,[]},{c,[4,5]}]如果 Family1 是一个族，并且对于 Family1 的索引集中的每个 i，Family1[i] 都是一个二元关系，那么 Family2 是一个与 Family1 具有相同索引集的族，使得 Family2[i] 是 Family1[i] 的域。
1> FR = sofs:from_term([{a,[{1,a},{2,b},{3,c}]},{b,[]},{c,[{4,d},{5,e}]}]),
F = sofs:family_field(FR),
sofs:to_external(F).
[{a,[1,2,3,a,b,c]},{b,[]},{c,[4,5,d,e]}]family_field(Family1) 等价于 family_union(family_domain(Family1), family_range(Family1))。
如果 Family1 是一个族，并且对于 Family1 的索引集中的每个 i，Family1[i] 都是一个集合的集合，那么 Family2 是一个与 Family1 具有相同索引集的族，使得 Family2[i] 是 Family1[i] 的交集。
如果 Family1[i] 对于某些 i 为空集，则进程将以 badarg 消息退出。
1> F1 = sofs:from_term([{a,[[1,2,3],[2,3,4]]},{b,[[x,y,z],[x,y]]}]),
F2 = sofs:family_intersection(F1),
sofs:to_external(F2).
[{a,[2,3]},{b,[x,y]}]-spec family_intersection(Family1, Family2) -> Family3 when Family1 :: family(), Family2 :: family(), Family3 :: family().
如果 Family1 和 Family2 是族，那么 Family3 是一个族，其索引集是 Family1 和 Family2 的索引集的交集，并且 Family3[i] 是 Family1[i] 和 Family2[i] 的交集。
1> F1 = sofs:family([{a,[1,2]},{b,[3,4]},{c,[5,6]}]),
F2 = sofs:family([{b,[4,5]},{c,[7,8]},{d,[9,10]}]),
F3 = sofs:family_intersection(F1, F2),
sofs:to_external(F3).
[{b,[4]},{c,[]}]-spec family_projection(SetFun, Family1) -> Family2 when SetFun :: set_fun(), Family1 :: family(), Family2 :: family().
如果 Family1 是一个族，那么 Family2 是一个与 Family1 具有相同索引集的族，使得 Family2[i] 是以 Family1[i] 为参数调用 SetFun 的结果。
1> F1 = sofs:from_term([{a,[[1,2],[2,3]]},{b,[[]]}]),
F2 = sofs:family_projection(fun sofs:union/1, F1),
sofs:to_external(F2).
[{a,[1,2,3]},{b,[]}]如果 Family1 是一个族，并且对于 Family1 的索引集中的每个 i，Family1[i] 都是一个二元关系，那么 Family2 是一个与 Family1 具有相同索引集的族，使得 Family2[i] 是 Family1[i] 的值域。
1> FR = sofs:from_term([{a,[{1,a},{2,b},{3,c}]},{b,[]},{c,[{4,d},{5,e}]}]),
F = sofs:family_range(FR),
sofs:to_external(F).
[{a,[a,b,c]},{b,[]},{c,[d,e]}]-spec family_specification(Fun, Family1) -> Family2 when Fun :: spec_fun(), Family1 :: family(), Family2 :: family().
如果 Family1 是一个族，那么 Family2 是 Family1 的限制，只保留索引集中那些对 Family1[i] 应用 Fun 返回 true 的元素 i。如果 Fun 是一个元组 {external, Fun2}，那么 Fun2 将应用于 Family1[i] 的外部集合，否则 Fun 将应用于 Family1[i]。
1> F1 = sofs:family([{a,[1,2,3]},{b,[1,2]},{c,[1]}]),
SpecFun = fun(S) -> sofs:no_elements(S) =:= 2 end,
F2 = sofs:family_specification(SpecFun, F1),
sofs:to_external(F2).
[{b,[1,2]}]-spec family_to_digraph(Family) -> Graph when Graph :: digraph:graph(), Family :: family().
-spec family_to_digraph(Family, GraphType) -> Graph when Graph :: digraph:graph(), Family :: family(), GraphType :: [digraph:d_type()].
从族 Family 创建一个有向图。对于 Family 的每个对 (a, {b[1], ..., b[n]})，顶点 a 和边 (a, b[i]) (1 <= i <= n) 被添加到新创建的有向图中。
GraphType 将传递给 digraph:new/1。
如果 F 是一个族，则 F 是 digraph_to_family(family_to_digraph(F), type(F)) 的子集。如果 union_of_family(F) 是 domain(F) 的子集，则等式成立。
在无环图中创建循环会导致进程以 cyclic 消息退出。
-spec family_to_relation(Family) -> BinRel when Family :: family(), BinRel :: binary_relation().
如果 Family 是一个族，那么 BinRel 是一个二元关系，包含所有 (i, x) 对，其中 i 属于 Family 的索引集，x 属于 Family[i]。
1> F = sofs:family([{a,[]}, {b,[1]}, {c,[2,3]}]),
R = sofs:family_to_relation(F),
sofs:to_external(R).
[{b,1},{c,2},{c,3}]如果 Family1 是一个族，并且对于 Family1 的索引集中的每个 i，Family1[i] 都是一个集合的集合，那么 Family2 是一个与 Family1 具有相同索引集的族，使得 Family2[i] 是 Family1[i] 的并集。
1> F1 = sofs:from_term([{a,[[1,2],[2,3]]},{b,[[]]}]),
F2 = sofs:family_union(F1),
sofs:to_external(F2).
[{a,[1,2,3]},{b,[]}]-spec family_union(Family1, Family2) -> Family3 when Family1 :: family(), Family2 :: family(), Family3 :: family().
如果 Family1 和 Family2 是族，那么 Family3 是一个族，其索引集是 Family1 和 Family2 的索引集的并集，并且如果 i 在两者中都有映射，则 Family3[i] 是 Family1[i] 和 Family2[i] 的并集，否则为 Family1[i] 或 Family2[i]。
1> F1 = sofs:family([{a,[1,2]},{b,[3,4]},{c,[5,6]}]),
F2 = sofs:family([{b,[4,5]},{c,[7,8]},{d,[9,10]}]),
F3 = sofs:family_union(F1, F2),
sofs:to_external(F3).
[{a,[1,2]},{b,[3,4,5]},{c,[5,6,7,8]},{d,[9,10]}]-spec field(BinRel) -> Set when BinRel :: binary_relation(), Set :: a_set().
返回二元关系 BinRel 的域。
1> R = sofs:relation([{1,a},{1,b},{2,b},{2,c}]),
S = sofs:field(R),
sofs:to_external(S).
[1,2,a,b,c]-spec from_external(ExternalSet, Type) -> AnySet when ExternalSet :: external_set(), AnySet :: anyset(), Type :: type().
从外部集合 ExternalSet 和类型 Type 创建一个集合。假设 Type 是 ExternalSet 的一个有效类型。
-spec from_sets(ListOfSets) -> Set when Set :: a_set(), ListOfSets :: [anyset()]; (TupleOfSets) -> Ordset when Ordset :: ordset(), TupleOfSets :: tuple_of(anyset()).
返回包含列表 ListOfSets 的集合的无序集合。
1> S1 = sofs:relation([{a,1},{b,2}]),
S2 = sofs:relation([{x,3},{y,4}]),
S = sofs:from_sets([S1,S2]),
sofs:to_external(S).
[[{a,1},{b,2}],[{x,3},{y,4}]]返回包含非空元组 TupleOfSets 的集合的有序集合。
等效于 from_term(Term, '_')。
通过遍历项 Term，排序列表，删除重复项，并为获得的外部集合推导或验证一个有效类型，来创建一个 Sets 的元素。
显式指定的类型 Type 可用于限制遍历的深度；原子类型会停止遍历，如下例所示，其中 "foo" 和 {"foo"} 保持不变
1> S = sofs:from_term([{{"foo"},[1,1]},{"foo",[2,2]}],
[{atom,[atom]}]),
sofs:to_external(S).
[{{"foo"},[1]},{"foo",[2]}]from_term 可用于创建原子集合或有序集合。此类集合的唯一目的是在以后构建无序集合，因为此模块中所有执行操作的函数都在无序集合上运行。如果有序集合很大，并且不想通过重建无序集合的元素来浪费堆空间，则从有序集合的集合创建无序集合可能是一种方法。以下示例说明了如何“逐层”构建集合
1> A = sofs:from_term(a),
S = sofs:set([1,2,3]),
P1 = sofs:from_sets({A,S}),
P2 = sofs:from_term({b,[6,5,4]}),
Ss = sofs:from_sets([P1,P2]),
sofs:to_external(Ss).
[{a,[1,2,3]},{b,[4,5,6]}]其他创建集合的函数有 from_external/2 和 from_sets/1。from_term/2 的特例有 a_function/1,2、empty_set/0、family/1,2、relation/1,2 和 set/1,2。
-spec image(BinRel, Set1) -> Set2 when BinRel :: binary_relation(), Set1 :: a_set(), Set2 :: a_set().
返回在二元关系 BinRel 下集合 Set1 的像。
1> R = sofs:relation([{1,a},{2,b},{2,c},{3,d}]),
S1 = sofs:set([1,2]),
S2 = sofs:image(R, S1),
sofs:to_external(S2).
[a,b,c]-spec intersection(SetOfSets) -> Set when Set :: a_set(), SetOfSets :: set_of_sets().
返回集合的集合 SetOfSets 的交集。
对空集合的集合求交会导致进程以 badarg 消息退出。
返回 Set1 和 Set2 的交集。
返回族 Family 的交集。
对空族求交会导致进程以 badarg 消息退出。
1> F = sofs:family([{a,[0,2,4]},{b,[0,1,2]},{c,[2,3]}]),
S = sofs:intersection_of_family(F),
sofs:to_external(S).
[2]-spec inverse(Function1) -> Function2 when Function1 :: a_function(), Function2 :: a_function().
返回函数 Function1 的逆。
1> R1 = sofs:relation([{1,a},{2,b},{3,c}]),
R2 = sofs:inverse(R1),
sofs:to_external(R2).
[{a,1},{b,2},{c,3}]-spec inverse_image(BinRel, Set1) -> Set2 when BinRel :: binary_relation(), Set1 :: a_set(), Set2 :: a_set().
返回在二元关系 BinRel 下 Set1 的逆像。
1> R = sofs:relation([{1,a},{2,b},{2,c},{3,d}]),
S1 = sofs:set([c,d,e]),
S2 = sofs:inverse_image(R, S1),
sofs:to_external(S2).
[2,3]-spec is_a_function(BinRel) -> Bool when Bool :: boolean(), BinRel :: binary_relation().
如果二元关系 BinRel 是一个函数或无类型空集，则返回 true，否则返回 false。
如果 Set1 和 Set2 是不相交的，则返回 true，否则返回 false。
如果 AnySet 是一个空无序集合，则返回 true，否则返回 false。
-spec is_equal(AnySet1, AnySet2) -> Bool when AnySet1 :: anyset(), AnySet2 :: anyset(), Bool :: boolean().
如果 AnySet1 和 AnySet2 相等，则返回 true，否则返回 false。下面的例子表明，在比较集合是否相等时，使用 ==/2
1> S1 = sofs:set([1.0]),
S2 = sofs:set([1]),
sofs:is_equal(S1, S2).
true如果 AnySet 看起来是一个无序集合，则返回 true，如果 AnySet 是一个有序集合、原子集合或任何其他项，则返回 false。
请注意，此测试是浅层的，并且此函数将对与无序集合的表示形式一致的任何项返回 true。另请参阅关于数据类型的说明。
如果 Term 看起来是一个无序集合、一个有序集合或一个原子集合，则返回 true，否则返回 false。
请注意，此函数将对与 sofs 集合的表示形式一致的任何项返回 true。另请参阅关于数据类型的说明。
如果 Set1 是 Set2 的子集，则返回 true，否则返回 false。
如果项 Term 是一个类型，则返回 true。
-spec join(Relation1, I, Relation2, J) -> Relation3 when Relation1 :: relation(), Relation2 :: relation(), Relation3 :: relation(), I :: pos_integer(), J :: pos_integer().
返回关系 Relation1 和 Relation2 在坐标 I 和 J 上的自然连接。
1> R1 = sofs:relation([{a,x,1},{b,y,2}]),
R2 = sofs:relation([{1,f,g},{1,h,i},{2,3,4}]),
J = sofs:join(R1, 3, R2, 1),
sofs:to_external(J).
[{a,x,1,f,g},{a,x,1,h,i},{b,y,2,3,4}]-spec multiple_relative_product(TupleOfBinRels, BinRel1) -> BinRel2 when TupleOfBinRels :: tuple_of(BinRel), BinRel :: binary_relation(), BinRel1 :: binary_relation(), BinRel2 :: binary_relation().
如果 TupleOfBinRels 是一个非空二元关系元组 {R[1], ..., R[n]}，并且 BinRel1 是一个二元关系，那么 BinRel2 是有序集合 (R[i], ..., R[n]) 和 BinRel1 的多次相对乘积。
1> Ri = sofs:relation([{a,1},{b,2},{c,3}]),
R = sofs:relation([{a,b},{b,c},{c,a}]),
MP = sofs:multiple_relative_product({Ri, Ri}, R),
sofs:to_external(sofs:range(MP)).
[{1,2},{2,3},{3,1}]-spec no_elements(ASet) -> NoElements when ASet :: a_set() | ordset(), NoElements :: non_neg_integer().
返回有序或无序集合 ASet 的元素数量。
-spec partition(SetOfSets) -> Partition when SetOfSets :: set_of_sets(), Partition :: a_set().
返回集合的集合 SetOfSets 的并集的划分，其中如果两个元素属于 SetOfSets 的相同元素，则认为它们是相等的。
1> Sets1 = sofs:from_term([[a,b,c],[d,e,f],[g,h,i]]),
Sets2 = sofs:from_term([[b,c,d],[e,f,g],[h,i,j]]),
P = sofs:partition(sofs:union(Sets1, Sets2)),
sofs:to_external(P).
[[a],[b,c],[d],[e,f],[g],[h,i],[j]]-spec partition(SetFun, Set) -> Partition when SetFun :: set_fun(), Partition :: a_set(), Set :: a_set().
返回 Set 的划分，其中如果应用 SetFun 的结果相等，则认为两个元素是相等的。
1> Ss = sofs:from_term([[a],[b],[c,d],[e,f]]),
SetFun = fun(S) -> sofs:from_term(sofs:no_elements(S)) end,
P = sofs:partition(SetFun, Ss),
sofs:to_external(P).
[[[a],[b]],[[c,d],[e,f]]]-spec partition(SetFun, Set1, Set2) -> {Set3, Set4} when SetFun :: set_fun(), Set1 :: a_set(), Set2 :: a_set(), Set3 :: a_set(), Set4 :: a_set().
返回一对集合，它们被视为构成集合，形成 Set1 的一个划分。如果将 SetFun 应用于 Set1 的一个元素的结果给出了 Set2 中的一个元素，则该元素属于 Set3，否则该元素属于 Set4。
1> R1 = sofs:relation([{1,a},{2,b},{3,c}]),
S = sofs:set([2,4,6]),
{R2,R3} = sofs:partition(1, R1, S),
{sofs:to_external(R2),sofs:to_external(R3)}.
{[{2,b}],[{1,a},{3,c}]}partition(F, S1, S2) 等价于 {restriction(F, S1, S2), drestriction(F, S1, S2)}。
-spec partition_family(SetFun, Set) -> Family when Family :: family(), SetFun :: set_fun(), Set :: a_set().
返回族 Family，其中索引集合是 Set 的一个划分，其中如果应用 SetFun 的结果是相同的值 i，则认为两个元素是相等的。此 i 是 Family 映射到等价类的索引。
1> S = sofs:relation([{a,a,a,a},{a,a,b,b},{a,b,b,b}]),
SetFun = {external, fun({A,_,C,_}) -> {A,C} end},
F = sofs:partition_family(SetFun, S),
sofs:to_external(F).
[{{a,a},[{a,a,a,a}]},{{a,b},[{a,a,b,b},{a,b,b,b}]}]-spec product(TupleOfSets) -> Relation when Relation :: relation(), TupleOfSets :: tuple_of(a_set()).
返回非空集合元组 TupleOfSets 的笛卡尔积。如果 (x[1], ..., x[n]) 是 n 元关系 Relation 的一个元素，那么 x[i] 是从 TupleOfSets 的元素 i 中提取的。
1> S1 = sofs:set([a,b]),
S2 = sofs:set([1,2]),
S3 = sofs:set([x,y]),
P3 = sofs:product({S1,S2,S3}),
sofs:to_external(P3).
[{a,1,x},{a,1,y},{a,2,x},{a,2,y},{b,1,x},{b,1,y},{b,2,x},{b,2,y}]-spec product(Set1, Set2) -> BinRel when BinRel :: binary_relation(), Set1 :: a_set(), Set2 :: a_set().
返回 Set1 和 Set2 的笛卡尔积。
1> S1 = sofs:set([1,2]),
S2 = sofs:set([a,b]),
R = sofs:product(S1, S2),
sofs:to_external(R).
[{1,a},{1,b},{2,a},{2,b}]返回通过将 Set1 的每个元素替换为将 SetFun 应用于该元素的结果而创建的集合。
如果 SetFun 是一个数字 i >= 1，并且 Set1 是一个关系，则返回的集合是 Set1 在坐标 i 上的投影。
1> S1 = sofs:from_term([{1,a},{2,b},{3,a}]),
S2 = sofs:projection(2, S1),
sofs:to_external(S2).
[a,b]-spec range(BinRel) -> Set when BinRel :: binary_relation(), Set :: a_set().
返回二元关系 BinRel 的值域。
1> R = sofs:relation([{1,a},{1,b},{2,b},{2,c}]),
S = sofs:range(R),
sofs:to_external(S).
[a,b,c]等效于 relation(Tuples, Type)，其中 Type 使用 Tuples 的第一个元组的大小（如果存在这样的元组）。
如果 tuples 为 []，则 Type 为 2。
-spec relation(Tuples, Type) -> Relation when N :: integer(), Type :: N | type(), Relation :: relation(), Tuples :: [tuple()].
创建一个关系。如果 T 是一个类型且结果是一个关系，则 relation(R, T) 等效于 from_term(R, T)。
如果 Type 是一个整数 N，则 [{atom, ..., atom}])，其中元组大小为 N，将用作关系的类型。
-spec relation_to_family(BinRel) -> Family when Family :: family(), BinRel :: binary_relation().
返回族 Family，使得索引集等于二元关系 BinRel 的定义域，并且 Family[i] 是 i 的集合在 BinRel 下的像。
1> R = sofs:relation([{b,1},{c,2},{c,3}]),
F = sofs:relation_to_family(R),
sofs:to_external(F).
[{b,[1]},{c,[2,3]}]-spec relative_product1(BinRel1, BinRel2) -> BinRel3 when BinRel1 :: binary_relation(), BinRel2 :: binary_relation(), BinRel3 :: binary_relation().
返回二元关系 BinRel1 的逆和二元关系 BinRel2 的相对乘积。
1> R1 = sofs:relation([{1,a},{1,aa},{2,b}]),
R2 = sofs:relation([{1,u},{2,v},{3,c}]),
R3 = sofs:relative_product1(R1, R2),
sofs:to_external(R3).
[{a,u},{aa,u},{b,v}]relative_product1(R1, R2) 等价于 relative_product(converse(R1), R2)。
-spec relative_product(ListOfBinRels) -> BinRel2 when ListOfBinRels :: [BinRel, ...], BinRel :: binary_relation(), BinRel2 :: binary_relation().
等效于 relative_product/2。
-spec relative_product(ListOfBinRels, BinRel1) -> BinRel2 when ListOfBinRels :: [BinRel, ...], BinRel :: binary_relation(), BinRel1 :: binary_relation(), BinRel2 :: binary_relation(); (BinRel1, BinRel2) -> BinRel3 when BinRel1 :: binary_relation(), BinRel2 :: binary_relation(), BinRel3 :: binary_relation().
如果 ListOfBinRels 是一个非空二元关系列表 [R[1], ..., R[n]] 且 BinRel1 是一个二元关系，那么 BinRel2 是有序集合 (R[i], ..., R[n]) 和 BinRel1 的相对乘积。
如果省略 BinRel1，则使用 R[i] 范围的笛卡尔积的元素之间的等式关系，即 range R[1] × ... × range R[n]（直观上，不会“丢失”任何内容）。
1> TR = sofs:relation([{1,a},{1,aa},{2,b}]),
R1 = sofs:relation([{1,u},{2,v},{3,c}]),
R2 = sofs:relative_product([TR, R1]),
sofs:to_external(R2).
[{1,{a,u}},{1,{aa,u}},{2,{b,v}}]请注意，relative_product([R1], R2) 与 relative_product(R1, R2) 不同；一个元素的列表与元素本身不相同。
返回二元关系 BinRel1 和 BinRel2 的相对乘积。
-spec restriction(BinRel1, Set) -> BinRel2 when BinRel1 :: binary_relation(), BinRel2 :: binary_relation(), Set :: a_set().
返回二元关系 BinRel1 在 Set 上的限制。
1> R1 = sofs:relation([{1,a},{2,b},{3,c}]),
S = sofs:set([1,2,4]),
R2 = sofs:restriction(R1, S),
sofs:to_external(R2).
[{1,a},{2,b}]-spec restriction(SetFun, Set1, Set2) -> Set3 when SetFun :: set_fun(), Set1 :: a_set(), Set2 :: a_set(), Set3 :: a_set().
返回 Set1 的子集，该子集包含那些将 SetFun 应用后，结果在 Set2 中的元素。
1> S1 = sofs:relation([{1,a},{2,b},{3,c}]),
S2 = sofs:set([b,c,d]),
S3 = sofs:restriction(2, S1, S2),
sofs:to_external(S3).
[{2,b},{3,c}]等价于 set(Terms, [atom])。
创建一个无序集合。set(L, T) 等价于 from_term(L, T)，如果结果是一个无序集合。
返回一个集合，其中包含 Set1 中每个 Fun 返回 true 的元素。如果 Fun 是一个元组 {external, Fun2}，则 Fun2 应用于每个元素的外部集合，否则 Fun 应用于每个元素。
1> R1 = sofs:relation([{a,1},{b,2}]),
R2 = sofs:relation([{x,1},{x,2},{y,3}]),
S1 = sofs:from_sets([R1,R2]),
S2 = sofs:specification(fun sofs:is_a_function/1, S1),
sofs:to_external(S2).
[[{a,1},{b,2}]]-spec strict_relation(BinRel1) -> BinRel2 when BinRel1 :: binary_relation(), BinRel2 :: binary_relation().
返回对应于二元关系 BinRel1 的严格关系。
1> R1 = sofs:relation([{1,1},{1,2},{2,1},{2,2}]),
R2 = sofs:strict_relation(R1),
sofs:to_external(R2).
[{1,2},{2,1}]-spec substitution(SetFun, Set1) -> Set2 when SetFun :: set_fun(), Set1 :: a_set(), Set2 :: a_set().
返回一个函数，其定义域为 Set1。定义域中元素的值是将 SetFun 应用于该元素的结果。
1> L = [{a,1},{b,2}].
[{a,1},{b,2}]
2> sofs:to_external(sofs:projection(1,sofs:relation(L))).
[a,b]
3> sofs:to_external(sofs:substitution(1,sofs:relation(L))).
[{{a,1},a},{{b,2},b}]
4> SetFun = {external, fun({A,_}=E) -> {E,A} end},
sofs:to_external(sofs:projection(SetFun,sofs:relation(L))).
[{{a,1},a},{{b,2},b}]{a,b,c} 元素之间的相等关系
1> I = sofs:substitution(fun(A) -> A end, sofs:set([a,b,c])),
sofs:to_external(I).
[{a,a},{b,b},{c,c}]设 SetOfSets 是一个集合的集合，BinRel 是一个二元关系。以下函数返回将 SetOfSets 的每个元素 Set 映射到 Set 在 BinRel 下的像的函数
images(SetOfSets, BinRel) ->
Fun = fun(Set) -> sofs:image(BinRel, Set) end,
sofs:substitution(Fun, SetOfSets).外部无序集合表示为排序列表。因此，创建集合在关系 R 下的像可以遍历 R 的所有元素（由此产生结果的排序，即像）。在 image/2 中，BinRel 对于 SetOfSets 的每个元素遍历一次，这可能需要太长时间。如果在 BinRel 下 SetOfSets 的每个元素的像都非空，则可以使用以下高效函数代替
images2(SetOfSets, BinRel) ->
CR = sofs:canonical_relation(SetOfSets),
R = sofs:relative_product1(CR, BinRel),
sofs:relation_to_family(R).返回 Set1 和 Set2 的对称差（或布尔和）。
1> S1 = sofs:set([1,2,3]),
S2 = sofs:set([2,3,4]),
P = sofs:symdiff(S1, S2),
sofs:to_external(P).
[1,4]-spec symmetric_partition(Set1, Set2) -> {Set3, Set4, Set5} when Set1 :: a_set(), Set2 :: a_set(), Set3 :: a_set(), Set4 :: a_set(), Set5 :: a_set().
返回一个三元集合组
Set3包含Set1中不属于Set2的元素。Set4包含Set1中属于Set2的元素。Set5包含Set2中不属于Set1的元素。
-spec to_external(AnySet) -> ExternalSet when ExternalSet :: external_set(), AnySet :: anyset().
返回原子集合、有序集合或无序集合的外部集合。
-spec to_sets(ASet) -> Sets when ASet :: a_set() | ordset(), Sets :: tuple_of(AnySet) | [AnySet], AnySet :: anyset().
返回有序集合 ASet 的元素作为集合的元组，并返回无序集合 ASet 的元素作为排序后的无重复集合列表。
返回原子集合、有序集合或无序集合的类型。
-spec union(SetOfSets) -> Set when Set :: a_set(), SetOfSets :: set_of_sets().
返回集合的集合 SetOfSets 的并集。
返回 Set1 和 Set2 的并集。
返回族 Family 的并集。
1> F = sofs:family([{a,[0,2,4]},{b,[0,1,2]},{c,[2,3]}]),
S = sofs:union_of_family(F),
sofs:to_external(S).
[0,1,2,3,4]-spec weak_relation(BinRel1) -> BinRel2 when BinRel1 :: binary_relation(), BinRel2 :: binary_relation().
返回对应于二元关系 BinRel1 的弱关系 W 的子集 S。设 F 是 BinRel1 的域。子集 S 的定义方式是，如果对于 F 中的某个 x 和 F 中的某个 y，x W y，则 x S y。
1> R1 = sofs:relation([{1,1},{1,2},{3,1}]),
R2 = sofs:weak_relation(R1),
sofs:to_external(R2).
[{1,1},{1,2},{2,2},{3,1},{3,3}]