We present here a second algorithm in order to show that when the closure operator has additional properties, someone need to leverage them in order to enumerate its fixpoints more efficiently. We consider here for instance the following subproblem of Problem 4.1.
Problem 4.3. Let E be a finite set and letσbe a closure operator on (℘(E), ⊆) having the anti-exchange property:
(∀S ∈σ[℘(E)], ∀e1, e2∈ E) e1∈σ(S ∪ {e2}) ⇒ e26∈σ(S ∪ {e1})
List all fixpointsσ[℘(E)].
Note 4.7. Please note that according to Theorem 4.1, Problem 4.3 is equivalent to enumerate all elements of a convex geometryF. Indeed, set system (E,σ[℘(E)]) is a convex geometry and any convex geometry can be induced by a closure operator having the anti-exchange property.
Algorithm 2, namely Extreme points Removal Closed Set Listing orExRfor short, is a correct enumeration algorithm for Problem 4.3. It performs a top-down and depth-first traversal of
σ[F]. It starts from the top element E which is always closed by extensivity ofσ(Line 7) then enumerates in depth-first fashion the convex sets inσ[℘E]. Rather than performing closures, Algorithm 2 relies on Proposition 4.10, i.e. to create new closed set, it does successive extreme points removal (Line 4). To ensure non-redundancy, Algorithm 2 maintains a set of banned elements (Line 6), i.e. whenever an extreme point is removed from a closed set C, it is forbidden to remove it in the next iterations.
Algorithm 2:ExR(Extreme points Removal Closed Set Listing) Algorithm Input: A finite set E and
a closure operatorσon (℘(E), ⊆) having the anti-exchange property Output: Elements of the convex geometryσ[℘(E)]
1 procedureExR(C, B)
2 Print(C) // Output the convex set φ[℘(E)]
3 for e ∈ ex(C)\B do
4 Cnew ← C\{e} // generate a new convex set Cnew since e ∈ ex(C)
5 ExR(Cnew, B)
6 B ← B ∪ {e} // Element e can not be removed in the next iterations
7 ExR(E, ;) // Enumeration starts here on E
Theorem 4.3 provide the computation and space complexities of Algorithm 2.
Theorem 4.3. Algorithm 2 solves Problem 4.3 with the following complexities:
delayO(|E| · (Tex+ |E|)) , and
totalO(|E| · (Tex+ |E|) · |F|) , and
spaceO¡|E|2+ Sex¢
Where Texand Sexare respectively the time and space complexity of computing the extreme
points of a given convex set.
Proof. To see the delay complexity, one should notice that the algorithm cannot backtrack more that |E| times without printing an element. Each call ofExRcosts one extreme points computation Texand manipulation (union, difference) of sets of sizeO(|E|). The formula of
delay complexity follows. The total complexity is directly deducted from the delay complexity. For the space complexity follow also from the fact that there is no more than |E| + 1 nested call ofExRalgorithm. Notice that in each callExRmanipulates a constant set of variable of sizeO(|E|), adding the space cost of extreme points computation Sexat each call, the formula
C
H
A
P
5
E
NUMERATION INP
ATTERNS
ETUPSW
e have seen in Chapter 3 that pattern languages can be seen as ordered sets. Partic- ularly, we considered the general case of pattern setups to model pattern languages over a dataset. The aim of this chapter is to investigate the following problem:Problem 5.1. LetP = (G, (D, v),δ) be a finite pattern setup (i.e. set of objectsG is finite). List all definable sets inPextnon-redundantly.
It is clear thatPextis a set system onG. Moreover, when the considered pattern setupP is
a pattern structure, the set systemPext is closed-under-intersection which associated closure
operator is ext ◦ int. Therefore, we will often use here results from Chapter 4 to propose correct algorithms solving Problem 5.1. The following of this chapter is organized as follow:
• Section 5.1 investigates a sub-problem of Problem 5.1 when the considered pattern setup is a pattern structure over itemsets (or equivalently a formal context).
• Section 5.2 extends the state-of-the-art by proposing a new algorithm for enumerating definable sets of a formal context by leveraging the implications existing inherently between its attributes. This contribution had appeared in [16].
• Section 5.3 considers the larger problem of enumerating definable sets of an arbitrary pattern structure.
• Section 5.4 considers Problem 5.1 for the particular pattern structure of interval patterns in numerical datasets.
• Section 5.5 considers the convex set pattern language and three algorithms solving Prob- lem 5.1 for finite pattern structures induced by this language. The results presented in this section were introduced in [20].
• Section 5.6 concludes this chapter by discussing Problem 5.1 for the general case of pattern setups. Recall that sequential patterns [6] does not induce a pattern structure [48].
5.1
Enumeration in Formal Contexts
In this section, we will consider Problem 5.1 where the inputs are restricted to formal contexts P = (G,M,I) with finite set of objectsG and finite the set of attributesM. All the notations we use here follow Section 3.2 on formal contexts. The new sub-problem is formulated below:
Problem 5.2. LetP = (G,M,I) be a formal context with a finite set of objectsG and a finite the set of attributesM. List all definable sets inPext non-redundantly.
Solving Problem 5.2 is tightly linked to enumerating fixpoints of a given closure operator that was thoroughly investigated in the literature. We have seen in Section 4.3.2 that many algorithms solving this later problem (e.g. [33, 76, 109, 110]) follows the same enumeration scheme, i.e. divide-&-conquer scheme, as stated by Gély [83] and later by [29] for a further generalization. The general Algorithm is dubbedD&Cand is presented in Algorithm 1. We will present here two particular algorithms solving Problem 5.2 in formal contexts which is CLOSE-BY- ONE(CBO) [109, 110]. Both algorithms rely on the fact that the pair of operators (ext, int) form a Galois connection between posets (℘(G), v) and (℘(M), v) (Proposition 3.1). Hence, mappings ext ◦ int and int ◦ ext are closure operators on (℘(G), v) and (℘(M), v) respectively. Hence, one can rely on Algorithm 1 to enumerate all extents inPextusing two different approaches.
• Algorithm CLOSE-BY-ONE BOTTOM-UPenumerate extents in a Depth-first search and bottom up fashion, i.e. from small extents to bigger ones. It uses the closure operator ext ◦ int on the powerset set system℘(G).
• Algorithm CLOSE-BY-ONETOP-DOWNenumerate extents in a Depth-first search and top down fashion, i.e. from bigger extents to smaller ones. It uses the closure operator int ◦ ext on the powerset set system℘(M) and the fact that there is a one-to-one correspondance with the set of fixpoints of int ◦ ext given by Pintand the extentsPext, i.e.Pext= ext[Pint].