A pattern-growth approach for mining maximal fault-tolerant frequent itemsets

Abstract

Mining fault-tolerant (FT) frequent itemsets in noisy datasets is more challenging than conventional frequent itemset mining due to the high cost of evaluating fault-tolerance conditions. Consequently, mining maximal fault-tolerant frequent itemsets (FT-MFIs) is particularly important, as they provide a concise representation of all frequent patterns while eliminating redundancy, which is crucial in noisy datasets where error tolerance must be considered. Existing approaches for mining FT-MFIs are predominantly based on Apriori-style candidate generation and test, which suffer from exponential candidate growth, multiple dataset scans, and limited scalability. As a novel contribution, this work is the first to propose a pattern-growth framework for mining FT-MFIs. We introduce an algorithm that constructs a fault-tolerant FP-tree (FT-FP-tree) to compress transactions with common prefixes and evaluate tolerance conditions in a single pass. Additionally, new techniques for transaction mapping and conditional pattern extraction enhance the efficiency and scalability of the mining process. Experimental results on benchmark datasets demonstrate that the proposed approach achieves substantial reductions in execution time compared to all existing algorithms, while also showing improved memory efficiency relative to other pattern-growth based algorithms. This establishes pattern growth as a practical and scalable solution for fault-tolerant frequent itemset discovery.

Introduction

Frequent itemset mining (FIM) has long been considered one of the most fundamental problems in the broader domain of data mining ¹. The discovery of frequently co-occurring items in large datasets forms the foundation for numerous data-driven applications across a variety of fields ². For instance, FIM enables effective clustering of documents by identifying groups of terms that appear together in textual corpora^3–5. In social network analysis, itemset mining supports the detection of community structures and interaction patterns among users^6–8. Similarly, in commercial environments, market basket analysis remains one of the most well-known applications, where co-purchased products are extracted to guide cross-selling and recommendation systems^9,10. Beyond business, FIM has also been applied in several other domains. In fraud detection, it helps uncover suspicious transaction patterns^11–13. In bioinformatics, it is used to identify recurring biological markers or gene interactions^14–17. In web mining, FIM supports the analysis of usage logs to capture user navigation behavior^18–20.

The formalization of association rule learning, introduced in the foundational work of²¹, placed FIM at the core of data mining research. Since then, an extensive body of work has emerged that has focused on designing efficient algorithms for discovering frequent itemsets (patterns) in transactional datasets^22–34. Despite the maturity of this area, traditional FIM suffers from a key weakness: It assumes that frequent itemsets must be identified through exact matches within the database.

Challenges of conventional FIM

Reliance on exact matching restricts the utility of conventional FIM when applied to noisy or incomplete datasets. Real-world datasets rarely conform to clean and exact patterns due to errors, omissions, or inconsistencies in recording processes^35–38. Consequently, itemsets that should intuitively be considered frequent may be overlooked because they are not perfectly present across transactions. Furthermore, the choice of support threshold has a critical impact on the output. When the threshold is set too high, the algorithm produces only a small number of very short itemsets. In contrast, lowering the threshold leads to an explosion of trivial itemsets, especially those of length two or three^39–41. Both extremes reduce the practical usefulness of mined itemsets.

Fault-tolerant (FT) frequent itemsets mining

To overcome these issues, the concept of fault-tolerant (FT) frequent itemsets was proposed by³⁵. The key idea is to relax the rigid requirement of exact matching by introducing a tolerance factor, , that allows for the presence of noise or missing items. Under this model:

1. An itemset X qualifies as an FT frequent itemset if it is supported by at least FT transactions.

2. A transaction is said to be an FT transaction of X if it contains at least items from X.

3. Additionally, each item in X must occur in at least FT transactions of X, ensuring that tolerance does not compromise the reliability of individual items.

This formulation allows the discovery of meaningful patterns even when the dataset is imperfect. The FT parameter, , determines how many items of an itemset X are absent in a transaction while still considering that transaction as supporting X. For an itemset of length X, at least items must appear together to satisfy the FT condition. A smaller (for example, or 1) implies that only transactions with almost complete presence of all items in X are counted, corresponding to low tolerance for noise. As increases, the algorithm becomes more flexible and includes transactions where more items are missing. For instance, if and , a transaction containing any three of these items (e.g., ) still contributes to the support of X. When , even transactions containing only two items from X are counted. However, if approaches |X| (for example, for a four itemset), almost any transaction containing at least one of the items in X will qualify as a FT occurrence, reducing the discriminative power of the measure. Therefore, should be chosen carefully according to the expected noise level in the data to balance completeness and specificity. In practical settings, smaller values are suitable for relatively clean datasets, whereas larger values are beneficial when data contain omissions or measurement errors. Table 1 summarizes how different values influence both the minimum required items and the discriminative nature of the patterns. Increasing relaxes the FT constraint, allowing more partially matched itemsets to be considered frequent. Although this expands the search space, it reduces the discriminative power of the resulting patterns because fewer items are required to co-occur. Smaller values of enforce stricter matching, producing more specific and more discriminative maximal FT frequent itemsets.

Table 1.

Effect of on required items and discriminative power. X is the length of itemset.

	Minimum required items	Tolerance to missing items	Discriminative power
0	X	None	Very high
1		Low	High
2		Moderate	Medium
3		High	Low
Large	Small	Very high	Very low

To better illustrate the practical interpretation of FT frequent itemsets, consider the e-commerce transaction dataset shown in Table 2, consisting of nine shopping-cart transactions. With a minimum support threshold of , conventional exact frequent itemset mining identifies only short itemsets of length at most two (such as Laptop+Mouse or Laptop+Headphones). These short itemsets provide limited insight because real customers frequently purchase product bundles that may vary slightly from one transaction to another. When fault tolerance is introduced with , longer and more meaningful purchasing patterns emerge. For example, the itemset forms a FT frequent itemset of length four with FT-support equal to three. Transactions 10, 20, and 50 each contain at least three of these items, satisfying the FT condition that allows one item to be missing. Furthermore, each item in X appears in at least two distinct transactions, meeting the individual FT-occurrence requirement. Under exact matching, X would not be considered frequent because no transaction contains all four items simultaneously. Under FT support, however, X becomes a valid and highly informative FT frequent itemset, capturing a realistic customer purchasing pattern (a typical laptop workstation bundle). This example demonstrates that fault-tolerant mining uncovers longer, behaviorally meaningful itemsets that traditional exact FIM would entirely miss, thereby revealing richer purchasing structures in e-commerce environments.

Table 2.

Sample e-commerce transactional dataset showing items purchased and the resulting frequent items across transactions with a minimum support threshold of .

TID	Items	Frequent items
10	Keyboard, Headphones, Smartphone, Mouse	Laptop, Mouse, Headphones, Keyboard
20	Headphones, Laptop, Mouse	Laptop, Mouse, Headphones
30	Laptop Stand, Smartphone, Mouse	Mouse, Laptop Stand, Smartphone
40	Laptop, USB Adapter	Laptop
50	Laptop Stand, Keyboard, Headphones, Laptop	Laptop, Laptop Stand, Headphones, Keyboard
60	Laptop Stand, Laptop, Mouse	Laptop, Mouse, Laptop Stand
70	Keyboard, Laptop Stand, Smartphone, Mouse	Mouse, Laptop Stand, Smartphone, Keyboard
80	Smartphone, Mouse Pad, Power Bank	Smartphone
90	Smartphone, USB Cable, SD Card	Smartphone

FT frequent itemset mining is highly relevant for many real world applications where transactional records are incomplete, noisy, or imprecise. Examples include retail sales data, sensor logs, Internet of Things (IoT), web clickstreams, healthcare records ⁴², and industrial monitoring. In these domains, missing entries, intermittent sensor failures, anonymized identifiers, and recording errors are common, so methods that tolerate small amounts of noise while still extracting reliable patterns are particularly useful ^43,44. In retail, FT itemset mining can reveal robust co-purchase relationships even when some barcodes are missing or transactions are partially recorded. Such patterns support assortment planning, cross-selling, and targeted promotions by identifying groups of products that are frequently bought together despite occasional recording errors. In sensor networks and IoT deployments, FT mining can detect recurring combinations of sensor readings that indicate normal operating modes or emerging faults, even when individual sensors drop out or report noisy values. For example, a recurring pattern of temperature, vibration, and current readings can signal an incipient fault of the equipment, even if one sensor intermittently fails. In web and mobile analytics, FT itemset mining can identify stable navigation patterns or frequent sequences of actions even when some events are lost during logging or anonymized. In healthcare and clinical data, FT patterns can help find common co-occurrences of symptoms, medications, or lab results across incomplete electronic health records, supporting cohort discovery and hypothesis generation. In cyber security and fraud detection, FT patterns expose typical combinations of events that precede attacks or fraudulent transactions while tolerating gaps in noisy logs ^11–13 (Table 3).

Table 3.

Example of a transactional dataset with frequent items across transactions.

TID	Items	(Ordered) frequent items
10	c , d , e , g	f , g , d , c
20	d , f , g	f , g , d
30	b , e , g	g , b , e
40	f , l	f
50	b , c , d , f	f , b , d , c
60	b , f , g	f , g , b
70	c , b , e, g	g , b , e, c
80	e , h , j	e
90	e , i , k	e

Limitations of Apriori-based FT frequent itemset mining and main contribution

Early algorithms for mining FT frequent itemsets extended the Apriori principle, employing candidate generation and iterative testing to construct larger itemsets from smaller ones. While straightforward, this strategy faces well-known scalability issues. When support thresholds are low, the number of generated candidates grows exponentially, leading to excessive computational overhead^45–47.

To mitigate these challenges, researchers have advocated mining only long or maximal FT frequent itemsets (FT-MFIs), rather than enumerating the complete set^45,48. The appeal of this approach is twofold: (i) the number of FT-MFIs is significantly smaller than the full set of FT frequent itemsets, and (ii) FT-MFIs can still serve as a condensed representation from which all FT frequent itemsets may be derived in a post-processing step. Once derived, their supports can be computed efficiently through a single dataset scan. Nonetheless, the existing FT-MFI mining algorithms remain rooted in the Apriori paradigm. Their reliance on exhaustive candidate generation and multiple dataset scans significantly hampers performance due to following reasons.

• Apriori-based algorithms attempt to mine the complete set of FT-MFIs by generating and testing candidate itemsets. The critical weakness of this approach lies in the exponential explosion of candidates when the dataset is large. For example, if a dataset contains 300 frequent items, the Apriori-based approach theoretically generates and evaluates all candidate itemsets, which is computationally infeasible in practice.

• The search strategy used by Apriori-based algorithms is top-down, meaning that to identify a frequent itemset X, the algorithm must first generate and test all subsets of X. This exhaustive enumeration becomes highly inefficient when datasets contain a large number of single frequent items, as the number of subsets grows exponentially with itemset size.

• To validate the FT conditions for each candidate itemset, the Apriori-based algorithm requires multiple scans of the entire dataset. Each scan increases the computational cost, and when the number of candidates is exponential, these repeated scans make Apriori impractical for large-scale or sparse datasets.

To address these limitations, this article introduces a novel algorithm called FT-MFI-PG, which mines fault-tolerant maximal frequent itemsets (FT-MFIs) using a combination of pattern-growth and the FP-tree structure ^2,49. Mining FT-MFIs is more challenging than traditional maximal frequent itemset mining ²⁷. This is because the algorithm must handle additional complexity introduced by fault-tolerance. It needs to maintain and update fault-tolerant transactions (FT transactions) that partially satisfy itemsets. Additionally, the support computation must account for both exact and partial matches. The pattern-growth paradigm is particularly well suited for this task, as it combines transaction compression with localized evaluation of FT conditions. Unlike candidate generation and test approach (Apriori), which require repeated dataset scans, FT-MFI-PG constructs a compact FP-tree that merges transactions with common prefixes. This allows partially matching transactions, which may arise due to noise or missing items, to be efficiently mapped onto shared branches while preserving fault-tolerance information through the FT-FP-tree and FT conditional pattern tables (FT-CP-Tables). The divide-and-conquer strategy of pattern-growth recursively partitions the dataset into smaller conditional subsets, enabling the mining process to focus only on feasible itemsets. In addition, FT-MFI-PG prunes infeasible itemset combinations early in the search, reducing computational overhead and improving scalability compared to conventional approaches ^22,49,50.

The mining process of FT-MFI-PG can be summarized as follows:

1. In the first scan of the dataset, all one-length frequent items are identified, while items with support below are discarded.

2. A second scan maps transactions onto the FP-tree. Frequent items are stored as nodes, and transactions are mapped onto the branches. If transactions share a common prefix, the corresponding items share branches in the FP-tree. The frequency (support) of shared subsets is stored in the nodes, which results in a compact dataset representation.

3. Using depth first search, the pattern-growth explores FT-MFIs directly from the FP-tree. Supersets of an itemset are generated by constructing conditional pattern bases from FP-tree branches. Frequent items from these conditional patterns recursively build child FP-trees, from which larger FT-MFIs are discovered.

Through this recursive process, FT-MFI-PG efficiently enumerates the complete set of FT-MFIs without the exponential candidate generation and test overhead of Apriori. We conducted experiments on multiple benchmark datasets to evaluate FT-MFI-PG against existing algorithms. The results demonstrate that FT-MFI-PG mines the complete set of FT-MFIs with significantly less computational time while maintaining correctness.

The remainder of this article is organized as follows. “Related work” section provides an extensive review of related work on mining maximal and all FT frequent itemsets, highlighting differences between the proposed algorithm and existing algorithms. “Mining maximal fault-tolerant (FT) frequent itemsets: pattern-growth methodology” section introduces the mapping of FT transactions onto the FP-tree and details the integration of pattern growth for mining FT-MFIs. “Correctness and completeness of FT-MFI-PG” section presents the correctness and completeness of FT-MFI-PG. “Pruning infrequent FT-MFIs” section discusses heuristics for pruning infrequent itemsets to reduce search space. “Experiments” section describes the benchmark datasets and presents a performance comparison of FT-MFI-PG with alternative algorithms. Finally, “Conclusion” section summarizes the key findings and contributions of proposed algorithm.

Related work

The problem of mining fault-tolerant maximal frequent itemsets (FT-MFIs) has received limited attention, and only a few algorithms have been proposed to address it. Early research efforts predominantly adopted an Apriori-style search strategy ⁴⁸. Apriori-based algorithms rely on the well-known anti-monotonic property: if an itemset is infrequent, all of its supersets must also be infrequent. This heuristic effectively prunes a large portion of the search space, thereby reducing the computational overhead associated with frequent itemset mining. However, the Apriori framework generates a vast number of candidate itemsets, including many that may never occur in the transaction dataset. Each set of candidates must then be validated through repeated dataset scans, which significantly increases computational cost, especially in noisy datasets where fault tolerance must be incorporated.

³⁵ introduced one of the earliest algorithms in this category, namely FT-Apriori. This algorithm adopts a top-down, level-wise approach, where larger candidate itemsets are generated by extending previously discovered FT frequent itemsets. An itemset X is considered FT frequent if its minimum support in the noisy dataset remains above the specified tolerance threshold (). The algorithm begins with single items, iteratively combining them to form larger candidates while pruning those that fail the support test. Although conceptually simple and complete, FT-Apriori suffers from two main drawbacks: (i) the number of candidates grows exponentially when many frequent single items exist, and (ii) the algorithm requires multiple full dataset scans to validate FT conditions. In practice, this translates into high time complexity, since it must enumerate and evaluate all possible subsets of an itemset before confirming its frequency status. Consequently, FT-Apriori is not well suited for large-scale or high dimensional (sparse) datasets.

To overcome the inefficiency of repeated dataset scans, researchers later investigated bit-vector projection techniques.⁴⁸ and⁴⁵ proposed algorithms that encode each frequent item as a bit-vector representing its occurrence across all transactions. With this structure, dataset scanning is performed only once, and subsequent support counting is achieved through efficient bitwise operations. Candidate generation still follows the Apriori-style level-wise extension, but support computations are faster, since combining two bit-vectors via logical operations directly yields the occurrence of their joint itemset. While this approach significantly reduces support counting overhead, the exponential growth of candidate itemsets persists, and therefore, scalability remains a challenge.

In response to the limitations of candidate generation, ^47,51 explored a pattern-growth paradigm for FT itemset mining. Instead of generating and testing a large number of candidate itemsets, pattern-growth algorithms recursively project the dataset into smaller conditional sub-datasets and build prefix trees (FP-trees) to directly grow frequent patterns. In the proposed method, multiple FP-trees are constructed to represent different combinations of item presence and absence. For instance, when mining supersets of (ab) with , four FP-trees are needed: one for transactions containing both a and b, one for those containing a but not b, one for those containing b but not a, and one for those missing both. While this strategy avoids redundant candidate generation, its main drawback lies in memory consumption and redundancy: even transactions that share many common items are mapped across multiple FP-trees. As a result, the algorithm struggles with scalability and is impractical for large datasets. The proposed approach addresses this shortcoming by designing a single FP-tree structure that accommodates transactions with varying numbers of missing items, thereby reducing both memory usage and computational complexity. Moreover, existing pattern-growth approaches attempt to mine the complete set of FT frequent itemsets, which can still be exponential in number and often include many small or trivial patterns ⁵². In contrast, the proposed approach focuses on maximal FT frequent itemsets, offering a far more compact and informative representation that avoids redundancy and provides greater practical utility.

Beyond FT itemset mining, related research has also investigated approximate frequent itemset mining, where the goal is to tolerate errors or noise in the data. For example, ⁵³ introduced proportional approximate frequent itemsets (AFIs), where the degree of tolerance scales with the size of the itemset. Similarly, ⁵⁴ studied the discovery of high utility approximate itemsets in noisy datasets. These approaches differ from FT itemset mining in that their tolerance models are proportional to itemset length, leading to distinct sets of itemsets compared to those obtained with fault-tolerant definitions. Applications of proportional AFIs have been reported in domains such as bioinformatics¹⁵, and various heuristics have been developed to accelerate their discovery^46,55. However, existing AFI methods are predominantly Apriori-based and therefore suffer from inherent limitations, including exponential candidate explosion and high processing costs.

GPU-based frequent itemset mining trends

Recent trends in frequent itemset mining research have increasingly focused on accelerating the mining process using GPU-based architectures. Parallel frequent itemsets mining using distributed GPUs ⁵⁶ presents a distributed multi-GPU framework in which the database is partitioned across multiple GPU devices to accelerate Apriori-style and level-wise counting operations ^57,58. The primary objective of this approach is to maximize throughput by mapping support-counting tasks to massively parallel GPU kernels while managing coordinated data exchange between devices. A Parallel FP-Growth Algorithm Based on GPU extends the FP-growth paradigm to GPU environments ⁵⁹. This approach reorganizes transactions and conditional pattern bases into GPU-compatible structures, enabling parallel construction of conditional FP-trees and mitigating the candidate-generation overhead commonly associated with Apriori-based techniques. Its design emphasizes SIMD friendly memory layouts and kernel orchestration to efficiently parallelize FP-growth.

GMiner ⁶⁰ introduces a GPU-optimized enumeration strategy for frequent itemset mining on large scale datasets. It focuses on balancing computational load across GPU cores, reducing CPU–GPU transfer overhead, and restructuring enumeration tasks to better fit GPU execution models. This allows large datasets to be processed effectively on one or more GPU devices. GMiner++ ⁶¹ further enhances GMiner by reducing redundant computations and refining memory layout designs for improved utilization of multi-GPU architectures. It also reduces repeated intersection operations, resulting in improved performance when mining exact frequent itemsets. Although these GPU-based algorithms represent the latest developments in accelerating frequent itemset mining, they differ from the proposed FT-MFI-PG algorithm in several key aspects. First, all GPU-based algorithms enumerate all frequent itemsets. In contrast, the proposed FT-MFI-PG focuses on mining maximal frequent itemsets, which represent only the most specific and non-redundant itemsets. Second, the GPU-based algorithms operate under exact matching semantics, whereas the FT-MFI-PG mines fault-tolerant (FT) frequent itemsets that allow up to a specified number of missing items per occurrence. Third, the existing algorithms are designed for GPU architectures, while the proposed FT-MFI-PG is CPU-based; however, future extensions is possible to explore GPU-accelerated FT-MFI mining to further enhance performance. The Table 4 summarizes the key conceptual differences between the FT-MFI-PG and the current GPU-based frequent itemset mining algorithms.

Table 4.

Conceptual comparison between FT-MFI-PG and modern GPU-based FIM algorithms.

Algorithm	Exact/FT	All/maximal	Paradigm	GPU?
FT-MFI-PG (this work)	FT	Maximal	Pattern-growth (FT-FP-tree)	No
Parallel FIM on distributed GPUs 56	Exact	All	Apriori / counting	Yes
Parallel FP-Growth on GPU 59	Exact	All	FP-growth	Yes
GMiner 60	Exact	All	Enumeration	Yes
GMiner++ 61	Exact	All	Enhanced enumeration	Yes

Mining maximal fault-tolerant (FT) frequent itemsets: pattern-growth methodology

The core of the proposed approach relies on the pattern-growth paradigm, which is a divide-and-conquer strategy for mining frequent itemsets without the need for exhaustive candidate generation. Unlike Apriori-style approaches, pattern-growth uses a compact data structure known as the FP-tree (Frequent Pattern Tree) ^22,49,50. The FP-tree is specifically designed to compress a large transactional dataset into a highly efficient representation that preserves itemset association information. In this structure, each transaction is projected onto a path in the tree, where nodes represent items and branches correspond to entire transactions. When multiple transactions share common prefixes, their overlapping parts are stored on the same branch, and the frequency of the shared prefix is aggregated at the corresponding nodes. This compression significantly reduces redundancy, especially for dense datasets, and provides a powerful foundation for mining longer frequent itemsets.

Once the FP-tree is constructed, the pattern-growth recursively explores conditional patterns to discover maximal FT frequent itemsets (FT-MFIs). For a given itemset, its supersets are identified by extracting the conditional patterns from the FP-tree branches in which the itemset occurs. These conditional patterns are then used to generate smaller, conditional FP-trees. Each conditional tree preserves only the transactions relevant to the itemset under consideration. By recursively applying this process, the algorithm expands itemsets in a depth-first manner, enabling efficient discovery of FT-MFIs at successive levels. To facilitate traversal of the FP-tree, each occurrence of an item is connected through a linked list, and the head pointers of these lists are stored in a header table. The header table acts as an index, allowing the algorithm to quickly locate and traverse all nodes of a given item across the FP-tree. This structure plays a critical role in ensuring that candidate generation remains efficient and that the recursive construction of conditional FP-trees can be carried out without repeated scans of the original dataset.

One of the most significant advantages of the FP-tree structure is its ability to eliminate irrelevant candidate itemsets early in the mining process. Only itemsets that actually occur in the conditional patterns are expanded, while those absent from the dataset are naturally pruned. Moreover, the evaluation of FT conditions, such as the minimum support of itemsets and the item-level support thresholds can be computed directly from the conditional patterns without costly additional scans.

Example

To illustrate how the proposed approach constructs the initial (global) FP-tree, consider the sample transactional dataset shown in Table 3. For this example, the fault-tolerant parameter is set to , while the thresholds for the minimum support and minimum item support are specified as and , respectively. During the initial pass over the dataset, the algorithm filters out all items that do not meet the requirement. This pruning step eliminates infrequent items early in the process, ensuring that only potentially useful items contribute to subsequent FP-tree construction ³⁵. After this filtering stage, the resulting set of frequent items, along with their corresponding support counts, is given as .

Once the frequent items have been identified, the transactions are reorganized by ordering their items according to the global frequency of occurrence, starting with the most frequent. This reordering step is critical, as it maximizes prefix sharing in the FP-tree, thereby improving both compression efficiency and mining performance. The algorithm then performs a second pass over the dataset to construct the FP-tree. Each transaction is projected onto a path in the tree, and overlapping prefixes between transactions are merged into shared branches. For instance, when two or more transactions begin with the same sequence of items, this common prefix is stored only once in the FP-tree, and its frequency count is updated accordingly. The resulting FP-tree serves as a compact representation of the dataset, where nodes capture item frequencies and branches capture transactional structure. The constructed (global) FP-tree for the dataset in Table 3 is depicted in Fig. 1, which clearly illustrates how transaction compression and prefix sharing are achieved through the FP-tree representation.

Fig. 1.

Resulting global FP-tree built from the full set of transactions.

Constructing fault-tolerant (FT) frequent pattern tree (FT-FP-tree)

The proposed algorithm discovers the complete set of maximal FT frequent itemsets (FT-MFIs) by creating an enhanced tree structure referred to as the FT-FP-tree (Fault-Tolerant Frequent Pattern Tree). Conceptually, the FT-FP-tree extends the traditional FP-tree ^22,49,50 by incorporating FT conditional patterns. This enhancement allows the algorithm to efficiently prune infrequent items that do not appear in the dataset, thereby focusing computation on promising candidate itemsets.

An FT conditional pattern of an itemset X is defined as a conditional transaction that contains at least items of X, i.e., it satisfies the fault-tolerant matching constraint. Each FT conditional pattern is represented as a 4-tuple:

where each component has a precise meaning. The first component P denotes the prefix itemset (i.e., the items that can be used to generate supersets of X) and is mapped onto the corresponding branch of the FT-FP-tree. The second component sup is the support of the conditional pattern, representing the number of transactions in the database that contribute to this pattern. The third component , referred to as the row FT value, explicitly represents the number of missing items of X in the current conditional pattern. Thus, indicates that all items of X are present in the pattern, whereas indicates that exactly one item of X is missing. This value is not the maximum tolerance threshold; rather, it is the observed fault level associated with the specific conditional pattern. The fourth component stores the item-level support distribution of the items in P. Specifically, for each individual item , the entry represents the number of transactions (captured by this conditional pattern) in which item occurs. For example, the vector indicates that within this conditional pattern, both d and c contribute a support count of 1, while indicates that c contributes support 1 but d does not occur in this conditional pattern. These values correspond to the support contributions of the current conditional pattern only. The overall item-level FT support () is then obtained by aggregating the contributions of across all FT conditional patterns in X. To organize these components efficiently, the leaves of the FT-FP-tree maintain FT conditional pattern tables (FT-CP-Tables). Each FT-CP-Table contains three columns corresponding to the second, third, and fourth components of the FT conditional pattern, respectively. This tabular mapping ensures that all necessary information for evaluating both itemset and individual item support is readily accessible during the mining process.

“Constructing FT-FP-tree of base itemsets of length ” and “Mining maximal FT frequent itemsets from FT-FP-tree” sections describe how the proposed algorithm mines the complete set of maximal FT itemsets from the FT-FP-tree. “Constructing FT-FP-tree of base itemsets of length ” section explains how the algorithm constructs the FT-FP-tree for itemsets of length by extracting and transforming conditional patterns from the FP-tree. “Mining maximal FT frequent itemsets from FT-FP-tree” section then extends this process to itemsets of length . In this step, the algorithm mines maximal FT frequent itemsets using information from both the FT-FP-tree of length and the global FP-tree. This approach ensures that all valid supersets are discovered while maintaining consistency in the FT mining process.

Before discussing the procedures in “Constructing FT-FP-tree of base itemsets of length ” and “Mining maximal FT frequent itemsets from FT-FP-tree” sections, it is important to explain why the algorithm constructs FT-FP-trees for itemsets of lengths and . This design is motivated by two interconnected aspects of FT frequent itemset mining: (i) determining the correct starting point for the mining process based on the FT factor , and (ii) ensuring the complete discovery of supersets during maximal FT frequent itemset mining. In traditional exact FP-growth ⁴⁹, the algorithm begins by constructing FP-trees for 1-item conditional patterns, which corresponds to itemsets of length because in exact frequent itemset mining the is 0. This requires scanning the global FP-tree to extract the conditional pattern bases needed for building these initial trees. This procedure is intrinsic to pattern growth, because constructing itemsets at the next level requires scanning the tree of the previous level. The proposed algorithm follows the same principle. In FT itemset mining, all itemsets whose lengths are less than or equal to are automatically FT-frequent. Therefore, mining must begin from itemsets of length , which are the smallest non-trivial FT itemsets. To correctly initialize mining at this level, the algorithm scans the global FP-tree once to extract the FT conditional patterns required for constructing the FT-FP-tree of itemsets of length . To support this initialization, the algorithm first constructs the FT-FP-tree for itemsets of length (“Constructing FT-FP-tree of base itemsets of length ” section), and then constructs the FT-FP-tree for itemsets of length (“Mining maximal FT frequent itemsets from FT-FP-tree” section). This process mirrors the natural progression of traditional FP-growth and does not conflict with the independence of conditional pattern bases.

It should be note here, that although the algorithm could directly construct the FT-FP-tree for itemsets of length , the intermediate construction at level is significantly more efficient. First, they establish the boundary from which valid FT supersets can be generated. Second, they ensure that the FT-FP-tree for itemsets of length correctly incorporates all FT conditional patterns associated with their immediate parent structures. Without first consolidating the FT conditional patterns at level , the algorithm would face several inefficiencies: it would need to repeatedly recompute missing item counts for each candidate, and it would repeatedly recompute overlapping supports. These repeated computations would increase initialization overhead and diminish the structural advantages of the FP-tree representation. For this reason, the algorithm performs an intermediate step in “Constructing FT-FP-tree of base itemsets of length ” section, where FT-FP-trees for itemsets of length are constructed once using the global FP-tree. This step does not introduce an additional loop-back; instead, it follows the same initialization logic as traditional FP-growth. In both cases, the global FP-tree must be scanned once to extract the conditional patterns, which then seed the first non-trivial level of mining. “Mining maximal FT frequent itemsets from FT-FP-tree” section then uses the consolidated FT-FP-trees of length , together with information from the global FP-tree, to build the FT-FP-trees for itemsets of length . After this initialization, all FT pattern growth proceeds entirely within the FT-FP-tree hierarchy, without requiring further traversal of the global FP-tree. Algorithm 1 provides the pseudocode for constructing the FT-FP-tree for an itemset, and Fig. 2 presents a workflow diagram summarizing the overall FT-MFI-PG procedure.

Fig. 2.

Visual workflow diagram summarizing the FT-MFI-PG algorithm. The diagram illustrates the complete process, from transaction mapping and candidate generation to the construction of FT-FP-trees, FT condition checking, superset mining, pruning heuristics, and the final maximal FT frequent itemset output. (a) Shows the generation of FT-FP-trees for base itemsets of length , and (b) shows the recursive mining of itemsets of length and mining maximal FT frequent itemsets.

Constructing FT-FP-tree of base itemsets of length

The algorithm begins by constructing FT-FP-trees for all possible -item combinations using only items that satisfy the minimum support thresholds. From these initial FT-FP-trees, the algorithm extracts FT conditional patterns, which are subsequently used to generate longer candidate itemsets.

Example

To illustrate the construction of an FT-FP-tree for a specific itemset, consider with a FT factor , , and . The algorithm begins by extracting the conditional patterns of the individual items c and d from the initial FP-tree. These conditional patterns are then transformed into FT conditional patterns, which embed additional information about missing items and their fault levels.

• FT conditional patterns for item c: For item c, the algorithm identifies three conditional patterns: , , and . Each of these is then converted into an FT conditional pattern that explicitly records four components: (i) the items available for generating supersets, (ii) the overall support of the pattern, (iii) the fault-tolerant factor , and (iv) the support distribution of individual items in X. For instance, the pattern is mapped to , where the items ef are available for extending (dc), the support count is 1, indicates that both d and c are present, and the last component confirms that each item in (dc) has a support of 1. Likewise, the pattern becomes , while is transformed into , where reflects the absence of item d.

• FT conditional patterns for item d: The algorithm then proceeds to extract conditional patterns for item d by scanning the FP-tree again. Two patterns are obtained: and . To ensure that no redundant patterns are stored, each new conditional pattern of item d () is compared with the conditional patterns already generated for item c (). If is a subset of , its support is reduced by the support of , and any pattern with zero support after adjustment is discarded. In this example, is identified as a prefix of . After subtracting the overlap, its support is reduced to 1, producing the FT conditional pattern . The second pattern, , is removed because it overlaps with an already mapped pattern for item c with equivalent support.

This process ensures that the FT-FP-tree retains only those FT conditional patterns that contribute to valid FT frequent itemsets. The explicit recording of values within each FT conditional pattern guarantees that the algorithm consistently respects FT thresholds while extending itemsets. As a result, the FT-FP-tree for provides a compact, noise-resilient representation of the search space, which is critical for efficiently mining maximal FT frequent itemsets. Table 5 presents the complete set of FT conditional patterns associated with the itemset dc. It is important to note that the itemset (dc) used in this example has a length of two. According to the fundamental property of FT frequent itemset mining, all itemsets whose lengths are less than or equal to the FT factor are automatically considered FT frequent. This means that (dc) inherently satisfies the FT conditions without requiring explicit frequency validation.

Table 5.

Conditional patterns of itemset (dc) derived from the FP-tree and FT patterns.

Item	Conditional patterns	FT conditional patterns
c	fgdc : 1	(,,,)
c	fbdc : 1	(,,,)
c	gebc : 1	(,,,)
d	fgd : 2	(,,,)
d	fbd : 1	Ignored, as it is prefix of pattern (fbdc : 1). The support of fbd : 1 becomes zero after subtracting its support from the support of fbdc : 1.

After this, the algorithm constructs the FT-FP-tree for dc using the extracted FT conditional patterns. This tree serves as a compact data structure that supports the recursive exploration of longer supersets containing dc. During the construction process, items that do not meet the requirement, such as item e, are pruned. The pruning operation is not only a memory optimization but also a computational one, since it prevents the algorithm from generating and evaluating supersets that are guaranteed to be infrequent. By carefully discarding infrequent items, the algorithm focuses its efforts on only those extensions of dc that have the potential to form valid maximal FT frequent itemsets.

If no supersets of dc are later discovered to be frequent, then dc itself is added to the set of FT-MFIs, ensuring that the algorithm does not overlook valid maximal patterns. This mechanism highlights the completeness property of the mining procedure: every mined FT frequent itemset is either extended into a larger frequent superset or preserved as part of the maximal set. Figure 3 illustrates the FT-FP-tree structure generated for dc, demonstrating how FT itemsets are organized for efficient mining. Finally, to facilitate efficient traversal and reduce repeated computation, all FT conditional pattern tables (FT-CP-Tables) associated with the FT-FP-tree are linked together to form a unified list. This linked structure allows the algorithm to navigate across related conditional patterns, enabling faster generation of supersets and efficient updating of support counts. Such design decisions are critical for scaling the algorithm to large datasets, where redundant calculations can quickly become a bottleneck.

Fig. 3.

Fault-Tolerant FP-tree of itemset (dc).

Algorithm 1.

Pseudo-code for constructing FT-FP-tree for an itemset.

Algorithm 2.

Pseudo-code for mining maximal FT frequent itemsets (FT-MFIs).

Algorithm 3.

Support computation from a set of FT conditional patterns.

Mining maximal FT frequent itemsets from FT-FP-tree

As discussed in the previous section, the FT-FP-tree constructed for an itemset X effectively encapsulates all transactions in which X appears. An important advantage of this property is that the algorithm can directly mine all supersets containing X from the FT-FP-tree, thereby eliminating the need to re-scan the original dataset multiple times. In practice, this significantly improves computational efficiency, especially when dealing with large or dense transactional datasets where repeated dataset scans would otherwise be prohibitively expensive. Moreover, by storing information about missing items through the FT factor , the FT-FP-tree ensures that both exact and approximate occurrences of an itemset are considered, providing robustness against noisy or incomplete data.

Example

To demonstrate this process, consider the head table of the itemset (dc) shown in Fig. 3. From this head table, the supersets of (dc) can be organized based on the additional items that co-occur with it in transactions. Specifically, the candidate FT-MFIs containing (dc) can be divided into three distinct categories: (i) supersets that include item b, (ii) supersets that include item g, and (iii) supersets that include item f. These categories capture all meaningful directions in which (dc) can be extended within the tree structure.

The mining process then proceeds recursively. For each additional item, the algorithm extracts the corresponding conditional patterns from the FT-FP-tree and evaluates them against the FT thresholds and . If the support values satisfy these thresholds, the candidate superset is retained as a valid candidate FT-MFI; otherwise, it is pruned from further exploration. For example, if (dc) is extended with item b, the algorithm checks whether (bdc) satisfies both global and item-level support requirements. A similar procedure applies to (gdc) and (fdc). In cases where extensions fail to meet the thresholds, those branches are discarded early, thereby reducing unnecessary computation. By traversing the FT-FP-tree in this manner, the algorithm guarantees that the complete set of FT-MFIs containing (dc) is discovered without performing repeated scans over the original transaction dataset. The hierarchical structure of the FT-FP-tree allows shared prefixes of transactions to be processed once and reused across multiple candidate generations, further reducing overhead.

To determine whether the itemset (bdc) qualifies as a maximal FT frequent itemset and to generate its possible supersets, the algorithm begins by extracting the FT conditional patterns of (bdc) from the FT-FP-tree of (dc). This step is performed by traversing all nodes of the corresponding FT-CP-Table, where each node generates a distinct FT conditional pattern for (bdc). Because the FT-FP-tree of (dc) is constructed solely from transactions containing both c and d, the extracted patterns represent only those transactions in which these two items appear together. Consequently, transactions that contain item b without simultaneously including c and d are absent from this structure.

To ensure completeness, the algorithm performs an additional traversal of the global FP-tree (illustrated in Fig. 1). This complementary step is essential because depending exclusively on the FT-FP-tree of (dc) would overlook candidate supersets of (bdc) that arise from transactions where b occurs independently of c and d. By re-examining the global FP-tree, the algorithm captures such cases and integrates them into the mining process. During this traversal, three conditional patterns for item b are identified: , , and . These conditional patterns ensure that the representation of (bdc) is now comprehensive, covering both joint occurrences of (dc) with b and occurrences where b appears in transactions without c or d.

A redundancy check is then applied to avoid duplicate representation of patterns already captured under other itemsets. Specifically, and are compared with conditional patterns of item c previously extracted from the FT-FP-tree of (dc) (e.g., and , as listed in Table 5). The pattern has identical support to and is therefore ignored to prevent redundancy. Similarly, the support of overlaps with , and after subtracting the overlapping support, its revised contribution is updated to 1.

By combining the FT conditional patterns derived from both sources (the FT-CP-Table of (dc) and the FP-tree traversal for item (b)), the algorithm builds a complete and non-redundant set of conditional patterns for (bdc). This dual-traversal strategy ensures that no valid supersets of (bdc) are overlooked, while redundant or overlapping patterns are systematically pruned. The resulting FT conditional patterns form the basis for evaluating whether (bdc) satisfies the required thresholds ( and ) and for mining all possible supersets of (bdc) in the FT-MFI framework. The extracted patterns are summarized as follows:

• ,,,,

• ,,,,

• ,,,,

• ,,,, and

• ,,,,

Table 6 shows the complete set of FT conditional patterns for the itemset (bdc). All patterns satisfy the FT factor requirement of . The itemset (bdc) also meets the minimum FT support threshold, , which means it appears at least three times in the transactions when considering the FT criteria. Looking at the support of individual items in the FT conditional patterns, we find that item c occurs in 3 transactions, item d occurs in 3 transactions, and item b occurs in 4 transactions. Since each of these counts is greater than the item-level FT support threshold, , it is clear that all items in (bdc) individually satisfy the required support condition. Therefore, the itemset (bdc) can be identified as a FT frequent itemset of length three. Figure 4 illustrates the FT-FP-tree constructed for the itemset (bdc), which serves as the basis for generating its supersets. To facilitate efficient traversal and mining, the algorithm links all FT-CP-Tables located at the leaf nodes of the FT-FP-tree, forming a linked list of FT-CP-Tables.

Table 6.

Fault-tolerant conditional patterns for itemset (bdc).

FT conditional patterns derived from the FT-FP-Tree of itemset (dc)	FT conditional patterns used to construct the FT-FP-Tree of itemset (bdc)
,,,	,,,
,,,	,,,
,,,	,,,
,,,	,,,
,,,	,,,

Fig. 4.

Fault-tolerant FP-tree constructed for itemset (bdc).

After identifying (bdc) as a FT frequent itemset, the algorithm proceeds to generate its supersets using the corresponding FT-FP-tree, as shown in Fig. 4. The candidate supersets of (bdc) are divided into two groups based on the additional item included: (1) supersets that contain item g, and (2) supersets that contain item f. This grouping allows the algorithm to systematically explore possible FT-MFIs.

To build and evaluate these supersets, such as (gbdc), the algorithm checks the FT support conditions, and , by traversing all nodes of the FT-CP-Tables linked to the FT-FP-tree of (bdc). Conditional patterns that include only the additional item g without b, d, or c are ignored. This is because such patterns have a FT factor of , which is higher than the allowed threshold (). As a result, they do not contribute to the support of candidate itemsets of length four. The FT conditional patterns obtained from both the FT-CP-Tables of (bdc) and the original FP-tree are listed below.

• ,,,,

• ,,,,

• ,,,, and

• ,,,,

All relevant conditional patterns are converted into FT conditional patterns for the itemset (gbdc), and the results are shown in Table 7. Each conditional pattern satisfies the FT parameter , which ensures that the patterns allow for up to two missing items while still being considered valid. The itemset (gbdc) also meets the minimum FT support threshold, , meaning that it appears frequently enough in the transactions under the FT criteria. The supports of the individual items within these patterns are as follows: g occurs in 5 transactions, b in 4 transactions, d in 3 transactions, and c in 3 transactions. Since all of these values are greater than the item-level FT support requirement, , Therefore, the itemset (gbdc) qualifies as a FT frequent itemset of length four. Figure 5 shows the FT-FP-tree built for (gbdc). To improve efficiency in traversal and superset generation, the algorithm connects all FT-CP-Tables located at the leaf nodes of the tree.

Table 7.

Fault-tolerant conditional patterns for itemset (gbdc).

FT conditional patterns extracted from FT-FP-Tree for (bdc)	FT conditional patterns for constructing FT-FP-Tree of (gbdc)
,,,	,,,
,,,	,,,
,,,	,,,
,,,	,,,

Fig. 5.

Fault-tolerant FP-tree constructed for itemset (gbdc).

Using the same procedure as with the itemset (gbdc), the algorithm now generates candidate supersets for (fgbdc). From the FT conditional patterns of (gbdc) (see Table 7), it is clear that item f is the only additional frequent item available. Therefore, the algorithm concentrates on building candidate itemsets that include f. To construct the FT conditional patterns for (fgbdc), the algorithm traverses all nodes in the linked list of FT-CP-Tables associated with (gbdc). Conditional patterns that include only the additional item f without g, b, d, or c are ignored. This is because such patterns have a FT factor of , which is higher than the allowed threshold (). As a result, they do not contribute to the support of candidate itemsets of length five. The list below presents the FT conditional patterns obtained through this process.

• ,,,,

• ,,,, and

• ,,,,

All identified patterns are transformed into FT conditional patterns for the itemset (fgbdc), as summarized in Table 8. Each conditional pattern adheres to the FT factor (), which establishes a support threshold of six for the itemset. Thus, the itemset (fgbdc) satisfies the required threshold. Table 8 presents the complete set of FT conditional patterns for (fgbdc). The support counts for individual items, derived from these patterns, are: , , , , and . Each of these items meets or exceeds the item-level support threshold (). Consequently, (fgbdc) is validated as a FT frequent itemset of length five.

Table 8.

Fault-tolerant conditional patterns for itemset (fgbdc).

FT conditional patterns obtained from the FT-FP-tree of itemset (gbdc)	FT conditional patterns for building FT-FP-tree of (fgbdc)
,,,	,,,
,,,	,,,
,,,	,,,

As no supersets of (fgbdc) exist, the algorithm classifies it as a maximal FT frequent itemset and adds it to the set of FT-MFIs. Because (fgbdc) is a superset of previously identified FT frequent itemsets, including (gbdc), (bdc), and (dc), these subsets are pruned from the FT-MFIs set to preserve maximality. Following this step, the algorithm backtracks to process the next -length itemset (ec). Mirroring the procedure demonstrated for itemset (dc) in the prior example, the algorithm recursively constructs FT-FP-trees for the remaining itemsets and mines them to discover all remaining FT-MFIs. Algorithm 2 shows the pseudo code for extracting the entire set of maximal FT frequent itemsets.

Time and space complexity

The search space for mining maximal FT-frequent itemsets can grow up to possible itemsets for distinct items, making the problem inherently exponential in the worst case. In the proposed algorithm, itemsets are expanded recursively using the FT-FP-tree, and their FT-support is computed directly from the FT-FP-tree together with the corresponding FT conditional patterns (projected databases). Consequently, the total running time depends on the amount of work spent across all explored itemsets, which can be expressed as

where denotes the size of the projected database for itemset , and is the set of prefix itemsets that survive HUT-based pruning.

In dense datasets, many item combinations remain frequent, and pruning becomes less effective. As a result, the algorithm may need to explore a large number of itemsets, and the complexity can approach the exponential bound , where is the number of transactions. In typical datasets, however, the FT-FP-tree structure, shared FT conditional patterns, and strong upper-bound pruning significantly reduce the number of itemsets that must be explored, making the pattern-growth process far more efficient in practice. The space complexity is dominated by the FT-FP-tree and the FT conditional patterns generated during recursive processing. In the worst case, when no prefix compression is possible, the FT-FP-tree may need to store every item occurrence, which leads to a space requirement of , where is the average transaction length. Because projected databases are stored in a compact form and reused across recursive calls, the additional working memory beyond the input and output is generally limited to , which includes the header table, temporary structures, and the recursion stack.

Correctness and completeness of FT-MFI-PG

In this section, we provide a rigorous proof framework to justify the correctness of the proposed FT-MFI-PG algorithm. Specifically, we formally justify: (i) the boundary condition that itemsets with length are automatically FT-frequent, (ii) the completeness of the recursive FT mining procedure (i.e., no valid FT-MFI is missed), and (iii) the maximal correctness of the output set (i.e., every reported pattern is maximal).

Preliminaries and definitions

Let D be a transaction database and let X be an itemset. According to the FT itemset mining model ³⁵, a transaction is said to be an FT transaction of X if

1

The FT support of X is defined as the number of FT transactions of X in D:

2

An itemset X is an FT frequent itemset if

3

and additionally, each item must occur in at least FT transactions of X, i.e.,

4

where denotes the number of FT transactions of X that contain item i. Finally, an FT frequent itemset X is called a maximal FT frequent itemset (FT-MFI) if there exists no FT frequent itemset Y such that

5

Boundary condition: why is automatically FT-frequent

Lemma 1

(Automatic FT Transaction Condition for Small Itemsets) Let X be an itemset such that . Then for every transaction , T is an FT transaction of X.

Proof

From Eq. 1, T is an FT transaction of X if

Since , we have . For any transaction T, it always holds that . Thus,

which implies that every transaction satisfies the FT condition of X.

Corollary 4.1

(FT Support for Itemsets of Length ) If , then

Proof

By Lemma 1, all transactions in D satisfy the FT condition for X. Hence, the FT support of X equals the total number of transactions in D.

Corollary 4.2

(Boundary Condition for FT-Frequency) If and , then X is an FT frequent itemset.

Proof

From Corollary 4.1, . Since , we obtain

Thus, X satisfies the FT frequency condition.

Remark 4.3

(Clarification of Boundary Conditions) Corollary 4.2 clarifies the boundary condition used in FT-MFI-PG. All itemsets of length are automatically FT-frequent holds under the practical assumption that . If , then no itemset can satisfy the FT support threshold, including those with .

Lemma 2

(Smallest Non-Trivial FT Frequent Itemsets) The smallest non-trivial FT frequent itemsets that require explicit mining have length .

Proof

For , Eq. 1 becomes

Thus, only transactions containing at least one item of X contribute to its FT support, and the FT support of X depends on the actual distribution of items in D. Therefore, explicit mining is required. In contrast, for , Lemma 1 shows that every transaction supports X automatically.

Completeness of the recursive mining procedure

Lemma 3

(Completeness of FT Conditional Pattern Generation) Let X be an FT frequent itemset and let W be an item such that is also FT frequent. Then all FT conditional patterns required to construct are contained in the conditional pattern base of W.

Proof

If is FT frequent, then it is supported by at least FT transactions, i.e.,

Thus, there exist at least transactions satisfying

For each such transaction, the items co-occurring with W form part of the prefix path of W in the global FP-tree. Therefore, every FT occurrence contributing to the FT support of is captured in the conditional pattern base of W. Hence, the conditional pattern base contains all necessary information to generate FT extensions including .

Lemma 4

(No Missing FT Frequent Itemsets) If an itemset X is an FT frequent itemset, then FT-MFI-PG will generate and evaluate X during the recursive mining process.

Proof

FT-MFI-PG follows a pattern-growth strategy similar to FP-growth ⁴⁹. Mining starts from itemsets of size (Lemma 2) and recursively grows patterns using conditional pattern bases. At each recursion step, the FT conditional pattern base contains all transactions contributing to the FT support of the current prefix (Lemma 3). Therefore, any FT frequent itemset X can be constructed through successive extensions and will be evaluated during the recursion. Hence, no FT frequent itemset is missed.

Theorem 4.4

(Completeness of FT-MFI-PG) FT-MFI-PG enumerates all maximal FT frequent itemsets in the database D.

Proof

Let M be any maximal FT frequent itemset in D. Since M is FT frequent, Lemma 4 ensures that FT-MFI-PG generates and evaluates M. Therefore, every maximal FT frequent itemset in D is discovered. Hence, FT-MFI-PG is complete.

Maximal correctness of the output set

Lemma 5

(Soundness of Reported Patterns) Every itemset reported by FT-MFI-PG satisfies both and constraints.

Proof

FT-MFI-PG reports an itemset X only after computing its FT support and verifying that

and

Thus, every reported itemset satisfies the FT frequent itemset definition.

Lemma 6

(Correctness of Maximality Condition) If FT-MFI-PG outputs an itemset X as maximal, then there exists no FT frequent itemset Z such that .

Proof

Assume there exists an FT frequent itemset Z such that . Then there exists at least one item such that is FT frequent. By Lemma 3, the conditional pattern base of X contains all FT occurrences needed to generate such an extension. Therefore, FT-MFI-PG would extend X during recursion and would not terminate at X. This contradicts the assumption that X is output as maximal. Hence, no FT frequent superset exists.

Theorem 4.5

(Maximal Correctness of FT-MFI-PG) Every itemset reported by FT-MFI-PG is a maximal FT frequent itemset, and no non-maximal FT frequent itemset is included in the output set.

Proof

From Lemma 5, each reported itemset is FT frequent. From Lemma 6, each reported itemset has no FT frequent superset. Therefore, each reported itemset is maximal by definition. Hence, the output set contains only maximal FT frequent itemsets.

Correctness and completeness of FT-MFI-PG

Theorem 4.6

(Correctness and Completeness of FT-MFI-PG) FT-MFI-PG outputs the complete set of maximal FT frequent itemsets in D, without missing any valid FT-MFI and without producing any non-maximal patterns.

Proof

Theorem 4.4 proves that FT-MFI-PG discovers all maximal FT frequent itemsets (completeness). Theorem 4.5 proves that every reported itemset is maximal (maximal correctness). Therefore, FT-MFI-PG is both complete and correct.

Pruning infrequent FT-MFIs

The FT-MFIs mining approach presented in Section 3 generates exactly the same set of candidate itemsets as the algorithm would when mining all FT frequent itemsets. However, the FT-MFIs set is typically an order of magnitude smaller than the complete set of FT frequent itemsets. This reduction enables the use of efficient heuristics to prune infrequent search spaces. In the literature on maximal frequent itemset mining, several well–known algorithms such as LCM ²⁶, GenMax ⁶², MAFIA ²⁷, and FPMax ⁶³ exploit different pruning mechanisms under the assumption of exact support anti-monotonicity. These approaches typically rely on pruning schemes such as diffsets, closure-based pruning, PEP (Parent Equivalence Pruning), FHUT, and head–tail maximality checking (HUTMFI) to eliminate non-promising branches early during the mining process (see Table 9 for a comparative overview). Such strategies are extremely effective in exact maximal itemset mining because support monotonically decreases when an itemset is extended. However, these pruning strategies cannot be directly adopted for maximal FT frequent itemset mining. Under exact matching, the support of an itemset always decreases or remains same when the itemset is extended. This is not valid in the fault-tolerant context because an itemset may satisfy the FT support threshold even if X does not. Therefore, pruning strategies that rely on exact support, such as diffset-based pruning, closure checking, or PEP, cannot be directly transferred to the FT mining context without compromising correctness or completeness. For example, the diffset optimization used in GenMax depends strongly on the monotonic decreasing property of supports, while closure-based pruning in LCM assumes that closedness can be maintained by exact support comparisons. These conditions are violated when support is computed under relaxed semantics.

Table 9.

Comparison of pruning techniques used in maximal frequent itemset mining algorithms and applicability to FT-MFI. PEP is Parent Equivalence Pruning, FHUT is Frequent Head Union Tail, and HUTMFI is Head Union Tail Maximal Frequent Itemset.

Algorithm/pruning techniques	Diffsets	Closure-based pruning	PEP	FHUT	HUTMFI	Prefix-based pruning
LCM 26
GenMax 62
MAFIA 27
FPMax 63
FT–MFI–PG

Despite these challenges, the FT–MFI–PG algorithm adopts pruning strategies that remain valid in the fault–tolerant setting. Specifically, FT–MFI–PG incorporates FHUT and HUTMFI heuristics, which are conceptually related to pruning schemes used in MAFIA ²⁷ and GenMax ⁶³, but are redesigned such that they do not require the exact anti-monotonicity of support. In addition, the FT–FP–tree combined with FT conditional pattern extraction performs prefix-based pruning and early elimination of infeasible conditional branches while preserving the relaxed support conditions. These components enable aggressive pruning comparable to classical maximal itemset mining algorithms, but without violating the semantics of fault tolerance.

FHUT (frequent head union tail)

 ⁶⁴ and ²⁷ observed that the longest itemset that can be mined in an iteration is the current frequent itemset combined with all frequent items in the header table. Let H denotes the frequent itemset of the current iteration, and T represents the set of all frequent items in the header table. If the union itself forms an FT-MFI, then all frequent items in the header table can be pruned from further consideration.

HUTMFI (head union tail maximal FT frequent itemset)

Before generating conditional patterns for an itemset, the algorithm checks whether the union of H with the frequent items in T is a subset of any known FT-MFI. If it is, generation of conditional patterns for the remaining frequent items in the header table is halted, and the algorithm backtracks to the parent itemset ²⁷. Experimental results indicate that applying this heuristic can yield substantial performance gains.

Maximal superset checking

To determine whether an itemset X is maximal, the algorithm checks if X is a subset of any known FT-MFI, a process referred to as maximal superset checking. Naively, this requires comparing X against all known FT-MFIs, which can be computationally expensive for low support thresholds where the number of FT-MFIs is large. To improve efficiency, we adopt a local MFI (LMFI) superset checking strategy ⁶⁵.

LMFI examines supersets using a divide-and-conquer approach. Instead of comparing X with all known FT-MFIs, it considers only those FT-MFIs where the parent of X appears as a prefix. All FT-MFIs are stored in a compact tree structure called the Max-FT-tree, which allows the algorithm to avoid exhaustive comparisons. Similar to the FP-tree, the Max-FT-tree maps FT-MFIs along the branches of the tree ⁶³. Shared prefixes among multiple FT-MFIs are merged into common branches, thereby improving the efficiency of superset comparisons. Nodes with the same items are linked via linked lists, and the head pointers and linked lists are used to retrieve the mined FT-MFIs. To find supersets of X, the parent itemset of X projects a list of pointers to only those FT-MFIs in the Max-FT-tree where the parent itemset appears as a subset.

Experiments

To assess the effectiveness and efficiency of proposed algorithm, FT-MFI-PG, we conducted a series of experiments comparing its performance with the most relevant existing FT-MFI mining algorithms. Specifically, we evaluated the algorithm on one synthetic dataset, T10I4D100K, and three widely used real-world benchmark datasets: FoodMart, FoodMart, and BMSWebView1. These datasets are standard choices in the frequent itemset mining (FIM) community for evaluating algorithm performance due to their varying sizes, item distributions, and transaction characteristics. All datasets are publicly accessible through the FIM repository (https://fimi.uantwerpen.be/data/ ). Table 10 presents a concise overview of these datasets, including the number of transactions, average transaction length, and the total number of distinct items in each dataset.

Table 10.

Overview of the datasets: transactions, items, and average transaction length.

Dataset	Number of transactions	Number of items	Avg. transaction length
Retail	88, 162	16, 470	10
BMSWebView1	59, 601	497	3
T10I4D100K	100, 000	870	11
FoodMart	4, 141	1, 559	4

For benchmarking purposes, we compared FT-MFI-PG against two prominent FT-MFI mining algorithms: VB-FT-Mine ⁴⁸ and FT-MFI-MultiTree ⁵¹. VB-FT-Mine is an Apriori-inspired method that traverses the search space in a top-down manner. It begins by examining individual items, gradually building up to larger itemsets while verifying the FT conditions for each candidate. To accelerate support counting, it employs bitwise operations on itemset bit-vectors ²⁷. Despite its computational optimizations, VB-FT-Mine faces scalability challenges for large datasets because it generates an exponentially growing number of candidate itemsets and repeatedly scans the entire dataset to calculate support counts. In contrast, FT-MFI-MultiTree is a tree-based approach designed to handle FT by mapping transactions with missing items across multiple FP-trees ⁵¹. Its inefficiency mainly arises when similar transactions differ in missing items, causing repeated computations of support and increased memory usage due to redundant storage in multiple trees. Since neither VB-FT-Mine nor FT-MFI-MultiTree has publicly available implementations, we re-implemented all algorithms in C++ to ensure a fair and consistent comparison.

All experiments were carried out on a machine equipped with an Intel processor running at 3.2 GHz and 8 GB of RAM. To examine performance trends, we varied the minimum support thresholds and tested FT factors of and . The specific parameter settings adopted for each dataset in these experiments are summarized in Table 11. This setup allowed us to evaluate the computational efficiency and scalability of FT-MFI-PG in comparison with the baseline FT-MFI algorithms across different dataset characteristics and parameter configurations. Since the proposed FT-MFI-PG algorithm is fully deterministic, running it multiple times on the same dataset with the same parameters always produces exactly the same results (number of maximal FT frequent itemsets) and the same execution time. Because there is no difference between runs, statistical measures such as standard deviation, variance, or confidence intervals are not needed and are not included.

Table 11.

Dataset-specific fault-tolerant factors and support thresholds applied in the experiments.

Dataset	Number of transactions
Retail	88, 162
BMSWebView1	59, 601
T10I4D100K	100, 000
FoodMart	4, 141

We evaluated the performance of the FT-MFI mining algorithms through three key experiments:

• Processing time: The first experiment measures the total time required by each algorithm to extract the complete set of FT-MFIs, thereby reflecting their computational efficiency.

• Scalability: The second experiment examines how the algorithms perform on datasets of varying sizes to assess their ability to handle increasing volumes of transactional data.

• Transaction complexity: The third experiment analyzes execution time on subsets of datasets with different transaction lengths, highlighting the impact of transaction length on algorithmic performance.

• Memory consumption: The fourth experiment evaluates the amount of memory utilized by each algorithm during execution.

Experiments related to scalability (second experiment) and transaction complexity (third experiment) are carried out exclusively on the Retail and T10I4D100K datasets because of their sparsity and diverse transaction lengths. All algorithms are executed on these subsets using identical FT support thresholds to ensure a fair comparison. To study scalability, dataset subsets containing between 10, 000 and 90, 000 transactions are generated. For transaction complexity, the T10I4D100K and Retail datasets are divided into five subsets each, with 30,000 transactions randomly selected from the original dataset for each subset. The subsets are organized based on transaction lengths: the first subset includes transactions of length 1 to 10, the second subset covers transactions of length 11 to 20, and the remaining three subsets include transactions of length 21 to 30, 31 to 40, and 41 to 50, respectively. These subsets allow the evaluation of the algorithms on datasets of varying sizes and on transactions of differing complexity.

Figures 6, 7, 8, 9 show the processing times observed for the algorithms. Here, processing time is defined as the total execution duration from the beginning of mining until the full set of FT-MFIs is obtained. As expected, all algorithms exhibit increased execution times at lower support thresholds. To maintain practicality, any experiment exceeding 3,200 seconds is terminated. Specifically, Figs. 6, 7, 8, 9 report processing times for the Retail, BMSWebView1, FoodMart, and T10I4D100K datasets. Additionally, Figs. 11 and 13 depict performance variations with respect to different dataset sizes, while Figs. 10 and 12 show the results for subsets with differing average transaction lengths.

Fig. 6.

Performance comparison of FT-MFI mining algorithms on the Retail dataset ().

Fig. 7.

Performance comparison of FT-MFI mining algorithms on the BMSWebView1 dataset ().

Fig. 8.

Performance comparison of FT-MFI mining algorithms on the T10I4D100K dataset ().

Fig. 9.

Performance comparison of FT-MFI mining algorithms on the FoodMart dataset ().

Fig. 11.

Scalability analysis of FT-MFI mining algorithms on the Retail dataset with varying transaction sizes (, , ).

Fig. 13.

Scalability analysis of FT-MFI mining algorithms on the T10I4D100K dataset with varying transaction sizes (, , ).

Fig. 10.

Scalability analysis of FT-MFI mining algorithms on the Retail dataset with varying transaction lengths (, , ).

Fig. 12.

Scalability analysis of FT-MFI mining algorithms on the T10I4D100K dataset with varying transaction lengths (, , ).

Systematic analysis of FT parameters (, min_sup, and item_sup): In the FT frequent itemset mining model, the parameter determines the tolerance level by allowing up to missing items in a transaction when evaluating whether it supports an itemset. Therefore, increasing relaxes the matching constraint and results in a larger number of transactions contributing to the FT support of candidate itemsets. Consequently, the search space expands rapidly, leading to a substantial increase in both the number of generated FT candidates and the computational cost of FT support verification. In addition, min_sup and item_sup act as frequency thresholds that control pruning strength. Since these parameters directly affect the number of frequent items retained and the number of conditional patterns constructed, they significantly influence both the output size and the processing time. To systematically evaluate the impact of these parameters, additional experiments are conducted by varying and min_sup while fixing item_sup for each dataset. The results are summarized in Tables 12, 13, 14, 15. All values in these tables represent processing time in seconds required to mine the complete set of FT-MFIs.

Table 12.

Performance evaluation of FT-MFI mining algorithms with varying min_sup on the Retail dataset and item_sup = 0.10%. The values in the table cells represent the processing time (in seconds) required by each algorithm to mine the maximal fault-tolerant frequent itemsets.

	min sup	FT-MFI-PG	VB-FT-Mine	FT-MFI-MultiTree
	0.35%	8	168	124
	0.40%	7	156	113
	0.50%	6	143	102
	0.60%	4	113	84
	0.70%	3	87	77
	0.35%	62	> 3,200	> 3,200
	0.40%	56	> 3,200	> 3,200
	0.50%	48	> 3,200	> 3,200
	0.60%	22	> 3,200	2988
	0.70%	12	3,123	2578

Table 13.

Performance evaluation of FT-MFI mining algorithms with varying min_sup on the BMSWebView1 dataset and item_sup = 0.04%. The values in the table cells represent the processing time (in seconds) required by each algorithm to mine the maximal fault-tolerant frequent itemsets.

	min sup	FT-MFI-PG	VB-FT-Mine	FT-MFI-MultiTree
	0.20%	52	2145	742
	0.30%	48	1975	691
	0.40%	43	1768	643
	0.50%	35	1454	550
	0.60%	21	1139	405
	0.20%	604	>3200	1256
	0.30%	553	>3200	1199
	0.40%	498	>3200	1132
	0.50%	414	>3200	1013
	0.60%	356	3134	958

Table 14.

Performance evaluation of FT-MFI mining algorithms with varying min_sup on the T10I4D100K dataset and item_sup = 0.70%. The values in the table cells represent the processing time (in seconds) required by each algorithm to mine the maximal fault-tolerant frequent itemsets.

	min sup	FT-MFI-PG	VB-FT-Mine	FT-MFI-MultiTree
	1.7%	109	3145	1251
	2.0%	106	3085	1214
	3.0%	101	3047	1162
	4.0%	94	2981	1079
	5.0%	85	2893	987
	1.7%	2370	>3200	>3200
	2.0%	2325	>3200	>3200
	3.0%	2863	>3200	>3200
	4.0%	2786	>3200	>3200
	5.0%	2668	>3200	>3200

Table 15.

Performance evaluation of FT-MFI mining algorithms with varying min_sup on the FoodMart dataset and item_sup = 0.03%. The values in the table cells represent the processing time (in seconds) required by each algorithm to mine the maximal fault-tolerant frequent itemsets.

	min sup	FT-MFI-PG	VB-FT-Mine	FT-MFI-MultiTree
	0.09%	1	389	68
	0.12%	1	332	62
	0.15%	1	268	53
	0.18%	1	138	26
	0.20%	1	65	15
	0.09%	37	139	104
	0.12%	32	135	943
	0.15%	24	127	861
	0.18%	13	69	458
	0.20%	6	38	235

Effect of : The results presented in figures and tables clearly indicate that increasing substantially increases runtime for all evaluated algorithms. This behavior is consistent with the trends observed in Figs. 6, 7, 8, 9, where the runtime increases significantly when mining is performed under relaxed FT constraints. Specifically, when increases from 1 to 2, more partially matching transactions satisfy the FT condition, which increases the number of FT frequent itemsets and enlarges the candidate space. For example, in the Retail dataset (Table 12), FT-MFI-PG requires only 3–8 seconds when , but increases to 12–62 seconds when . A similar trend is observed for BMSWebView1 (Table 13), where FT-MFI-PG increases from 21–52 seconds () to 356–604 seconds (). This demonstrates that is a dominant parameter influencing computational complexity. The impact of is even more severe for VB-FT-Mine and FT-MFI-MultiTree. In multiple datasets, both algorithms fail to complete within the 3,200 seconds time limit when , as also reflected in Figs. 6, 7, 8, 9. This occurs because the relaxed tolerance level increases the number of candidates that must be generated and tested, causing a combinatorial explosion in Apriori-based approaches.

Effect of min_sup: The minimum FT support threshold min_sup plays a critical role in controlling the number of FT frequent itemsets. Lower min_sup values allow more itemsets to satisfy the FT frequency condition, which results in a larger output size and higher computational overhead. This observation is consistent with Figs. 6, 7, 8, 9, where all algorithms show increased runtime as support thresholds decrease. For example, in the Retail dataset with (Table 12), FT-MFI-PG requires 12 seconds at min_sup, but increases to 62 seconds at min_sup. Similarly, for FoodMart (Table 15), FT-MFI-PG increases from 6 seconds to 37 seconds when min_sup decreases from 0.20% to 0.09% under . This confirms that lower min_sup thresholds substantially increase mining complexity by expanding the set of candidate FT frequent patterns. Furthermore, the effect of lowering min_sup is significantly more pronounced for VB-FT-Mine and FT-MFI-MultiTree. In BMSWebView1 (Table 13), VB-FT-Mine exceeds the 3,200 seconds time limit for most configurations when , while FT-MFI-MultiTree remains slower than FT-MFI-PG due to repeated construction and traversal of multiple trees. These results reinforce the conclusions drawn from Figs. 7, 8, 9, where both baseline methods struggle at low thresholds.

Effect of item_sup: The threshold item_sup serves as an additional reliability constraint in the FT itemset mining by ensuring that tolerance does not lead to unreliable patterns. Specifically, although an itemset X may satisfy the global FT frequency requirement (i.e., it appears in at least min_sup FT transactions), the FT definition further requires that each individual item in X must occur in at least item_sup FT transactions of X. This condition prevents weak items from being included in an FT frequent itemset simply because allows partial matching. Hence, item_sup acts as an item-level support constraint that strengthens the validity of the discovered FT-MFIs. From a computational perspective, item_sup also strongly affects the search space. A lower item_sup makes the item-level constraint less restrictive, allowing more items to remain eligible for extension during mining. This increases the number of candidate FT frequent itemsets and enlarges the conditional search space, which results in higher processing time. In contrast, a higher item_sup eliminates unreliable items early and reduces the number of candidate extensions explored, leading to smaller FT-FP trees (or conditional trees) and improved efficiency.

Figures 6, 10, and 11 summarize the execution times on the Retail dataset under varying values of item_sup while keeping min_sup fixed. The results clearly demonstrate that item_sup has a significant impact on both the runtime and the overall mining complexity. In particular, when item_sup is set to a lower value, more items satisfy the item-level FT frequency constraint and remain eligible for extension during mining. This substantially increases the number of conditional patterns and candidate FT itemsets, resulting in higher execution times for all algorithms. In contrast, increasing item_sup strengthens the pruning effect by eliminating weak items early, which reduces the size of the conditional search space and improves efficiency. Across all tested configurations, FT-MFI-PG consistently mines the complete set of FT-MFIs in considerably less time compared to VB-FT-Mine and FT-MFI-MultiTree. Furthermore, FT-MFI-PG demonstrates strong scalability when the dataset size increases (Fig. 11) and when the average transaction length becomes larger (Fig. 10). This indicates that the proposed FP-tree mapping and pattern-growth strategy is able to exploit the pruning effect introduced by higher item_sup thresholds more effectively than the competing approaches. On the other hand, VB-FT-Mine and FT-MFI-MultiTree show a steep increase in runtime at lower item_sup thresholds and frequently fail to complete the mining process within the 3,200 seconds time limit, since the relaxed item-level constraint leads to a rapid expansion of the candidate space.

Figures 7, 8, and 9 report the execution times observed on the T10I4D100K, FoodMart, and BMSWebView1 datasets, respectively, under varying item_sup values. Similar performance trends are observed across these datasets. As item_sup decreases, all algorithms experience increased runtime due to the larger number of frequent items retained and the corresponding growth in the number of candidate FT frequent itemsets. This effect is particularly severe for VB-FT-Mine, which relies on Apriori-based candidate generation and therefore suffers from excessive FT support verification when many frequent items exist. Although FT-MFI-MultiTree performs better than VB-FT-Mine by adopting a pattern-growth paradigm, it still incurs substantial overhead due to repeated construction and traversal of multiple conditional trees. In contrast, FT-MFI-PG remains the most efficient across all item_sup configurations, confirming that its compact FP-tree representation and effective pruning strategies allow it to scale well even when item_sup is low and the search space becomes significantly larger (Figs. 12, 13).

Memory consumption: Figure 14 compares the memory consumption of the algorithms during execution. Among them, VB-FT-Mine uses the least memory. This efficiency is primarily attributed to its bit-vector representation of transactions, where each item is encoded as a binary vector indicating its occurrence across all transactions. Through this encoding, multiple transactions are compressed within a single bit-vector element, significantly reducing storage overhead and minimizing data duplication during computation. Because all subsequent operations such as intersection or union of transactions are performed using lightweight bitwise operations, VB-FT-Mine maintains compact memory usage even on large datasets. In contrast, FT-MFI-PG consumes more memory than both VB-FT-Mine. This is mainly due to its use of the FP-tree structure for storing transactions. Each transaction contributes one or more nodes to the FP-tree, and additional memory is required to maintain pointers linking parent and child nodes. While this representation is efficient for compressing transactions with common prefixes, the node-based structure inherently introduces extra memory overhead compared to the compact bit-vector format. Finally, FT-MFI-MultiTree exhibits the highest memory usage among all compared algorithms. This method constructs multiple FP-trees to manage transactions with different FT mismatches. When transactions share a common prefix of items but differ in their allowed tolerance level, they are placed in separate FP-trees rather than being merged. This results in a significant duplication of structures, as redundant nodes and links must be created for similar transactions across different trees. For instance, when mining supersets of (ab) with , four FP-trees are required: one for transactions containing both a and b, one for those containing a but not b, one for those containing b but not a, and one for those missing both. This replication considerably increases memory consumption and reduces scalability compared to the proposed approach.

Fig. 14.

Memory consumption of FT-MFI mining algorithms on different datasets.

Algorithmic component analysis

The results in Table 16 present a detailed component analysis of the FT-MFI-PG algorithm, where execution time is measured in seconds for different datasets. Each configuration selectively removes or combines pruning strategies, thereby illustrating their individual and collective contributions to computational efficiency. The pruning components consist of FHUT and HUTMFI, which discard infrequent FT-MFIs and their supersets at an early stage, while the Max-FT-tree facilitates efficient maximal superset checking. The baseline “FT–MFI–PG – (all components)” corresponds to a simple traversal with no pruning, whereas “FT–MFI–PG + (all components)” represents the complete configuration with all pruning enabled.

Table 16.

Component analysis of FT–MFI–PG on benchmark datasets (execution time in seconds).

Configuration
Retail ( = 0.35%, = 0.06%)
FT–MFI–PG – (all components)	26	178
FT–MFI–PG – (FHUT)	21	145
FT–MFI–PG – (HUTMFI)	22	149
FT–MFI–PG – (Max-FT-tree)	23	162
FT–MFI–PG + (all components)	18	127
BMSWebView1 ( = 0.20%, = 0.02%)
FT–MFI–PG – (all components)	87	832
FT–MFI–PG – (FHUT)	67	769
FT–MFI–PG – (HUTMFI)	72	778
FT–MFI–PG – (Max-FT-tree)	80	824
FT–MFI–PG + (all components)	65	763
T10I4D100K ( = 1.7%, = 0.6%)
FT–MFI–PG – (all components)	104	3356
FT–MFI–PG – (FHUT)	92	3096
FT–MFI–PG – (HUTMFI)	95	3157
FT–MFI–PG – (Max-FT-tree)	98	3290
FT–MFI–PG + (all components)	84	2985
FoodMart ( = 0.09%, = 0.02%)
FT–MFI–PG – (all components)	1	102
FT–MFI–PG – (FHUT)	1	88
FT–MFI–PG – (HUTMFI)	1	89
FT–MFI–PG – (Max-FT-tree)	1	98
FT–MFI–PG + (all components)	1	87

Across all datasets, the inclusion of pruning consistently reduces execution time, confirming the effectiveness of these strategies. Both FHUT and HUTMFI yield substantial savings, with HUTMFI slightly outperforming FHUT, reflecting its more efficient superset lookups. The Max-FT-tree also contributes noticeably to reducing execution times by accelerating maximality verification. The combination of all components provides the largest savings, highlighting the complementary nature of these pruning strategies. When comparing dataset characteristics, a clear difference emerges between less sparse datasets (Retail and T10I4D100K) and more sparse datasets (BMSWebView1 and FoodMart). On less sparse datasets, where the number of potential itemsets and supersets is considerably higher, pruning has a much larger impact. For example, on T10I4D100K at , the execution time decreases from 3356 seconds with no pruning to 2985 seconds with all pruning components. Similarly, for the Retail dataset, the execution time reduces from 178 to 127 seconds. These improvements demonstrate that pruning is especially critical in dense settings where the search space grows exponentially. In contrast, the benefits of pruning are less pronounced on more sparse datasets. On FoodMart, the execution time at decreases from 102 seconds without pruning to 87 seconds with all pruning. The smaller gain can be explained by the inherently limited search space of sparse datasets, where fewer frequent itemsets exist and pruning opportunities are reduced. A similar trend is observed on BMSWebView1, where pruning improves execution time but with a smaller relative impact compared to dense datasets. Overall, the component analysis demonstrates that while all pruning components contribute to performance improvement, their impact is magnified in less sparse datasets with large numbers of frequent patterns.

Conclusion

In this paper, we introduce a new algorithm, FT-MFI-PG, that mines maximal fault-tolerant (FT) frequent itemsets using pattern-growth approach. The FT-MFI-PG algorithm provides several key improvements over traditional Apriori-based FT-MFI mining algorithms. First, it organizes FT transactions into a compact data structure known as the FT-FP-tree. By mapping transactions with similar itemsets along shared branches, this structure greatly reduces the effective size of the dataset during mining, which in turn allows for more efficient computation of itemset supports. Second, unlike Apriori-style approaches that generate all possible candidate itemsets level by level, FT-MFI-PG employs a pattern-growth strategy to generate candidates itemsets directly from the conditional patterns of the FT-FP-tree. This targeted generation ensures that only itemsets present in the dataset are considered, substantially lowering the total number of candidate itemsets and improving overall computational efficiency. We conducted a series of experiments to evaluate the performance of FT-MFI-PG in comparison to existing FT-MFI mining algorithms across multiple benchmark datasets with diverse sizes and transaction characteristics. The experimental results indicate that FT-MFI-PG outperforms existing FT-MFI mining algorithms, efficiently mining the complete set of FT-MFIs while scaling effectively to handle spare and dense datasets.

Although the proposed FT-MFI-PG algorithm demonstrates significant efficiency and scalability, its FP-tree–based structure is still subject to the well-known worst-case memory overhead of FP-trees. In particular, when transactions share very few common prefixes or when the dataset exhibits extremely high dimensionality with uniformly distributed items, the FP-tree may degenerate into a large, nearly uncompressed structure in which most branches are unique. Under such conditions, the FT-FP-tree and its associated FT conditional pattern tables may consume significantly more memory than in typical, prefix-rich datasets. This limitation is inherent to all FP-growth based approaches; therefore, while the proposed algorithm remains more memory efficient than prior FT pattern-growth algorithm that build multiple FP-trees, it may still experience elevated memory usage in datasets with minimal prefix sharing.

Furthermore, The current algorithm is designed for static transactional datasets and does not yet support incremental or real-time mining of fault-tolerant itemsets in dynamic data streams. Future extensions may focus on adaptive mechanisms for automatic adjustment based on observed data noise levels or evolving transaction characteristics. Furthermore, implementing parallel or distributed versions of FT-MFI-PG using multi-core or cluster based architectures could further improve performance for very large datasets. Additional research directions include mining the top-k FT frequent itemsets without relying on a minimum support threshold or discovering closed FT frequent itemsets to reduce redundancy.

Author contributions

Shariq Bashir (S.B.) designed the study, developed the methodology, performed the experiments, analyzed the results, and wrote the main manuscript. S.B. also prepared all figures and tables and reviewed and approved the final version of the manuscript.

Funding

This work was supported and funded by the Deanship of Scientific Research at Imam Mohammad Ibn Saud Islamic University (IMSIU) (grant number IMSIU-DDRSP2603).

Data availability

The datasets used in this study are publicly available from the Frequent Itemset Mining Dataset Repository (FIMI) at https://fimi.uantwerpen.be/data/

Declarations

Competing interests

The authors declare no competing interests.