檢視原始碼 sofs (stdlib v6.2)
用於操作集合的集合的函式。
此模組提供對有限集合和以集合表示的關係的操作。直觀來說，集合是元素的集合；每個元素都屬於該集合，且該集合包含每個元素。
此模組使用的代表 sofs 的資料應被其他模組視為不透明。在抽象術語中，表示法是現有 Erlang 項的複合類型。請參閱關於資料類型的注意事項。任何假設了解格式的程式碼都如同在薄冰上行走。
給定一個集合 A 和一個句子 S(x)，其中 x 是一個自由變數，可以形成一個新的集合 B，其元素恰好是 A 中滿足 S(x) 的那些元素，這表示為 B = {x 在 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 在 X 中，且對於某些 y 在 Y 中}。
關係是 X × Y 的子集。令 R 為一個關係。事實 (x, y) 屬於 R 寫成 x R y。由於關係是集合，因此最後一個項目（子集、聯集等等）的定義也適用於關係。
R 的定義域是集合 {x : 對於某些 y 在 Y 中，x R y}。
R 的值域是集合 {y : 對於某些 x 在 X 中，x R y}。
R 的逆關係是集合 {a : a = (y, x)，對於某些 (x, y) 在 R 中}。
如果 A 是 X 的子集，則 A 在 R 下的像是集合 {y : 對於某些 x 在 A 中，x R y}。如果 B 是 Y 的子集，則 B 的逆像是集合 {x : 對於某些 y 在 B 中，x R y}。
如果 R 是從 X 到 Y 的關係，而 S 是從 Y 到 Z 的關係，則 R 和 S 的相對乘積是從 X 到 Z 的關係 T，其定義為 x T z 若且唯若在 Y 中存在一個元素 y，使得 x R y 且 y S z。
R 對 A 的限制是集合 S，其定義為 x S y 若且唯若在 A 中存在一個元素 x，使得 x R y。
如果 S 是 R 對 A 的限制，則 R 是 S 對 X 的擴展。
如果 X = Y，則 R 稱為 in X 的關係。
X 中關係 R 的域是 R 的定義域和 R 的值域的聯集。
如果 R 是 X 中的關係，且如果 S 的定義為 x S y 如果 x R y 且非 x = y，則 S 是對應於 R 的嚴格關係。相反地，如果 S 是 X 中的關係，且如果 R 的定義為 x R y 如果 x S y 或 x = 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) 在 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[j] 在 X[j] 中，(x[1], ..., x[i], ..., x[n]) 在 R 中，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，其定義為 x T z 若且唯若對於每個 1 <= i <= n，在 Y[i] 中存在一個元素 y[i]，使得 x R[i] y[i] 且 (y[1], ..., y[n]) S 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]) 在 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]) 在 R 中，且對於某些 (y[1], ..., y[m]) 在 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 表示的集合是從 Sets 到 Erlang 項和 Erlang 項集合的函數 Set 的值域中的元素
- 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) 集合，對於某些類型為 A 的 Sets 中的元素 x，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}，但建議使用，因為這樣可以更有效率地處理這種情況。
SetFuns 的範例
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 的子集，其中包含那些將 SetFun 應用後，不會在 Set2 中產生元素的元素。
建立子集族系。family(F, T) 等同於 from_term(F, T)，如果結果是族系。
如果 Family1 和 Family2 是族系，則 Family3 是族系，使得索引集合等於 Family1 的索引集合，並且 Family3[i] 是 Family1[i] 和 Family2[i] 之間的差集（如果 Family2 對應 i 的話），否則為 Family1[i]。
如果 Family1 和 Family2 是family，那麼 Family3 是一個 family，其索引集合是 Family1 和 Family2 的索引集合的交集，且 Family3[i] 是 Family1[i] 和 Family2[i] 的交集。
如果 Family1 是一個family，那麼 Family2 是一個與 Family1 具有相同索引集合的 family，使得 Family2[i] 是以 Family1[i] 作為參數呼叫 SetFun 的結果。
從family Family 建立一個有向圖。對於 Family 的每個配對 (a, {b[1], ..., b[n]})，頂點 a 和邊 (a, b[i])，其中 1 <= i <= n，會被加入到新建立的有向圖中。
如果 Family 是一個family，那麼 BinRel 是一個二元關係，包含所有 (i, x) 配對，其中 i 屬於 Family 的索引集合，且 x 屬於 Family[i]。
如果 Family1 和 Family2 是family，那麼 Family3 是一個 family，其索引集合是 Family1 和 Family2 的索引集合的聯集，且 Family3[i] 是 Family1[i] 和 Family2[i] 的聯集（如果兩者都映射 i），否則為 Family1[i] 或 Family2[i]。
回傳二元關係 BinRel 的範圍。
回傳包含列表 ListOfSets 中集合的無序集合。
回傳集合 Set1 在二元關係 BinRel 下的像。
回傳集合的集合 SetOfSets 的交集。
回傳 Set1 和 Set2 的交集。
回傳family Family 的交集。
回傳函數 Function1 的反函數。
回傳 Set1 在二元關係 BinRel 下的反像。
如果二元關係 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 的笛卡爾積。
回傳通過將 SetFun 應用於每個元素所產生的結果來替換 Set1 的每個元素所建立的集合。
回傳二元關係 BinRel 的值域。
等同於 relation(Tuples, Type)，其中如果存在此類元組，則 Type 使用 Tuples 的第一個元組的大小。
建立一個關係。relation(R, T) 等同於 from_term(R, T)，如果 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().
-type set_fun() :: pos_integer() | {external, fun((external_set()) -> external_set())} | fun((anyset()) -> anyset()).
-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]:s 是 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 的子集，其中包含那些將 SetFun 應用後，不會在 Set2 中產生元素的元素。
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 的索引集合，並且 Family3[i] 是 Family1[i] 和 Family2[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 是一個family，且對於 Family1 索引集合中的每個 i，Family1[i] 是一個二元關係，那麼 Family2 是一個與 Family1 具有相同索引集合的 family，使得 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 是一個family，且對於 Family1 索引集合中的每個 i，Family1[i] 是一個集合的集合，那麼 Family2 是一個與 Family1 具有相同索引集合的 family，使得 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 是family，那麼 Family3 是一個 family，其索引集合是 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 是一個family，那麼 Family2 是一個與 Family1 具有相同索引集合的 family，使得 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 是一個family，且對於 Family1 索引集合中的每個 i，Family1[i] 是一個二元關係，那麼 Family2 是一個與 Family1 具有相同索引集合的 family，使得 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 是一個family，那麼 Family2 是 Family1 的限制，只包含索引集合中那些將 Fun 應用於 Family1[i] 後回傳 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 建立一個有向圖。對於 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 是一個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 是一個family，且對於 Family1 索引集合中的每個 i，Family1[i] 是一個集合的集合，那麼 Family2 是一個與 Family1 具有相同索引集合的 family，使得 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 是family，那麼 Family3 是一個 family，其索引集合是 Family1 和 Family2 的索引集合的聯集，且 Family3[i] 是 Family1[i] 和 Family2[i] 的聯集（如果兩者都映射 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().
回傳集合 Set1 在二元關係 BinRel 下的像。
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 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().
回傳 Set1 在二元關係 BinRel 下的反像。
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 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}]回傳通過將 SetFun 應用於每個元素所產生的結果來替換 Set1 的每個元素所建立的集合。
如果 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 的第一個元組的大小。
如果元組是 []，則 Type 是 2。
-spec relation(Tuples, Type) -> Relation when N :: integer(), Type :: N | type(), Relation :: relation(), Tuples :: [tuple()].
建立一個關係。relation(R, T) 等同於 from_term(R, T)，如果 T 是一個類型且結果是一個關係。
如果 Type 是一個整數 N，則會使用 [{atom, ..., atom}])（其中元組大小為 N）作為關係的類型。
-spec relation_to_family(BinRel) -> Family when Family :: family(), BinRel :: binary_relation().
回傳family 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] 的範圍的笛卡兒積範圍 R[1] × ... × 範圍 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 的每個元素遍歷一次，這可能會花費太長時間。如果假設 SetOfSets 的每個元素在 BinRel 下的影像都是非空的，則可以使用以下高效函數。
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包含不屬於Set2的Set1的元素。Set4包含屬於Set2的Set1的元素。Set5包含不屬於Set1的Set2的元素。
-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().
傳回 弱關係 W 的子集 S，該弱關係對應於二元關係 BinRel1。令 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}]