Revisiting Numerical Pattern Mining with Formal Concept Analysis

1 Introduction

In this paper, we investigate the problem of mining numerical data. This problem arises in many practical situations, e.g. analysis of gene and transcriptomic data in biology, soil characteristics and land occupation in agronomy, demographic data in economics, temperatures in climate analysis, etc. We introduce an original framework for mining numerical data based on advances in itemset mining and in Formal Concept Analysis (FCA, [Ganter and Wille, 1999]), respectively condensed representations of itemsets and pattern structures in FCA [Ganter and Kuznetsov, 2001]. The mining of frequent itemsets in binary data, considering a set of objects and a set of associated attributes or items, is studied for a long time and usually involves the so-called "pattern flooding" problem [Bastide et al., 2000]. A way of dealing with pattern flooding is to search for equivalence classes of itemsets, i.e. itemsets shared by the same set of objects (or having the same image). For an equivalence class, there is one maximal itemset, which corresponds to a "closed set", and possibly several minimal elements corresponding to "generators" (or "key itemsets"). From these elements, families of association rules can be extracted. These itemsets are also related to FCA , where a concept lattice is built from a binary context and where formal concepts are closed sets of objects and attributes.

The present work is rooted both in FCA and pattern mining with the objective of extracting interval patterns from numerical data. Our approach is based on "pattern structures" where complex descriptions can be associatedwith objects. In [Kaytoue et al., 2011] we introduced closed interval patterns in the context of gene expression data mining. Intuitively, an interval pattern is a vector of intervals, each dimension corresponding to a range of values of a given attribute ; it is closed when composed of the smallest intervals characterizing a same set of objects.

In the present paper, we complete and extend this first attempt. Considering numerical data, some general characteristics of equivalence classes remain, e.g. one maximal element which is a closed pattern and possibly several generators which are minimal patterns w.r.t. a subsumption relation defined on patterns. We show that directly extracting patterns data from numerical is more efficient using pattern structures than working on binary data with associated scaling procedures. We also provide a semantics to interval patterns in the Euclidean space, design and experiment algorithms to extract frequent closed interval patterns and their generators.

The problem of mining patterns in numerical data is usually referred as quantitative itemset/association rule mining [Srikant and Agrawal, 1996]. Generally, an appropriate discretization splits attribute ranges into intervals maximizing some interest functions, e.g. support, confidence. However, none of these works covers the notion of equivalence classes, closed patterns, and generators, and this is one of the originality of the present paper.

The plan of the paper is as follows. Firstly, we introduce the problem of mining numerical data and interval patterns. Then, we recall the basics of FCA and interordinal scaling. We pose a number of questions that we propose to answer using our framework of interval pattern structures dealing with numerical data. We then detail two original algorithms for extracting closed interval patterns and their generators. These algorithms are evaluated in the last section on real-world data.

ing perspectives to the present research work. As a complement, an extended version of this paper is given in [Kaytoue et al., 2010], providing algorithms pseudo-code and a longer discussion on the usefulness of interval patterns in classification problems and privacy preserving data-mining.

2 Problem definition

We propose a definition of interval patterns for numerical data. Intuitively, each object of a numerical dataset corresponds to a vector of numbers, where each dimension stands for an attribute. Accordingly, an interval pattern is a vector of intervals, and each dimension describes the range of a numerical attribute. We only consider finite intervals and that the set of attributes/dimensions is assumed to bed (canonically) ordered.

Numerical dataset. A numerical dataset is given by a set of objects G, a set of numerical attributes M, where the range of m ∈ M is a finite set noted Wm. m(g) = w means that w is the value of attribute m for object g.

Interval pattern and support. In a numerical dataset, an interval pattern is a vector of intervals d = 〈[ai, bi]〉i∈{1,...,|M|} where ai, bi ∈ Wmi , and each dimension corresponds to an attribute following a canonical order on vector dimensions, and |M| denotes the number of attributes. An object g is in the image of an interval pattern 〈[ai, bi]〉i∈{1,...,|M|} when mi(g) ∈ [ai, bi], ∀i ∈ {1, ..., |M|}. The support of d, denoted by sup(d), is the cardinality of the image of d.

Running example. Table 1 is a numerical dataset with objects in G = {g1, ..., g5}, attributes in M = {m1,m2,m3}. The range of m1 is Wm1 = {4, 5, 6}, and we have m1(g1) = 5. Here, we do not consider either missing values or multiple values for an attribute. 〈[5, 6], [7, 8], [4, 6]〉 is an interval pattern in Table 1, with image {g1, g2, g5} and support 3.

Interval pattern search space. Given a set of attributes M = {mi}i∈{1,|M|}, the search space of interval patterns is the set D of all interval vectors 〈[ai, bi]〉i∈{1,...,|M|}, with ai, bi ∈ Wmi . The size of the search space is given by

Example. All possible intervals for m1 are in {[4, 4], [5, 5], [6, 6], [4, 5], [5, 6], [4, 6]}. Considering also attributes m2 and m3, we have 6 × 6 × 10 = 360 patterns.

The classical problem of "pattern flooding" in data-mining is even worst for numerical data. Indeed, with three attributes, there are only 23 = 8 possible itemsets, compared to the 360 interval patterns in the above example with same number of attributes. A solution widely investigated in itemset-mining for minimizing the effect of pattern flooding relies on condensed representations including closed itemsets and generators [Bastide et al., 2000]. By contrast, the analysis of numerical datasets can be considered within the formal concept analysis framework (FCA) [Ganter and Wille, 1999], which is closely related to itemset-mining [Stumme et al., 2002]. Accordingly, we are interested in adapting the notions of (frequent) closed itemsets and their generators to interval patterns within the FCA framework, and in providing an appropriate semantics to these patterns.

3 Interval patterns in FCA

[Ganter and Wille, 1999] define a discretization procedure, called interordinal scaling, transforming numerical data into binary data that encodes any interval of values from a numerical dataset. We recall here the basics on FCA and interordinal scaling.

3.1 Formal concept analysis

FCA starts with a formal context (G,N, I) where G denotes a set of objects, N a set of attributes, or items, and I ⊆ G × N a binary relation between G and N. The statement (g, n) ∈ I, or gIn, means: "the object g has attribute n". Two operators (·)′ define a Galois connection between the powersets (P(G), ⊆) and (P(N), ⊆), with A ⊆ G and B ⊆ N: A′ = {n ∈ N | ∀g ∈ A : gIn} and B′ = {g ∈ G | ∀n ∈ B : gIn}. A pair (A,B), such that A′ = B and B′ = A, is called a (formal) concept, while A is called the extent and B the intent of the concept (A, B).

From an itemset-mining point of view, concept intents correspond to closed itemsets, since (.)′′ is a closure operator. An equivalence class is a set of itemsets with same closure (and same image). For any subset B ⊆ N, B′′ is the largest itemset w.r.t. set inclusion in its equivalence class. Dually, generators are the smallest itemsets w.r.t. set inclusion in an equivalence class. Precisely, B ⊆ N is closed iff ∄C such as B ⊂ C with C′ = B′ ; B ⊆ N is a generator iff ∄C ⊂ B with C′ = B′ .

3.2 Interordinal scaling

Given a numerical attribute m with range Wm, Interordinal Scaling builds a binary table with 2 × |Wm| binary attributes. They are denoted by "m ≤ w" and "m ≥ w", ∀w ∈ Wm, and called IS-items. An object g has an IS-item "m ≤ w" (resp. "m ≥ w") iff m(g) ≤ w (resp. m(g) ≥ w). Applying this scaling to our example gives Table 2. It is possible to apply classical mining algorithms to process this table for extracting itemsets composed of IS-items. These itemsets are called ISitemsets in the following.

IS-itemsets can be turned into interval patterns, since an IS-item gives a constraint on the range Wm of an attribute m. For example, the IS-itemset {m1 ≤ 5,m1 ≤ 6,m1 ≥ 4,m2 ≤ 9,m2 ≥ 7} corresponds to the interval pattern 〈[4, 5], [7, 9], [4, 8]〉. We have here the interval [4, 8] for attribute m3: [4, 8] covers the whole range of m3 since no constraint is given for m3.

Therefore, mining interval patterns can be considered with a scaling of numerical data. However, this scaling produces a very important number of binary attributes compared to the original ones. Hence, when original data are very large, the size of the resulting formal context involves hard computations. Accordingly, this raises the following questions:

(i) Can we avoid scaling and directly work on numerical data instead of searching for IS-itemsets? (ii) Can we adapt the notions of condensed representations such as closed patterns and generators for numerical data, and efficiently compute those patterns? (iii) What would be the semantics that could be provided to closed patterns and generators?

4 Revisiting numerical pattern mining

In this section, we answer those questions. First, we show that a closure operator can be defined for interval patterns based on their image. Then, we provide interval patterns with an appropriate semantics for defining the notion of equivalence classes of patterns, closed and generator patterns. After discussing why working with interordinal scaling is not acceptable thanks to the semantics of interval patterns, we propose two efficient algorithms for mining closed interval patterns and generators. Experiments follow in Section 5.

4.1 A closure operator for interval patterns

We introduce the formalism of pattern structures [Ganter and Kuznetsov, 2001], an extension of formal contexts for dealing with complex data in FCA. It defines a closure operator for a partially ordered set of object descriptions called patterns.

Formally, let G be a set of objects, (D, ⊓) be a semilattice of object descriptions, and δ : G → D be a mapping: (G, (D, ⊓), δ) is called a pattern structure. Elements of D are called patterns, and are ordered as follows c ⊓ d = c ⇐⇒ c ⊑ d. Intuitively, objects in G have descriptions in (D, ⊓). For example, g1 in Table 1 has description 〈[5, 5], [7, 7], [6, 6]〉 where D is the set of all possible interval patterns ordered with ⊓, as made precise below. Consider the two operators (.)□ defined as follows, with A ⊆ G and d ∈ (D, ⊓)

These operators form a Galois connection between (P(G),⊆) and (D,⊑). (.)□□ is a closure operator, meaning that any pattern d such as d = d□□ is closed.

Interval pattern structures. This general closure operator can be used for interval patterns. Indeed, interval patterns can be ordered within a meet-semi-lattice when the infimum is defined as follows. Let c = 〈[ai, bi]〉i∈{1,...,|M|}, and d = 〈[ei, fi]〉i∈{1,...,|M|} two intervals patterns. Their infimum is given by c ⊓ d = 〈[min(ai, ei),max(bi, fi)]〉i∈{1,...,|M|}. The ordering relation induced by this definition is: c ⊑ d ⇐⇒ [ei, fi] ⊆ [ai, bi], ∀i ∈ {1, ..., |M|}.

Consider now a numerical dataset, e.g. Table 1. (D,⊑) is the finite ordered set of all interval patterns. δ(g) ∈ D is the pattern associated to an object g ∈ G. Then:

This means that 〈[5, 6], [7, 8], [4, 8]〉 is not a closed interval pattern, its closure being 〈[5, 6], [7, 8], [4, 6]〉.

4.2 Semantics

An interval pattern d is a |M|-dimensional vector of intervals and can be represented by a hyper-rectangle (or rectangle for short) in Euclidean space R|M| , whose sides are parallel to the coordinate axes. This geometrical representation provides a semantics for interval patterns. In formal terms, an interpretation is given by I = (R|M| , (.)I ) where R|M| is the interpretation domain, and (.)I : D→R|M| the interpretation function. Figure 1 gives four interval pattern representations in R2 , with only attributes m1 and m3 of our example. The image of d1 is given by all objects g whose description δ(g) is included in the rectangle associated with d1, i.e. the set {g1, g3, g4, g5}. We can interpret the closure operator (.)□□ according to this semantics. The first operator (.)□ applies to a rectangle and returns the set of objects whose description is included in this rectangle. The second operator (.)□ applies to a set of objects and returns the smallest rectangle that contains their descriptions, i.e. the convex hull of their corresponding descriptions.

4.3 Closed interval patterns and generators

Now, we can revisit the notion of equivalence classes of itemsets as introduced in [Bastide et al., 2000]: an equivalence class of interval patterns is a set of rectangles containing the same object descriptions (based on all rectangles in the search space as given in Section 2). This enables to define the notions of (frequent) closed interval patterns ((F)CIP) and (frequent) interval pattern generators ((F)IPG), adapted itemisets.

Equivalence class. Two interval patterns c and d with same image are equivalent, i.e. c□ = d□ and we write c ∼= d. ∼= is an equivalence relation, i.e. reflexive, transitive and symmetric. The set of patterns equivalent to a pattern d is denoted by [d] = {c|c ∼= d} and called the equivalence class of d.

Closed interval pattern (CIP). A pattern d is closed if there does not exist any pattern e such as d ⊑ e with d ∼= e.

Interval pattern generator (IPG). A pattern d is a generator if there does not exist a pattern e such as e ⊑ d with d ∼= e. Frequent Interval pattern. A pattern d is frequent if its image has a higher cardinality than a given minimal support threshold minSup.

We illustrate these definitions with two dimensional interval patterns, and their representation in Figure 1, i.e. considering attributes m1 and m3 only. 〈[4, 5], [6, 8]〉 ∼= 〈[4, 6], [6, 8]〉 with image {g1, g4}. 〈[4, 6], [6, 8]〉 is not closed as 〈[4, 6], [6, 8]〉 ⊑ 〈[4, 5], [6, 8]〉, these two patterns having same image, i.e. {g1, g3, g4, g5}. 〈[4, 5], [5, 8]〉 is closed. 〈[4, 6], [5, 8]〉 and 〈[4, 5], [4, 8]〉 are generators in the class of the closed interval pattern d1 = 〈[4, 5], [5, 8]〉 with image {g1, g3, g4, g5}. Among the four patterns in Figure 1, d1 is the only frequent interval pattern with minSup = 3.

Based on the above semantics, an equivalence class is a set of rectangles containing the same set of object descriptions, with a (unique) closed pattern corresponding to the smallest rectangle, and one or several generator(s) corresponding to the largest rectangle(s).

These definitions are counter-intuitive w.r.t. itemsets: the smallest rectangles subsume the largest ones. This is due to the definition of infimum as set intersection for itemsets while this is convex hull for intervals, which behaves dually as a supremum.

4.4 IS-itemsets versus interval patterns

Interordinal scaling allows to build binary data encoding all interval of values from a numerical dataset. Therefore, one may attempt to mine closed itemsets and generators in these data with existing data-mining algorithms. Here we show why this should be avoided.

Local redundancy of IS-itemsets. Extracting all ISitemsets in our example (from Table 2) gives 31, 487 ISitemsets. This is surprising since there are at most 360 possible interval patterns. In fact, many IS-itemsets are locally redundant. For example, {m1 ≤ 5} and {m1 ≤ 5,m1 ≤ 6} both correspond to interval pattern 〈[4, 5], [7, 9], [4, 8]〉: the constraint m1 ≤ 6 is redundant w.r.t. m1 ≤ 5 on the set of values Wm1 . Hence there is no 1-1-correspondence between IS-itemsets and interval patterns. It can be shown that there is a 1-1-correspondence only between closed IS-itemsets and CIP [Kaytoue et al., 2011]. Later we show that local redundancy of IS-itemsets makes the computation of closed sets very hard.

Global redundancy of IS-itemset generators. Since ISitemset generators are the smallest itemsets, they do not suffer of local redundancy. However, we can remark another kind of redundancy, called global redundancy: it happens that two different and incomparable IS-itemset generators correspond to two different interval pattern generators, but one subsuming the other. In Table 2, both IS-itemsets N1 = {m1 ≤ 4,m3 ≤ 5} and N2 = {m1 ≤ 4,m3 ≤ 6} have the same image {g3} and are generators, i.e. there does not exist a smaller itemset of these itemsets with same image. However, their corresponding interval pattern are respectively c = 〈[4, 4], [7, 9], [4, 5]〉 and d = 〈[4, 4], [7, 9], [4, 6]〉 and we have d ⊑ c, while c□ = d□, hence c is not an interval pattern generator.

4.5 Algorithms

We detail a depth-first enumeration of interval patterns, starting with the most frequent one. Based on this enumeration, we design the algorithms MinIntChange and MinIntChangeG for extracting respectively frequent closed interval patterns (FCIP) and frequent interval pattern generators (FIPG).

Interval pattern enumeration. Consider firstly one numerical attribute of the example, say m1. The semi-lattice of intervals (Dm1 , ⊓) is composed of all possible intervals with bounds in Wm1 and is ordered by the relation ⊑. The unique smallest element w.r.t. ⊑ is the interval with maximal size, i.e. [4, 6] = [min(Wm1 ),max(Wm1 )] and maximal frequency (here 5). The basic idea of pattern generation lies in minimal changes for generating the direct subsumers of a given pattern. For example, two minimal changes can be applied to [4, 6]. The first consists in replacing the right bound with the value of Wm1 immediately lower that 6, i.e. 5, for generating the interval [4, 5]. The second consists in repeating the same operation for the left bound, generating the interval [5, 6]. Repeating these two operations allows to enumerate all elements of (Dm1 , ⊓). A right minimal change is defined formally as, given a, b, v ∈ Wm, a ̸= b, mcr([a, b]) = [a, v] with v < b and ∄w ∈ Wm s.t. v < w < b while a left minimal change mcl([a, b]) is formally defined dually. Minimal changes give direct next subsumers and implies a monotonicity property of frequency, i.e. support of [a, v] is less than or equal to support of [a, b]. To avoid generating several times the same pattern, a lectic order on changes, or equivalently on patterns, is defined. After a right change, one can apply either a right or left change; after a left change one can apply only a left change. Figure 2 shows the depth-first traversal (numbered arrows) of diagram of (Dm1 , ⊓). Backtrack occurs when an interval of the form [w,w] is reached (w ∈ Wm1 ), or no more change can be applied. Each minimal change can be interpreted in term of an IS-item. For example, if [a, b] corresponds to the IS-itemsets {m ≥ a,m ≤ b} then mcr([a, b]) = [a, v] corresponds to {m ≥ a, m ≤ b, m ≤ v}, i.e. adding m ≤ v to the original IS-itemset. The same applies dually to left minimal changes. These IS-items characterizing minimal changes are drawn on Figure 2. This figure accordingly represents a prefix-tree, factoring out the effort to process common prefixes or minimal changes, and avoiding redundancy problems inherent in interordinal scaling. The generalization to several attributes is straightforward. A lectic order is classically defined on numerical attributes as a lexicographic order, e.g. m1 < m2 < m3. Then changes are applied as explained above for all attributes respecting this order, e.g. after applying a change to attribute m2, one cannot apply a change to attribute m1.

Extracting FCIP with MintIntChange. The pattern enumeration starts with the minimal pattern w.r.t ⊑ and generates its direct subsumers with lower or equal support. The next problem now is that minimal changes do not necessarily generate patterns with strictly smaller support. Therefore, we should apply changes until a pattern with different support is generated to identify a closed interval pattern (FCIP) but this would not be efficient. We adopt the idea of the algorithm CloseByOne [Kuznetsov and Obiedkov, 2002]: before applying a minimal change, the closure operator (.)□□ is applied to the current pattern, allowing to skip all equivalent patterns. Indeed, the minimal pattern d w.r.t. ⊑ is closed as it is given by d = G□. Applying a minimal change returns a pattern c with strictly smaller support, since d ⊑ c and d is closed. If c is frequent, we can continue, apply the closure operator and next changes in lectic order, allowing to completely enumerate all FCIP. Since a FCIP may have several different associated generators, it can be generated several times. Still following the idea of CloseByOne, a canonicity test can be defined according to lectic order minimal changes.

Consider a pattern d generated by a change at attribute mj ∈ M. Its closure is given by d□□. If d□□ differs from d for some attributes mh ∈ M such as mh < mj , then d□□ has already been generated: it is not canonically generated, hence the algorithms backtracks.

Example. We start from the minimal pattern d = 〈[4, 6], [7, 9], [4, 8]〉. The first minimal change in lectic order is a right change on attribute m1. We obtain pattern c = 〈[4, 5], [7, 9], [4, 8]〉, and obviously d ⊑ c. However, c□□ = 〈[4, 5], [7, 9], [5, 8]〉, hence c is not closed. c□□ is stored as FCIP and next changes will be applied to it.

Now consider the pattern obtained by minimal change on left border for attribute m3, i.e. e = 〈[4, 6], [7, 9], [5, 8]〉. We have e□□ = 〈[4, 5], [7, 9], [5, 8]〉. e and e□□ differ for attribute m1, but e has been generated from a change on m3. Since m1 < m3, e□□ is not canonical and has already been generated (previous example), hence the algorithm backtracks.

Extracting FIPG with MintIntChangeG. We now adapt MinIntChange to extract FIPG, following a well-known principle in itemset-mining algorithms [Calders and Goethals, 2005]. For any FCIP d, a minimal change implies that the support of the resulting pattern c is strictly smaller than the support of d. Therefore, c is a good generator candidate of the next FCIP. Accordingly, at each step of the depth-first enumeration a FIPG candidate c is generated from the previous one b, by applying a minimal change characterized by b□□. Then, each candidate c has to be checked whether it is a generator or not. We know that the candidate has no subsumers in its branch with same support. However, it could exist a branch with another FIPG e with same image and resulting from less changes. Considering the lectic order on minimal changes, we use a reverse traversal of the tree (see Figure 2: 7,8,9,10,1,4,5,2,3,6), as already suggested in the binary case in [Calders and Goethals, 2005]. Since generators correspond to largest rectangles, i.e. on which the fewest minimal changes have been applied, if c is not a generator, a generator e associated to its equivalence class has already been generated, and c is discarded. To check the existence of e, we look up in an auxiliary data-structure storing already extracted FIPG. Precisely, if the data structure contains a FIPG e with same support than candidate c, such that e ⊑ c, c is discarded, and the algorithm backtracks. Otherwise c is declared as a FIPG and stored. We have experimented the MinIntChangeG algorithm with two well-known and adapted data structures, a trie and a hashtable.

5 Experiments

We evaluate the performances of the algorithms designed in Java, namely MinIntChange, MinIntChangeG-h with auxiliary hashtable and MinIntChangeG-t with auxiliary trie. Recalling that closed IS-itemsets and CIP are in 1-1correspondence, we compare the performance for mining interordinal scaled data with the closed-itemset-mining algorithm LCMv2 [Uno et al., 2004]. For studying the global redundancy effect of IS-itemset generators, we use the generator-mining-algorithmGrGrowth [Liu et al., 2006]. Both implementations in C++ are available from the authors. All experiments are conducted on a 2.50Ghz machine with 16GB RAM running under Linux 2.6.18-92.e15. We choose dataset from the Bilkent repository 1 , namely Bolts (BL), Basketball (BK) and Airport (AP), AP being worst case where each attribute value is different.

First experiments compare MinIntChange for extracting FCIP and LCMv2 for extracting equivalent frequent closed IS-itemsets in Table 3. Second experiments consist in extracting frequent interval pattern generators (FIPG) with MinIntChange-h and MinIntChange-t. We also extract frequent itemset generators (FISG) in corresponding binary data after interordinal scaling with GrGrowth for studying the global redundancy effect in Table 4.

In both cases, using binary data is better when the minimal support is high (e.g. 90%). For low supports, a critical issue, our algorithms deliver better execution times. Most importantly, the global redundancy effect discards the use of binary data, e.g. only 1.6% of all FISG are actually FIPG in dataset BL. Finally, the algorithm MinIntChangeG-t outperforms MinIntchangeG-h. MinIntChangeG-t however needs more memory since it stores each closed set of objects as a word in the trie, and to each word the list of associated FIPG.

It is very interesting to analyse the compression ability of closed interval patterns and generators. For that, we compare in each dataset the number of those patterns w.r.t. to all possible interval patterns. It gives the ratio of closed (generators) in the whole search space. In both cases, ratio varies between 10-7 and 10-9. This means that the volume of useful interval patterns, either closed or generators, is very low w.r.t. the set of all possible interval patterns, justifying our interest in equivalence classes for interval patterns.

1 http://funapp.cs.bilkent.edu.tr/

6 Conclusion

We discussed the important problem of pattern discovery in numerical data with a new and original formalization of interval patterns. The classical FCA/itemset-mining settings are adapted accordingly: from a closure operator naturally rise the notions of equivalence classes, closed and generator patterns, and we designed corresponding algorithms. An appropriate semantics of interval patterns shows from a theoretical (redundancy) and practical (computation times) points of view that mining equivalent binary data (encoding all possible intervals) is not acceptable. This is due to the fact that interval patterns are provided with a stronger partial ordering than IS-itemsets (classical set inclusion), hence pattern structures yield significantly less generators w.r.t. their semantics.

Dealing with interval patterns has applications in computational geometry, machine learning and data-mining, e.g. [Boros et al., 2003] and references therein. It is indeed highly related to the actual problem of (maximal) k-boxes which corresponds to interval patterns (generators) with support k. When k = 0, it corresponds to largest empty subspaces of the data. Our contribution to this field is the characterization of smaller subsets (closed and generators).

In data-mining, closed patterns and their generators are crucial for extracting valid and informative association rules [Bastide et al., 2000], while generators can be preferable to closed patterns following the minimum descriptions length principle for so-called itemset-based classifiers [Li et al., 2006]. How these notions can be shifted to interval patterns is an original perspective of research rising questions concerning missing values, fault-tolerant patterns, and interestingness measures that are critical issues even in classical itemset mining: although the compression ability of closed interval patterns and generators is spectacular, the number of patterns remains too high for large datasets. However, bringing the problem of numerical pattern mining into well known settings in favor of these perspectives of research.