我在这个来源中找到了一个稍微扩展的定义（其中包括一个很好的解释）。这是一个更可靠（已发布）的来源：CHARM：Mohammed J. Zaki 和 Ching-jui Hsiao 的封闭项集挖掘的有效算法。

根据这个来源：

• 如果项集的直接超集都没有与项集相同的支持，则项集是闭合的
• 一个项目集是最大频繁的，如果它的直接超集都不是频繁的


一些备注：

• 有必要设置一个min_support（支持 = 包含感兴趣的子集的项目集的数量除以所有项目集的数量），它定义了哪个项目集是频繁的。如果一个项集的支持度 >= min_support，则它是频繁的。
• 关于算法，当试图找到最大频繁项集和闭合项集时，只考虑具有 min_support 的项集。
• 封闭定义中的重要方面是，是否存在具有更多支持的直接超集并不重要，只有具有完全相同支持的直接超集才重要。
• 最大频繁 => 关闭 => 频繁，但反之则不然。

应用到 OP 的例子

笔记：

• 没有检查支持计数
• 假设 min_support=0.5。如果 min_support_count >= 3 则满足

{A} = 4; 由于 {A,E} 未关闭
{B} = 2; 不频繁 => 忽略
{C} = 5 ; 由于 {C,E} 而未关闭
{D} = 4 ; 由于 {D,E} 而没有关闭，但由于例如 {A,D} 而不是最大的
{E} = 6 ; 封闭，但不是最大的，例如 {D,E}

{A,B} = 1; 不频繁 => 忽略
{A,C} = 3; 由于 {A,C,E} 而未关闭
{A,D} = 3; 由于 {A,D,E} 未关闭
{A,E} = 4; 关闭，但由于 {A,D,E} 而不是最大值
{B,C} = 2; 不频繁 => 忽略
{B,D} = 0; 不频繁 => 忽略
{B,E} = 2; 不频繁 => 忽略
{C,D} = 3; 由于 {C,D,E} 而未关闭
{C,E} = 5; 闭合，但由于 {C,D,E} 而不是最大值
{D,E} = 4; 关闭，但由于 {A,D,E} 而不是最大值

{A,B,C} = 1; 不频繁 => 忽略
{A,B,D} = 0; 不频繁 => 忽略
{A,B,E} = 1; 不频繁 => 忽略
{A,C,D} = 2; 不频繁 => 忽略
{A,C,E} = 3; 最大频率
{A,D,E} = 3; 最大频率
{B,C,D} = 0; 不频繁 => 忽略
{B,C,E} = 2; 不频繁 => 忽略
{C,D,E} = 3; 最大频率

{A,B,C,D} = 0; 不频繁 => 忽略
{A,B,C,E} = 1; 不频繁 => 忽略
{B,C,D,E} = 0; 不频繁 => 忽略

您可能想阅读 APRIORI 算法。它通过巧妙的剪枝来避免不必要的项集。

{A} = 4 ;  {B} = 2  ; {C} = 5  ; {D} = 4  ; {E} = 6

B 不频繁，删除。

构建和计算两个项目集（还没有魔法，除了B已经出来了）

{A,C} = 3; {A,D} = 3; {A,E} = 4; 
{C,D} = 3; {C,E} = 5; {D,E} = 3

所有这些都是频繁的（请注意，所有这些都B不能是频繁的！）

现在使用前缀规则。仅组合以相同 n-1 项开头的项集。删除所有，其中任何子集都不频繁。计算剩余的项集。

{A,C,D} = 2; {A,C,E} = 3; {A,D,E} = 3; 
{C,D,E} = 3

注意{A,C,D}不频繁。由于没有共享前缀，所以不可能有更大的频繁项集！

注意我做的工作少了多少！

对于最大/封闭项集，检查子集/超集。

请注意，例如{E}=6和{A,E}=4。{E}是一个子集，但有更高的支持，即它是封闭的但不是最大的。{A}两者都不是，因为它没有比 更高的支持{A,E}，即它是多余的。