1

Introduction

Designing class models for information systems, databases or programs is a common activity, that usually involves domain experts and designers. Their task consists in capturing the domain concepts, and organizing them in a relevant specialization structure with adequate abstractions and avoiding redundant concepts. Formal Concept Analysis (FCA) and its variant Relational Concept Analysis (RCA) have been proposed to assist this elaboration phase, so as to introduce new abstractions emerging from the identied domain concepts, and to set up a factorization structure avoiding duplication. FCA classies entities having characteristics 1 , while RCA also takes into account the fact that entities are linked by relations. The concept lattices produced can be exploited so as to obtain the generalization structure for the class model. Nevertheless, while this whole factorization structure of a class model is a mathematical object with strong theoretical properties, its practical use might suer from limitations due to the large size of the obtained lattices. In such a case, domain experts might be overwhelmed by the produced information making it dicult (or even impossible) to use it to improve the class model.

In this paper we want to assess, in a real case study, the size of the factorization results, in order to have a solid foundation for proposing practical recommendations, tools or approaches. We work with a kind of "worst case" of RCA application, by using all the modeling elements and not limiting our investigation to some elements (like classes and attributes, or classes and operations). We show, via various selected graphics, how RCA behaves. Our experiments indicate which congurations are tractable, admitting that some tools present results in a ne way, and which congurations lead to quite unusable results.

The rest of the paper is structured as follows. Section 2 briey explains how FCA and RCA can contribute to a class model design. Section 3 settles the environment for our experiments and introduces our case study. Section 4 presents and discusses the obtained results. Section 5 presents related work, and section 6 concludes.

In this section, we explain how concept lattices implement and reveal the underlying factorization structure of a class model. We also show how this property can be exploited for class model refactoring, and in particular: generating new reusable abstractions that improve the class organization and understanding, especially for domain experts, limiting attribute and role duplication.

Formal Concept Analysis [5] is a mathematical framework that groups entities sharing characteristics: entities are described by characteristics (in a Formal Context), and FCA builds (formal) concepts from this description. In Relational Concept Analysis (RCA) [9], the data description consists of several Formal Contexts and relations. The main principle of RCA is to iterate on FCA application, and the concepts learnt during one iteration for one kind of entity are propagated through the relations to the other kinds of entities. The concepts are provided with a partial order which is a lattice. In the obtained concept lattices, we distinguish merged concepts and new concepts. A merged concept is a concept that has more than one entity in its simplied extent. This means that the entities of the simplied extent share the same description. A new concept is a concept that has an empty simplied extent. This means that no entity has exactly the simplied intent of the concept as set of characteristics: Entities of the whole extent own the characteristics of the simplied intent in addition to other characteristics.

To apply FCA to class models, we encode the elements of a class model into formal contexts. For example, we provide a context describing the classes by their attributes. The FCA approach then reveals part of the factorization structure and supports part of the refactoring process by using a straightforward description of UML elements. For example, we can discover new concepts for classes interpreted as new super-classes, factorizing two attributes. Nevertheless this approach does not fully exploit the deep structure of the class model. Let us take the example of Figure 1(a). The attribute name is duplicated in classes B1 and B2, and FCA can generate the model of Figure 1(b) that introduces a new class (here manually named NamedElement) that factorizes this attribute. However, FCA does not compute the factorization that can be found in Figure 1(c), in which a class called SuperA factorizes the two associations from A1 to B1 and from A2 to B2, being given that now B1 and B2 have an ancestor NamedElement. Extracting abstractions using this deep structure can be done with RCA, which builds the entire factorization structure, including information on the elements (classes, attributes, associations) and their relations. RCA uses the fact that classes are linked through associations. In the rst iteration step, RCA computes the factorization in Figure 1(b), and then propagates the new concept NamedElement through the association between classes. Then the factorization of Figure 1(c) is computed during the next iteration steps. The process stops there since a xpoint is found (no new abstractions can be found).

The obtained structure contains no duplication, and improves the organization of the model. However, when applied on large data, RCA may result in the introduction of many new concepts , that may be too abstract, and/or too many to be analyzed. That is why in the next sections, we investigate on a case study the behavior of RCA for a large class model corresponding to an actual information system. Our objective is to determine if RCA remains suitable for large class models, and how to congure RCA to obtain exploitable results. 3 The Pesticides class model and experimental setup Our case study is a class model which is part of a project from the Irstea institute, called Environmental Information System for Pesticides (EIS-Pesticides). It aims at designing an information system centralizing knowledge and information produced by two teams: a Transfer team in charge of studying the pesticide transfers from plots to rivers and a Practice team which mainly works on the agricultural practices of the farmers. The domain analysis has been carried on during series of meetings with one team or both teams. Fifteen versions of this class model have been created during this analysis. Figure 2 shows the number of model elements over the versions. Our tool is based on the Modeling Tool Objecteering2 and the framework eRCA 3 . eRCA has been extended for computing metrics. In this paper we focus on a conguration (part of the meta-model) including the following entities described in formal contexts: classes, associations, operations (very few in the Pesticides model), roles and attributes. Their characteristics are their names. The relations describe: which class owns which attribute, which class owns which operation, which class owns which role, which association owns which role and which type (class) has a role. When applying RCA to this conguration, we obtain 5 concept lattices, one for each formal context. We also consider four parameterizations for this conguration depending on whether we take into account navigability and undened elements. If a navigability is indicated on an association, meaning that objects from the source know objects from the target (not the reverse), taking into account navigability (denoted by Nav) results in the following encoding: the source class owns the corresponding role, but the target class does not own any role corresponding to that association. Not taking into account navigability (denoted by noNav) means that the source class and the target class own their respective role in the association. In the modeling tool, unnamed roles are named "undened". We can choose to include this "undened" name in the contexts (denoted by Undef) or not (denoted by noUndef). 4

In this section, we report the main results that we obtain. We consider two special iteration steps: step 1 (close to FCA application) and step 6 (where paths of length 6 in the model are followed, meaning that abstractions on classes created at step 1 have been exploited to create other class abstractions through roles and associations). At step 1 for example, common name attributes are used to nd new superclasses. At step 4, new superclasses can be found as shown in Figure 1(c), and 2 steps later, new super-associations can be found from the class concepts found at step 4. We examine, for classes and associations, which are the main elements of the model, metrics on new class concepts and new associations concepts (Section 4.1), then on merge class and association concepts (Section 4.2). Execution time is presented in Section 4.3, and we conclude this part by giving indications about the number of steps when the process reaches the xpoint.

We focus rst on the new concepts that appear in the class lattice and in the association lattice. They will be interpreted as new superclasses or as new generalizations of associations. In a collaborative work, these concepts are presented to the experts who use some of them to improve the higher levels of the class model with domain concepts not explicit until then. This is why their number is important; if too many new abstractions are presented to the experts, these experts might be overwhelmed by the quantity, preventing a relevant and ecient use of the method. Figure 3 (left-hand side) shows the new concepts in the class lattice (thus the new superclasses) at step 1, when paths of size 1 have been traversed. For example, this means that if some classes have attributes (or roles) of the same name in common, those attributes (or roles) will certainly be grouped in a new class concept. This new class concept can be presented to the expert to control if this corresponds to a new relevant class abstraction (or superclass). We notice that Nav parameterizations produce less new concepts than noNav ones. This is due to the fact that noNav parameterizations induce much more circuits in the analyzed data, increasing the number of RCA steps and the number of generated concepts. The number of new concepts decreases as the analysis process progresses.

Step 1

Step 6 Fig. 3. New class abstractions created at step 1 and 6 v.s. the number of initial classes

In the best case (of percentage of new superclasses), 32% of new potential superclasses will be presented to the experts, for the model V11 which contains 170 classes, giving 54 new potential superclasses. In the worst case, we have 112% of new potential superclasses, for V0 model, which has 34 classes, thus only 38 new potential superclasses are found. At this stage, we do not see a serious dierence between the four parameterizations.

Results obtained at step 6 are much more dicult to deal with. Figure 3 (right-hand-side) shows that the two parameterizations noNav (generating more cycles in data) give results that will need serious ltering to separate relevant new concepts from the large set of new concepts . Nav parameterizations will produce less than one and a half the initial number of classes, while noNav parameterizations can produce up to 10998 class concepts, really requiring either additional post-treatments or avoiding to generate all the concepts.

Figure 4 (left-hand side) shows the new concepts in the association lattice at step 1. They represent associations that are at a higher level of abstraction. Experts can examine them, to see if they can replace a set of low-level associations. In Nav parameterizations, at most 15 higher level associations are presented to experts; in noNav parameterizations, the number grows until 32, remaining very reasonable to analyze.

Figure 4 (right-hand side) shows the new concepts in the association lattice at step 6. It highlights the fact that, at this step, the number of these concepts may explode, and it is especially high in the last versions of the class model, in which we initially have many associations. The number of new association concepts, in Nav parameterizations, is less than a hundred, and it still remains reasonable (even if it is higher than in step 1), but in noNav parameterizations it dramatically grows and may reach about 9500 concepts.

Step 1

Step 6 Fig. 4. New association abstractions created at step1 and 6 v.s. the number of initial associations 4.2 Merged concepts

Merged concepts are concepts which introduce several entities (e.g classes or associations) in their extent. Such entities share exactly the same description in the model. For example, a merge class concept can group classes that have exactly the same name attributes. This common description is rst detected at step 1, then it does not change because the following steps rene the description by adding new relational characteristics and concepts; entities remain introduced in the same concepts. For classes and associations, the merged concept number is the same for the four analysis congurations. For experts, analyzing a merged concept consists in reviewing the simplied extent and examining if the entities (class or association) have been exhaustively described or eectively correspond to a same domain concept. Figure 5 (left-hand side) presents metrics for merge class concepts. V5 and V6 have a higher percentage of merged concepts because during analysis, a package has been duplicated at step 5 for refactoring purpose. The duplicated classes have been removed at step V7. In the other cases, there are not so much merge class concepts to be presented to the experts, between 0% and 2%, giving a maximum of two classes. This often corresponds to classes with incomplete description, that the experts should develop into more details. The low number of such cases makes the task of experts easy.

Ratio # merge association concepts on # initial associations Fig. 5. Merge class concept and merge association concepts vs. initial elements Figure 5 (right-hand side) presents metrics for merge association concepts. The percentage of merge association concepts is higher than the percentage of merge class concepts. This is explained by the fact that associations are only described by roles, that occasionally share the same names (identical to some class names). It varies between about 2% and 18%, meaning that at most 10 merge association concepts are presented to the experts for evaluation, making a little bit more complicated the analysis task compared to the case of classes, but it remains very reasonable.

Execution time, used RAM and total number of steps

Experimentations have been performed on a cluster composed of 9 nodes, each one having 8 processors Intel (R) Xeon (R) CPU E5335 @ 2.00GHz with 8 Go of RAM. The operating system was Linux (64 bits) and the programs are written in Java. Figure 6 shows the execution time in seconds, at step 1 and at step 6. At step 1, the execution time for the two Nav parameterizations are below 6 seconds, while for the two noNav parameterizations, for some versions (especially when there are more associations, like in the last versions) it may reach about 13 seconds. At step 6, the execution time for the two Nav parameterizations are below 8 seconds. But for the noNav parameterizations, we notice longer executions, up to 10 minutes. However, such a task does not require an instantaneous answer, and has not to be carried out too many times. Even if it occurs during an expert meeting, it can be admitted to spend a few minutes for constructing the concept lattices. 1 shows the RAM used during execution, here again, noNav parameterizations are the worst, reaching about 2 GigaBytes of used memory. In the case of Nav parameterizations, it is interesting to observe that there is not a signicant dierence between step 1 and step 6.

Step 1

Step 6 Fig. 6. Execution time at step 1 and 6 (in seconds)

Figure 7 shows, for the Nav-noUndef parameterization the total number of steps needed to reach the x-point, and the size of a longest path with no repeated arcs (such a path can be a cycle). We observe that the step number (from 6 to 16) is always below the size of the longest simple path which gives in our context a practical upper bound to the number of steps. This means that if we dispose in the future of relevant ltering strategies, we can envisage studying new concepts appearing after step 6. Step number (rst) and longest simple path size (second) in C2, Nav-noUndef parameterization 4.4 Discussion During this study, we observed that analyzing merge class concepts and merge association concepts was a feasible task in all parameterizations. The analysis of new class concepts and new associations concepts is more dicult. Nav parameterizations produce exploitable results with a maximum of about 50 class concepts (resp. about 30 new association concepts) to be examined at step 1.

At step 6, experts may have to face from one to three hundreds of new class concepts (resp. about one hundred of new association concepts). Execution time and used memory are not problematic issues and we get a practical upper bound to the number of steps in this kind of data, which is given by the size of a longest simple path. These observations may be the starting point of an ecient steering method for a collaborative class model construction. The objective of such a method would be to insert between each model release, an RCA-based analysis, in order to accelerate the discovery of new abstractions, and the completion of elements (highlighting of the merged concepts ). Both the concepts and the structure of the lattice are useful for the experts to determine which relevant modications should be applied. The strength of the lattice representation is that it provides a structure adapted to the task of choosing the right new abstractions, since concepts can be presented following the specialization order, depending of what is the demand of experts.

Known eects of some parameterizations can serve to favor dierent steering strategies. The longest simple path size gives a bound on the step number, giving an heuristic to decide when to stop the RCA process, with an idea about how far we are from the convergence. Nav parameterizations can be easily controlled by looking, at each step, the appearing concepts (and marking the non-relevant ones to avoid nding them again at next steps). If information is expected from NoNav parameterizations, experts have to be very careful because many concepts will be created. A particular sub-order of the concept lattice (the AOC-poset), induced by the concepts that introduce an entity or a characteristic, might oer an important reduction of the produced concept numbers, without loosing main information about factorization.

Another track is limiting input data, for example by removing attributes that have limited semantic value and to group concepts declaring few attributes.

There are of course some limits to the generalization of our conclusions. The class model is mainly a data model (very few operations), destined to build a database schema and we study various versions of a same class model. Nevertheless, the Pesticides model is a classical model, representative of the models that are built in the environmental eld. 5

The use of FCA in the domain of class model refactoring has a long and rich history in the literature. As far as we know, it has been introduced in the seminal paper of Godin et al. [6] for extracting abstract interfaces from a Smalltalk class hierarchy and extensions of the work have been published in [7]. Other approaches have been proposed, that take into account more information extracted from source code like super calls and method signatures in [2].

In [1], authors report an application of RCA to several medium-size class models of France Télécom (now Orange Labs). The RCA conguration was composed of classes, methods, attributes, and associations. Classes have no description; attributes are described by name, multiplicity and initial value; methods are described by name and method body; associations are described by names, role name and information like multiplicity and navigability. Associations are connected to their origin and destination classes, classes are connected to the attributes and operations they own, attributes are connected to classes that are their type, etc. The class models contain a few dozens of classes and the new concepts to be examined by experts varies from a few concepts to several hundreds.

In [11] detailed gures are given. In the largest project (57 classes), the number of new concepts was 110 for the classes, 9 for the associations and 59 for the properties. In this paper, we have several class models that are greater in terms of number of classes and we reify the role notion, rather than encoding it in the association description, with the risk of having more produced concepts. We discard technical description (like multiplicity which has no strong semantics).

We also analyze the merged concepts, another interesting product of RCA.

In [8], RCA has been applied on an excerpt of the class model of the Jetsmiles software of JETSGO society 4 . The class model excerpt is composed of only 6 classes, connected by 9 associations, and about 30 attributes. Attributes and roles are mixed, and classes are connected by a relational context to attributes-+roles, while attributes+roles are connected by another relational context to their type (when it is a class). The UML elements are described by many technical features: multiplicity, visibility, being "abstract", initial value, etc. A posttreatment analyzes the built concepts in order to keep the most relevant ones. The class concept lattice contains about 35 concepts while the attribute+role concept lattice has about 25 concepts. In [8], the size of the class model is very small. We suspect that using the conguration with many technical elements would not be scalable in the case of the Pesticides model.

RCA has been experimented on two Ecore models, two Java programs and ve UML models in [4]. The used conguration is composed of the classes and the properties (including attributes and roles) described by their names and their connections. To report some representative results of this experiment, in Apache Common Collections, which is composed of 250 classes, RCA nds 34 new class concepts and less than 80 new property concepts; in UML2 metamodel, which is composed of 246 classes and 615 properties, RCA extracts 1534 new class concepts and 998 new property concepts. In this experiment, associations were not encoded, contrary to what we do. Nevertheless an explosion of the concept number yet appears. In our case, we introduce associations in the conguration, and we show, that with some precautions as annotating by navigability and naming the roles, refactoring with data including the associations may remain feasible.

A more recent study [3] compared three strategies of FCA/RCA application to part of the open-source Java Salome-TMF software which comprises 37 classes and 142 attributes 5 . In the RCA strategy (ARC-Name), a formal context includes the classes (no description), a formal context describes the attributes by their names and the hyperonyms of their names, and relations connect classes and their attributes (and reversely). ARC-Name produces 33 new class concepts, and 3 merge class concepts, 21 new attribute concepts and 13 merge attribute concepts. Java softwares do not have associations and it is dicult to generalize these results to the general case of class models. Compared to this work, here we do not use linguistic information, this will be done in a future work, nevertheless the terms in the model are not technical identiers but rather do-main terms carefully selected by the expert group, thus there are less problems in using them directly.

Here we use the same class models as in [10] where RCA based metrics were proposed to assist a designer during the evolution of the class model in indicating him the evolution of the level of description and the level of abstraction.

In this paper, we describe the most advanced study of the application of RCA on class models, so as to obtain a relevant factorization structure. We apply RCA on several versions of the model of the same information system (from 40 to 170 classes), and we study the impact of several parameters in the application. The objective was to observe RCA on real-sized class models, so as to draw conclusions, mainly on its scalability. The experiment shows that taking into account the navigability, it is still possible to analyze the newly introduced abstractions. Consequently, RCA can be considered to scale to real-size models, if it is adequately parameterized. However, the produced results remain quite large to analyze, and new strategies can be settled to face the number of concepts to analyze.

Software engineering has a long tradition of graphical modeling, there are many different diagram types like flowcharts, BPMN, ERD and even languages like UML containing over dozen diagram types. Most of these diagrams have elements connected with directed or non-directed connections. Each element is represented as a node and each connection as a line between these nodes. While this approach is easy to understand and apply, methods of Formal Concept Analysis (FCA) like Galois sub hierarchies (GSH) can represent the same information in a more concise way, significantly reducing the number of graphical elements. This is achieved because a single node in GSH diagram can represent several elements (it can have many labels) and a line can represent many connections. This conforms to the "reduce redundant data-ink" principle from E. Tufte's classic work on visual information displays [19]. GSH diagram makes it easy to see which elements have same connections and which element has a subset of other elements connections inviting interesting comparisons.

GSH diagrams are most natural to use when there are two types of elements and connections between these (a bipartite graph). This applies to the UML use case diagram that describes actors, use cases and connections between them. A study presented here compares the GSH approach with the UML use case diagram. There is also a brief overview about describing the connections between use cases and data tables with diagrams, information present in CRUD matrix, another traditional software engineering artifact.

1. GSH diagrams show nodes (concepts), connections between them and labels from the sets G and M attached to the nodes. Each element from G and M has exactly one corresponding label. 2. g ∈ G is connected to m ∈ M iff there is an upward path from label g to label m or they are labels of the same node. 3. If g 1 , g 2 ∈ G and there is an upward path from g 1 to g 2 then the set of elements g 2 is connected to, g 2 , is a subset of g 1 . 4. Dually, if m 1 , m 2 ∈ M and there is a downward path from m 1 to m 2 then the set of elements m 2 is connected to, m 2 , is a subset of m 1 . 5. If g 1 , g 2 ∈ G and g 1 and g 2 are labels of the same node then g 2 = g 1 . 6. Dually, if m 1 , m 2 ∈ M and m 1 and m 2 are labels of the same node then m 2 = m 1 . There are several tools for concept lattice generation: Concept Explorer [24], ToscanaJ [4], GaLicia [20]. Of these, only GaLicia supports Galois subhierarchies, but its labeling scheme is not convenient for our purposes as its labels contain full concept intents and extents, therefore same element can appear many times in different labels. Two freely available tools were developed as bachelor theses, supervised by the author. One is GSH builder by Kristo Aun [3], another is GSH by Maarja Raud [15]. Both generate GSH diagrams that show the labels, not extents or intents.

Use Case modeling is a common tool for specifying functional requirements. An actor is something with behavior (person, computer system) who interacts with our system. A use case is a collection of related success and failure scenarios that describe an actor using a system to support a goal [13]. A detailed description of the use case is given in a text document while the use case diagram shows a general overview: actors and their relationships to use cases. Use case diagram can also show include and extend relations between use cases. A use case diagram is a diagram type within Unified Modeling Language. There are many books written about the topic including [16] and [13].

Following example (Figure 2) is redrawn from Craig Larmans partial use case diagram describing NextGen sales system: a computerized application used to record sales and handle payments in a retail store [13](pp. 29,71). This is a basic use case diagram showing use cases, actors and connections between them. Figure 3 shows a GSH diagram, equivalent to the use case diagram from Figure 2. It is more concise with only 5 nodes and 2 lines, compared to 14 nodes and 14 lines from Figure 2. A comparison of diagram types based on counting the number of visual elements may seem simplistic but it is in accordance with the principle stated by E. Tufte in his influential work on information displays [19]: " erase redundant data-ink, within reason". Possible reasons for redundancy being: "giving a context and order to complexity, facilitating comparisons over various parts of data, perhaps crafting an aesthetic balance." It is much easier to see from GSH diagrams the actors that are related to same use cases, for example Accounting System, Tax Calculator and Payment Authorization System. GSH diagram makes also visible subset relationships between the use case sets that actors participates in, for example Cashier can do anything that a HR System can do. Therefore GSH diagram both reduces the data ink and compares favorably with the use case diagram in giving a context and order to complexity and facilitating comparisons over various parts of data.

Use case diagrams can contain relations between the use cases or between the actors. Relating use cases is described by C. Larman [13] as "an optional step to possibly improve their comprehension or reduce duplication" GSH diagram showing relations between actors and use cases can not contain this information. Figure 4 presents an example about generalization and include relationships. Generalization is shown as a relation with a big arrowhead from less general subtype to more general supertype. Subtype inherits relations that its supertypes have. Actor Moderator is a subtype of an actor User and thus inherits its connection to Post a comment use case. Generalization relation between use cases is defined dually. Generalization relations can be used to reduce the number of connections within the use case diagrams. While defining formal contexts we add inherited relations to the subtypes.

Include and extend relations between use cases describe sub-functionality: more complex use case includes the behavior of a smaller use case. They allow to introduce different levels of abstraction: A. Cockburn [6] defines three common levels of abstraction: summary, user goal (default level) and sub-function level.

He also mentions very high summary (used rarely) and too low (should not be used) abstraction levels. S. Ambler recommends to avoid more than two levels of use case associations [1]. Use cases Post a comment and Delete inappropriate comment include a common Log in sub-functionality. Use case Manage comments includes use cases Post a comment and Delete inappropriate comment. Levels of abstraction different from the default user goal level are shown through UML stereotypes.

Extend and include arrows correspond to the direction of reference within the use case documentation. In the case of an include relation, use case containing the sub-functionality has a reference to it, in the case of an extend relation, the sub-functionality has a reference to the use case containing it. Extend relation is treated here as an include relation going to the opposite direction.

A method used here to deal with the include and extend relations is to focus on a single level of abstraction (preferably user goal or summary). Use cases at higher or lower levels of abstractions are removed and their relations to actors are added to the use cases they have include/extend relations with. This can introduce superfluous relations: it is impossible to deduce from the use case diagram if a particular actor from the higher level use case participates in certain sub-functionality or not, use case text has to be examined for that. 4) has been flattened as described to the user goal abstraction level through the removal of generalization and include relations and is now in the form that can be used for GSH generation.

GSH diagrams scale well when the number of use cases increases. tation had entire use case model split into four use case diagrams containing 25 use cases, 3 actors and 30 connections between actors and use cases. These 4 diagrams are not reproduced here due to limited space. Equivalent GSH diagram contains 5 nodes and 4 lines. That is a significant improvement in conciseness. In the previous examples GSH diagrams have all been simpler (less nodes, less connections) than use case diagrams. It is easy to see that GSH diagram can have no more nodes than the corresponding use case diagram as each GSH node must have at least one label and labels don't repeat. However, for certain contexts, GSH diagram can have more connections than the corresponding use case diagram, as shown in the following example.

Figure 7 shows a formal context with 16 connections and a corresponding GSH diagram with 18 connections. That raises a question if GSH diagrams are really simpler than use case diagrams for practical applications. Following study tries to answer this.

A B C D 1 x x 2 x x 3 x x 4 x x 5 x x 6

x x 7 x x x x Fig. 7. A formal context with a corresponding GSH diagram that has more lines than the number of original connections.

A study of 87 student projects, that were presented to the author for 2012 "Introduction to information systems" course, was completed to compare the use case and GSH diagrams. Student projects contained the analysis documentation for a freely chosen information system, including use case diagrams. Some of these projects were done in groups and were larger and there was also a variation of effort and quality. For all these projects a corresponding GSH diagram was generated, based on its use case diagram.

Some diagrams contained generalization relations between actors. In this case sub-actors inherited all the relations from super-actors in the corresponding formal context. Some diagrams contained include relationships between use cases. For these cases, only use cases at the user goal level were kept, use cases included in these and their connections with actors were merged into the user goal level use cases as described in the previous section. Use case and connection counts are for diagrams after removing the use cases not at the user goal level of abstraction but before the removal of generalization relations. Generalization relation is counted as one line.

Table 1. Results of the study. U C: number of use cases, A: number of actors, L: number of lines in the use case diagram, GSHC : number of concepts in GSH, GSHL: number of lines in GSH. Ratio between the average number of elements of the use case diagrams and the GSH diagrams is (U C + A + L)/GSH C+L = 3.72. Figure 8 shows the scatter plot of student projects showing the number of visual elements on use case and GSH diagrams. It is easy to see that in all cases GSH diagram was simpler than use case diagram, as all the data points lie below the diagonal (U C + A + L) = GSH C+L line. This confirms that, at least for the information systems with 30 or less use cases, GSH diagrams are much more concise than the use case diagrams.

Use case diagrams have their own advantages. They are easier to sketch and modify by hand and they are easier to decompose into several diagrams. That seems to suggest complementary roles for use case and GSH diagrams, use case diagrams for quick sketching and GSH diagrams for a well-formated and concise view of the system.

Use cases are not only connected to the actors who require such a functionality but they operate on data tables. GSH diagrams are useful for modeling these connections too. CRUD matrix is a well known artifact of software engineering that describes relations between data tables and use cases. It is described in several popular books about systems design [7] and databases [14]. Use of CRUD matrix as a basis for GSH diagrams was described by author in [18]. It is shortly summarized here to show the usefulness of GSH diagrams for different software engineering activities. There are 4 basic actions performed on data tables by use cases: (C)reate, (R)ead, (U)pdate, (D)elete. In some variations use cases are replaced with actors or business processes.

Table 2 contains a CRUD matrix for a simplified library system. Columns correspond to data tables and rows to use cases. Letters c, r, u, d inside the cells of the matrix correspond to 4 basic actions. For example, use case Add New Task reads data from the table Employee and creates (adds) new data to the table Task. We can think of a CRUD matrix as defining dependencies between use case layer and data layer. To describe only dependencies we introduce a new binary matrix where all entries with no actions in the original CRUD matrix are replaced with 0 and all entries with at least one action are replaced with 1. We refer to such a matrix as a usage matrix. Table 3 is a usage matrix for Table 2.

It is obvious that usage matrix, and therefore GSH diagram, can be generated automatically from CRUD matrix. That kind of tool could provide visual representation of CRUD matrix without extra effort from the tool user.

Figure 9 is a GSH diagram based on the usage matrix from Table 3. From the GSH diagram it is much easier to see the elements with same dependencies, like use cases Add loan and Return loaned book and disconnected subsystems, like use case Manage Readers with data table Reader. GSH diagrams are also helpful for detecting hidden similarities/isomorphisms between different contexts. It is 3.

much easier to see that GSH diagrams from Figures 1 and 9 are isomorphic than that matrices from Figure 1 and Table 3 are isomorphic.

The use of methods of FCA for software engineering is not a novel idea. A thorough survey of FCA support for software engineering activities is given in [17]. Most of such research is about extracting potential class hierarchies from different contexts. Dolques et al [8] propose a FCA-based method for simplifying use case diagrams through the introduction of new generalizations. The result of this method is a refactored use case diagram. Their method preserves the information of include and extend relations. Reduction of diagram elements seems to be smaller than with GSH based method reviewed here though these results are hard to compare exactly as they present them in the terms of edge density (ratio of existing edges to all possible edges). It is possible that the edge density goes down while the actual number of edges increases when new generalized use cases and actors are introduced.

Wolfgang Hesse and Thomas Tilley [12] use a concept lattice connecting use cases and "things" as a tool for identifying candidate classes for object oriented design. There has been much research into using FCA and GSH for class hierarchy design [10], [11]. Algorithms for GSH generation are compared in the article by Arévalo et al [2], a newer algorithm Hermes is presented by Berry et al [5].

GSH diagrams can be a concise replacement for UML use case diagrams. In our study they had 3.7 times less visual elements. GSH diagrams are likely to be useful wherever there are connections between two types of elements: actors and use cases, use cases and data tables, use cases and classes, business processes and use cases and so on.

One area for further research is the software engineering activity of grouping elements into subsystems. Similar use cases can be grouped into functional subsystems, similar data tables can be grouped into registers. GSH and concept lattice diagrams can help here by organizing elements by similar connections. Use cases that depend on the same data tables are likely to be similar. Grouping elements with similar connections into same subsystems would also help to minimize the connections at subsystem level. GSH diagrams can also be used to visualize the subsystem level connections, thus promising to be a quite universal tool for software engineering.

In the relational database model, functional dependencies (FDs) are among the most popular types of dependencies [19] since they indicate a functional relation between sets of attributes: the values of a set of attributes are determined by the values of another set of attributes. To handle errors and uncertainty in real-world data, alternatives exist. Approximate Dependencies [12] are FDs that hold in a part -which is user defined-of the database. Purity Dependencies [15] express the relationship on the relative impurity induced by two partitions of the table (generated by two sets of attributes). If the impurity is zero, we have a FD.

These generalizations do not necessarily capture the semantics of some patterns that may hold in a dataset. This motivates the definition of "Similarity Dependencies", which can be seen as a generalization of Functional Dependencies, but un-crispring the basic definition of FDs: similar values of an attribute determine similar values of another attribute. Similarity has been considered for FDs under several terms, e.g. fuzzy FDs [3], matching dependencies [16], constraint generating dependencies [2]. Moreover, it is still an active topic of research in the database community [4,8,16,17].

The main objective of the present article is to give a characterization of similarity dependencies within FCA [10], thanks to the formalism of pattern structures [9]. Indeed, characterizing and computing FDs is strongly related to lattice theory and FCA. For example, the lattice characterization of a set of FDs is studied in [5,6,7], while a characterization within a formal context in FCA is proposed in [10]. The latter is based on a binarization, which is the transformation of the original set of data into a binary context. To overcome the burden usually induced by such a transformation, pattern structures [9] have emerged as a valuable alternative to avoid arbitrary transformations and complexity problems [1].

Accordingly, our purpose here is threefold. Firstly, we propose a definition of Similarity Dependencies, and secondly a formalization based on pattern structures in FCA, avoiding a transformation of data into a binary table. It follows that classical algorithms of FCA can be -almost directly-applied to compute similarity dependencies. This work is based on [1] where FDs are characterized thanks to pattern structures, and on [13] where similarity is introduced in pattern structures as a tolerance relation (reflexive, symmetric, but not transitive). Finally, we also report preliminary experiments showing the capabilities of the approach.

The paper is organized as follows. In Section 2 we introduce the definition of Functional, Approximate and Purity Dependencies. In Section 3 we propose a definition and a characterization of Similarity Dependencies with pattern structures. Finally, Section 4 reports preliminary experimental results showing the capabilities of our approach.

2 Functional, Approximate and Purity Dependencies

We deal with datasets which are sets of tuples. Let U be a set of attributes and Dom be a set of values (a domain). For the sake of simplicity, we assume that Dom is a numerical set. A tuple t is a function t : U → Dom and then a table T is a set of tuples. Usually a table is presented as a matrix, as in the table of Example 1, where the set of tuples (or objects) is T = {t 1 , t 2 , t 3 , t 4 } and U = {a, b, c, d} is the set of attributes.

The functional notation allows to associate an attribute with its value. We define the functional notation of a tuple for a set of attributes X as follows, assuming that there exists a total ordering on U. Given a tuple t ∈ T and X = {x 1 , x 2 , . . . , x n } ⊆ U, we have:

In this paper, the set notation is usually omitted and we write ab instead of {a, b}.

Example 1. This is an example of a table

We are also dealing with the set of partitions of a set. Let S be any arbitrary finite set, then, Part(S) is the set of all possible partitions that can be formed with S. The set of partitions of a set is a lattice [11]. We recall that partitions can also be considered as equivalence classes induced by an equivalence relation. Now, we define the set of the "maximal subsets" of a set.

Definition 1. Given a finite base set S and X = {X 1 , X 2 , . . . , X n } a set of subsets of S, a subset X i is maximal in X if there does not exist any other subset X j in X such that X i ⊂ X j . Then X M ax is the set of the maximal subsets of X.

For example, let S = {a, b, c} and X = {{a, b}, {b, c}, {a}, {b}}. Then X is a subset of ℘ (S) the powerset of S, but not all elements of X are maximal subsets.

Indeed, X M ax = {{a, b}, {b, c}}. Moreover, we define the function max S which applies to a set of sets such as X and returns the set of maximal subsets of X, i.e. X M ax . Definition 2. Given a finite set S and a subset X = {X 1 , X 2 , . . . , X n } of ℘ (S), the function max S returns the set X M ax of maximal subsets of X:

We now introduce functional dependencies (FDs).

). Let T be a set of tuples (or a data table), and X, Y ⊆ U. A functional dependency (FD) X → Y holds in T if:

For example, the functional dependencies a → d and d → a hold in the table of Example 1, whereas the functional dependency a → c does not hold since t 2 (a) = t 4 (a) but t 2 (c) = t 4 (c).

There is an alternative way of considering Functional Dependencies using partitions of the set of tuples T . Taking a set of attributes X ⊆ U, we define the partition of tuples induced by this set as follows.

Definition 4. Let X ⊆ U be a set of attributes in a table T . Two tuples t i and t j in T are equivalent w.r.t. X when:

Then, the partition of T induced by X is a set of equivalence classes:

Given X, Π X (T ) is a partition or alternatively an equivalence relation. Then we have:

The classes in a partition induced by X are disjoint and they cover all the tuples in T . The set of all partitions of a set T is Part(T ). We can also notice that the set of partitions of any set Part(T ) induces an ordering relation ≤:

For example: {{t 1 }, {t 2 }, {t 3 , t 4 }} ≤ {{t 1 }, {t 2 , t 3 , t 4 }}. According to the partitions induced by a set of attributes, we have an alternative way of defining the necessary and sufficient conditions for a functional dependency to hold:

Again, taking the table in Example 1, we have that a → d holds and that Approximate Dependencies [12]. In a table, there may be some tuples that prevent a functional dependency from holding. Those tuples can be seen as exceptions (or errors) for that dependency. Removing such tuples allows the dependency to exist: then a threshold can be set to define a set of "approximate dependencies" holding in a table. For example, a threshold of 10% means that all functional dependencies holding after removing up to 10% of the tuples of a table are valid approximate dependencies. The set of tuples to be removed for validating a functional dependency does not need to be the same for each approximate dependency. Considering in Example 2 the dependency M onth → Av.T emp, we can check that 6 tuples should be removed before verifying the dependency: we keep only one tuple for Month 1 and one tuple for Month 5 (actually just as if we remove "duplicates"). Then, if the threshold is equal to or larger than 75%, M onth → Av.T emp is a valid Approximate Dependency.

Purity Dependencies [15] are a generalization of the relationship between partitions induced by the left-hand side and right-hand side of a functional dependency. These dependencies are based on the relative impurity measure of two partitions. In order to compute this impurity measure, we need a concave and subadditive function defined on the interval [0, 1] (for example, the binary entropy function). The intuition about this measure is that it computes how much those partitions disagree, i.e. how far two partitions π and σ are from fulfilling the relation π ≤ σ. If the impurity measure is zero (or close to zero), then π ≤ σ.

For example, the impurity measure (details on this measure are given in [14]) of partition {{1, 2, 3}, {4, 5}} w.r.t. partition {{1, 2}, {3, 4, 5}} is 5.6, whereas the impurity measure of partition {{1, 3}, {2, 5}, {4}} w.r.t. partition {{1, 2}, {3, 4, 5}} is 8.2. In the first pair of partitions, only tuple 3 is misplaced, i.e. moving 3 from one partition to another leads to the the same partitions, whereas in the second example, the number of misplaced elements is larger (2, 3, and 4 should be moved).

An important feature of this measure is that if a partition is finer than another, then, their relative impurity measure is exactly 0. This implies that a purity dependency X → Y holds if and only if the relative impurity of Π X (T ) w.r.t. Π Y (T ) is below a user-defined threshold. Therefore, if Π Y (T ) ≤ Π X (T ), a functional dependency is a valid purity dependency, regardless of the threshold.

For example, we consider all the possible dependencies having the attribute Average Temperature in their right-hand side. The purpose of this choice is to find out which attributes determine the values of the average temperature (Av. Temp.) in Example 2. Considering Approximate Dependencies, we introduce the two metrics # Tuples and Percentage: # Tuples denotes the minimal number of tuples that must be removed from the dataset for allowing the dependency to hold, and Percentage denotes the percentage that # Tuples represents for the whole dataset. For example, the Approximate Dependency M onth → Av.T emp holds when we remove at least 6 (well-chosen) tuples, which represent 75% of the whole dataset. As for the purity measure, we use the measure of relative entropy of two partitions described in [14]. If we examine the dependency M onth → Av.T emp, we should the relative entropy of the partitions induced by Month and Av. Temp., which are, respectively:

Then, the relative entropy of Π M onth and Π Av.T emp. is 12.98, i.e. the largest of the conditional entropies that are computed. Actually the number of tuples that need to be reallocated for Π Av.T emp. ≤ Π M onth is significantly large. It is also significant that the number of tuples that need to be removed for the dependency Y ear, City → Av.T emp to hold is zero and that the relative entropy of Π Y ear,City and Π Av.T emp. is zero as well. The Functional Dependency Y ear, City → Av.T emp holds because there is no pair of tuples t i , t j such that t i (Y ear, City) = t j (Av.T emp.), i.e. there is no need to remove any tuple to verify this dependency. In addition the relative entropy of Π Y ear,City and Π Av.T emp. is zero, because the partitions induced by both sides, Π Y ear,City and Π Av.T emp are exactly the same: {{t 1 }, {t 2 }, {t 3 }, {t 4 }, {t 5 }, {t 6 }, {t 7 }, {t 8 }}. Therefore, the relation Π Y ear,City ≤ Π Av.T emp holds, i.e. the relative entropy is zero and this dependency trivially holds.

Yet, the intuition about this dataset is that the "Average Temperature" depends, to some extent, on the location and the month, i.e. given a city and a month, we should be able to predict the average temperature. But this intuitive relationship is somehow difficult to deduce with Approximate and Purity Dependencies. For example, the metrics for the dependency M onth, City → Av.T emp indicate that 4 tuples must be removed (50% of the dataset) for checking this dependency, or alternatively, the relative entropy of the partitions Π M onth,City and Π Av.T emp is 4.0. Considering the number of tuples, removing 50% of the whole dataset is a lot, especially if the intuition tells that this dependency should hold. Considering the entropy rate, the smallest entropy rate is zero and the largest computed rate is 12.98. Thus, it seems difficult to deduce the right threshold in each case.

Instead of considering measures that deal with the sets of tuples as a whole, dependencies could be directly related with the notion of "similarity": if two tuples have similar values for the attributes Month and City, then they should have a similar value for the attribute Av. Temp. This can be interpreted as follows: if two cities are close enough and the corresponding months are also close enough, then the average temperature in the cities should be close enough or "similar" as well. In such a context, "having similar values" depends on the type of the attributes. For temperatures it mean that the absolute difference of the values is less than a given threshold. For months, it could mean that they are adjacent. For cities, it could mean that their locations are close enough.

Such a kind of dependency would provide more control and a more intuitive explanation of the relations existing between attributes.

First, we define a tolerance relation in a set S: Definition 5. θ ⊆ S × S is a tolerance relation if:

1. ∀s i ∈ S : s i θs i (reflexivity) 2. ∀s i , s j ∈ S : s i θs j ⇐⇒ s j θs i (symmetry) A tolerance relation is not necessarily transitive and induces blocks of tolerance: Definition 6. Given a set S, a subset K ⊆ S, and a tolerance relation θ ⊆ S×S, K is a block of tolerance of θ if:

All elements in a tolerance block are in pairwise correspondence, and the block is maximal with respect to the relation θ. The set of all tolerance blocks induced by a tolerance relation θ on the set S is denoted by S/θ (by analogy with the notation of equivalence classes). S/θ is a set of maximal subsets of S and as such, S/θ ∈ ℘ ( ℘ (S)). Thus we have:

Then, we define a partial ordering on the set of all possible tolerance relations in a set S as follows: Definition 7. Let θ 1 and θ 2 two tolerance relations in the set S. We say that

This relation is a partial ordering and induces a lattice where the meet and join operations of two tolerance relations θ 1 and θ 2 , or, equivalently, on the sets of blocks of tolerance of θ 1 and θ 2 are: Definition 8. Let θ 1 and θ 2 two tolerance relations in the set S.

The meet θ 1 ∧ θ 2 is the set of pairwise intersections of all blocks in S/θ 1 and S/θ 2 , and then removing intersections that are not maximal. The join is simpler as it consists in simply joining the blocks of tolerance in S/θ 1 and S/θ 2 and then removing the unions that are not maximal.

An example of a tolerance relation is the similarity that can be defined within a set of integer values as follows. Given two integer values v 1 , v 2 and a threshold (user-defined):

For example, when S = {1, 2, 3, 4, 5} and = 2, then S/θ = {{1, 2, 3}, {2, 3, 4}, {3, 4, 5}}. S/θ is not a partition as transitivity does not apply.

We now come back to the set of tuples T and the set of attributes M . For each attribute m ∈ M , we define a tolerance relation on the values of that attribute: θ m . The set of tolerance blocks induced by the tolerance relation of the attribute m is T /θ m . All the tuples in a tolerance block K ∈ T /θ m are similar one to the other according to their values w;r.t. the attribute m.

Now, assuming that = 1 in example 1, we have:

We can also extend this definition to sets of attributes. Given X ⊆ U, the similarity relation θ X is defined as follows:

Two tuples are similar w.r.t. a set of attributes X if and only if they are similar w.r.t. each attributes in X. We now can define a similarity dependency:

In the case of a functional dependency, X → Y holds if and only if, for each pair of tuples having the same value w.r.t. the attributes in X, then, they have the same value w.r.t. the attributes in Y .

In the case of a similarity dependency, X → Y holds if and only if, for each pair of tuples having similar values w.r.t. the attributes in X, then, they have similar values w.r.t. the attributes in Y .

Example 5. We revisit the table in Example 4 and we define the tolerance relation:

It is interesting to notice that b → d is a similarity dependency but not a functional dependency, as t 1 (b) = t 2 (b) and t 1 (d) = t 2 (d). Because of the same pair of tuples, the similarity dependency bcd → a does not hold, as t 1 θ bcd t 2 but we do not have

By contrast, the functional dependency bcd → a holds because there is no pair of tuples t i , t j such that t i (bcd) = t j (bcd). The only similarity dependency that holds is M onth, City → Av.T emp, using the following similarity measures for each attribute:

The similarity imposes that the month and year must be the same, whereas the distance between cities should be less than 500 kilometers and the difference between average temperatures should be less than 10 degrees (all these values are of course arbitrary).

In particular, considering the tuples t 1 , t 2 : t 1 θ M onth,City t 2 since t 1 (M onth) = t 2 (M onth) = 1 and t 1 (City) = t 2 (City) = M ilan . From the other side, we have that t 1 θ Av.T emp. t 2 since |36.4 − 33.8| ≤ 10.

A pattern structure allows one to apply FCA directly on non-binary data [9]. Formally, let G be a set of objects, let (D, ) be a meet-semi-lattice of potential object descriptions and let δ : G −→ D be a mapping associating each object with its description.

These operators form a Galois connection between (℘(G), ⊆) and (D, ). Pattern concepts of (G, (D, ), δ) are pairs of the form (A, d), A ⊆ G, d ∈ (D, ), such that A = d and A = d . For a pattern concept (A, d), d is a pattern intent and is the common description of all objects in A, the pattern extent. When partially ordered by

, the set of all concepts forms a complete lattice called pattern concept lattice.

Thanks to the formalism of pattern structures, similarity dependencies can be characterized (and computed) in an elegant manner. Firstly, the description of an attribute m ∈ M is given by δ(m) = G/θ m which is given by the set of tolerance blocks w.r.t. θ m and G = T . As tolerance relations can be ordered as presented and discussed in Definitions 7 and 8, then descriptions can be ordered within a lattice.

Then, a dataset can be represented as a pattern structure (M, (D, ), δ) where M is the set of original attributes, and (D, ) is the set of sets of blocks of tolerance over G provided with the meet operation defined in Definition 8.

An example of concept formation is given as follows. Starting from the set {a, c} ⊆ M and assuming that t i θ m t j ⇐⇒ |t i (m)−t j (m)| ≤ 2 for all attributes:

This pattern concept lattice allows us to characterize all similarity dependencies holding in M :

Proof. First of all, we notice that (t, t ) ∈ {X} if and only if t(X)θ X t (X), since (t, t ) ∈ {X} if and only if ∀x ∈ X : t(x)θ x t (x), if and only if t(X)θ X t (X). We also notice that {X, Y } ⊆ {X} . (⇒) We prove that if X → Y holds in T , then, {X} = {X, Y } , that is, {X} ⊆ {X, Y } . We take an arbitrary pair (t, t ) ∈ {X} , that is: t(X)θ X t (X).

Since X → Y holds, it implies that t(XY )θ XY t (XY ), and this implies that (t, t ) ∈ {X, Y } . (⇐) We take an arbitrary pair t, t ∈ T such that t(X)θ X t (X). Therefore, we have that (t, t ) ∈ {X} , and by hypothesis, (t, t ) ∈ {XY } , that is: t(XY )θ XY t (XY ). Since this is for all pairs t, t ∈ T such that t(X) = t (X), this implies that X → Y holds in T .

Dataset description. Electronic sport denotes the extreme practice of video games where so-called cyber-athletes compete in world-wide tournaments. As for any sport, such professionals are surrounded by sponsors and practice within professional teams. These professional games are even broadcast by commentators over specialized TV channels [18]. StarCraft II (Blizzard Entertainment) is the most competitive video game. Since e-sport is a digital entertainment, one can easily find game statistics and recording in great numbers on the Web. We list more than 209, 000 games between two opponents and their associated statistics (attributes). For each game, we derive two tuples (one for each of the players involved). Each player in a game (tuple) is described by 31 attributes such as his faction, the result, and several indicators of his game play. Experimental settings. The final dataset has about 400, 000 tuples described by 31 attributes with different domain types (Boolean, qualitative, and numerical). For attributes with Boolean or non-ordered qualitative domains, the similarity parameters are set to 0 as for classical FDs, since we do not have similarity constraints between their values. For the others, parameters are set by an expert of the domain, helped with the distribution of that attribute values. Thanks to the genericity of pattern structures, we slightly modified the very simplistic Java version of CloseByOne used in [1] for extracting classical FDs. The only modification lies in building the descriptions, i.e. producing tolerance blocks instead of partitions over the set of objects. We experimented on 1.8GHz and 4GB of RAM machines. Preliminary results. We build first several different sub-datasets with randomly chosen set of tuples and different subsets of attributes. We report execution times for extracting pattern concepts (and their count) to characterize functional dependencies and similarity dependencies for three datasets in Figure 1. We also report the average number of tolerance classes of each attribute (that allows to build their description). In Figure 1 (a), the dataset is composed of qualitative and not comparable attributes only. Thus, we set the similarity parameters to 0 and observe that extracting FDs and SDs requires the same amount of time and returns the same concepts (since setting the similarity parameter to 0 leads to partitions). Naturally, the number of tolerance blocks is high, corresponding to the cardinality of attribute domains. We added more attributes, among which 5 numerical, and introduce the similarity parameters, see Figure 1 (b) and (c). The number of tolerance blocks is still high since it is an average for all attributes, and attribute domains are very dense. We notice that there are more concepts to characterize SDs than FDs. This is due to our choice of similarity parameters. Finally, we face memory issues when computing pattern concepts for SDs, when the algorithms terminates for FDs. This is due to our pattern implementations, i.e. how a pattern is represented in the memory. We used striped partitions, i.e. not store any part of size 1, which can strongly reduce the pattern size in memory. For FDs, this experimentally happens more often than for SDs, due to the relaxation of the equality constraint. We need to investigate other pattern implementations.

We discussed how Functional, Approximate and Purity Dependencies may not capture some relationships among attributes that intuitively exist in a dataset. We presented alternatively Similarity Dependencies, to express relationships between attributes based on a similarity measure that depends on the semantics of each attribute. We showed that similarity dependencies are easily characterized in FCA with pattern structures and we gave a preliminary experimental study. Future work is in concern with a deeper investigation of the best in-memory pattern representations for fast and scalable computation, the introduction of a minimal support as well as a qualitative evaluation of similarity dependencies.

Various fields, such as artificial intelligence, data mining and databases, are concerned with the problem of finding implications between sets of attributes describing objects. Formal concept analysis offers a sound mathematical framework to help develop algorithms that compute implications. As it has been shown in [3], the set of implications of minimum cardinality needed to obtain all the interesting information can be found by enumerating attribute sets known as pseudo-intents. The best-known algorithm for the computation of pseudo-intents is Next Closure [4], in which pseudo-intents are enumerated following a total order on attribute sets called lectic order. The problem of enumerating pseudointents in lectic order has been studied in [2] and found to be CONP-complete. The same work has been unable to find a lower bound to the complexity of this problem once the restriction on the order is removed. This indicates that the order plays an important role and that using a weaker order could potentially yield interesting results. This prompted us to study an algorithm based on the same principles as Next Closure but with a partial order on the attribute sets instead of a linear order. We are inspired by the multiple algorithms for the related problem of enumerating formal concepts that make use of the lattice structure of the problem. There already are approaches that do not make use of the lectic order for pseudo-intents, such as the attribute incremental algorithm that has been introduced in [8], or the divide-and-conquer approach in [9] but we will not compare it to our own in this work as their nature differs.

After an overview of the notations in formal concept analysis and a brief recall of Next Closure, we will present our algorithm. In a second part, we will show that it can be modified to compute not only the Duquenne-Guigues basis but also the Luxenburger basis. The functioning of the algorithm will then be illustrated by means of a small example.

In formal concept analysis, data is represented by a triple C = (O, A, R), called formal context, where O is a set of objects, A a set of binary attributes and R ⊆ O × A a relation assigning a set of attributes to each object. An object o is said to be described by an attribute set A iff (o, a) ∈ R for every a ∈ A.

Two derivation operators are commonly employed and defined as follows :

.

The compositions of these two operators are closure operators and we will use the notation . for both. A set A is said to be closed if A = A . A closed attribute set is called an intent and a closed object set an extent. An attribute set A is a pseudo-intent if it is not an intent and P ⊂ A for all pseudo-intents P ⊂ A. The set B = {A → A | A is a pseudo-intent}, called the canonical basis, is a set of implications of minimum cardinality such that every implication that holds in the context can be inferred from it through the application of the Armstrong rules. That is, it is the minimum number of implications containing all information on the relations between attribute sets in the context.

Computing the canonical basis of a context thus requires the enumeration of its pseudo-intents. This presents some challenges as the number of pseudo-intents can be exponential in the size of the context (the number of attributes), as shown in [5]. Moreover, whether pseudo-intents can be enumerated without intents is still an open problem and the number of intents can itself be exponential in the number of pseudo-intents.

The most known algorithm for computing the canonical basis is Ganter's Next Closure [4]. For an arbitrary linear order < on A, a linear order, called lectic order, ≤ lec on attribute sets is defined as follows:

∆ is the symmetric difference. The implicational closure of an attribute set A with respect to a set of implications L, usually noted L(A), is the smallest superset of A such that, for every X ⊆ L(A), we have

The implicational closure is a closure operator. The implicational pseudo-closure of an attribute set A, noted L − (A), is the smallest superset of A such that, for every X ⊂ L(A), we have

It is shown that both intents and pseudo-intents are closed under B − . Next Closure, in its original form, computes closed sets for a given closure operator. Applied to the computation of pseudo-intents, it goes through implicationally pseudo-closed subsets of A in lectic order and checks whether the result is an intent or a pseudo-intent. The lectic order being linear, every set is computed once and only once. For an attribute set A and an attribute i, the operator ⊕ is defined as follows :

The closed set that immediately follows A in the lectic order is A ⊕ i with i maximal such that min((A ⊕ i) \ A). For each set closed under B − , Next Closure tests whether it is an intent or a pseudo-intent and then constructs the next set with the operator ⊕ until it reaches A. Numerous optimizations can be added to reduce the number of implicational closures. For example, as proposed in [8], if N ext(A) = A ⊕ i = B and min(B \ A) < max(A) then we can continue as if A ⊕ i had been rejected by Next Closure. It is the only one we will consider here as it is specific to Next Closure and has no incidence on our algorithm.

We consider the lattice Φ = ({A = B − (A) | A ⊆ A}, ⊆) of attribute sets closed under B − ordered by the inclusion relation. Enumerating pseudo-intents is enumerating all the elements of Φ and testing whether they are intents or pseudointents. As with other enumeration problems, we want to make sure every element is found once and only once. The other great FCA problem, computing the formal concepts of a context, can be viewed as the enumeration of the elements of ({B(A) | A ⊆ A}, ⊆). It has been extensively studied (see [6] for a comparison of different algorithms) and various approaches have been proposed for both generating elements from previous ones and checking whether an attribute set has already been found (or even preventing the generation of redundant sets). Surprisingly, it seems only Next Closure is commonly used for the problem of pseudo-intents, non-batch algorithms excluded. Indeed, it is very efficient in that the lectic order on attribute sets allows for the generation of the next set without stocking more than the current set and the total order ensures we do not generate them more than once. However, we feel that the fact that sets are not always generated by one of their subsets is a weakness for some applications, such as data mining. We propose to modify Next Closure with techniques from some algorithms for formal concepts that make use of the lattice structure.

The lectic order has the interesting property that a set B is greater than all its subsets. If B ∈ Φ is supposed to be generated by a single set, it should be one that is easily identifiable such as its lectically greatest subset A ∈ Φ. For any two A and B in Φ, we shall use A B to denote the fact that A is the lectically greatest subset of B closed under B − or, equivalently, that B is generated from A. We say that A is the predecessor of B and B is a successor of A.

Proposition 1. The relation defines a spanning tree of the neighbouring graph of Φ.

Proof. Any non-empty set B has at least one strict subset in Φ. We call A its lectically greatest subset in Φ. The lectic order respects the inclusion relation so there is no C such that A ⊂ C ⊂ B and A is a lower cover of B. Since every non-empty B ∈ Φ has a single lower cover A such that A B, the successor relation defines a spanning tree of the neighbouring graph of Φ. Proposition 2. For any two A, B ∈ Φ, the attribute set B is an upper cover of A if and only if B = B − (A ∪ {i}) for every i ∈ B \ A.

Proof. If B is an upper cover of A, then there is no

If B = B − (A ∪ {i}) for every i ∈ B \ A, given that A ∪ {i} is the smallest subset of B that contains both A and i, then there is no superset of A that is a strict subset of B.

Attribute sets are generated according to the tree, starting from ∅. The recursive nature of the definition of a pseudo-intent prevents us from computing a set before the computation of all its subsets. The lectic order solves this problem efficiently but our tree contains only the knowledge of the lectically greatest subset. In order to make sure that every subset has been found first, we propose to consider attribute sets in order of increasing cardinality. This way, when an intent or pseudo-intent of cardinality n is considered, we are sure that all pseudo-intents of cardinality n − 1 have been found.

then {i} is a pseudo-intent that is a subset of A ⊕ i and is lectically greater than A.

1: Successors = ∅ 2: for every attribute i greater than min(A) do 3:

end if 8:

end if 9: end for 10: return Successors Proposition 4. For any two attribute sets A and B such that

So, in order to generate all the successors of A, it suffices to compute A ⊕ i for every i greater than min(A). If a resulting attribute set is an upper cover of A it is a successor.

Testing whether a new attribute set B = A ⊕ i is a successor of A is easy as we know A ⊕ j for every j ∈ B \ A. Algorithm 1 uses this to compute the successors of an attribute set.

If an attribute set B is a pseudo-intent, it is a ∧-irreducible element of Φ. That is, it has a single upper cover. If B = B − (A), the set B is the lectically next set after B if max(A) ≤ min(A \ A). That way, if an attribute set is a pseudo-intent, we do not have to explicitly compute its successors.

Algorithm 2 uses Algorithm 1 to go through the intents and pseudo-intents of the context and compute its canonical basis. It starts with ∅ and computes the closure of all the attribute sets of the same cardinality simultaneously before generating their successors. However, when an intent A is considered and its successors generated, only the pseudo-intents of cardinality lesser than |A| + 1 have been found so the A ⊕ i computed at this point might be different from the final A ⊕ i. For example, if |A ⊕ i| − |a| = 2, an implication B → C with |B| = |A| + 1 and B ⊂ A ⊕ i will change the result. For this reason, we must split Algorithm 1 into two parts. First, the sets A ⊕ i are computed for all i once every intent of cardinality |A| have been found. Then, when A ⊕ i is considered as a Candidate, we must check whether it is still logically closed and, if it is, test whether it is a successor with Proposition 4. for every attribute set A of cardinality Card in Candidates do 7:

if A = B − (A) and it is a successor of its generator then 8: for every set C in Intents do 22:

end for 24:

Card = Card + 1 25: end while 26: return B Proposition 5. Algorithm 2 terminates and produces the canonical basis of the context.

Proof. An attribute set can only be used to generate attribute sets of greater cardinality. The set of attributes is finite, so the algorithm terminates when it reaches A.

Every element of Φ, except ∅, has a lower neighbour that is a predecessor in the spanning tree. If we generate the attribute sets along the tree, the lattice Φ being complete, every one of its elements is considered at least once. If an attribute set A is not equal to B − (A) it is not a pseudo-intent so all pseudointents are found.

During Algorithm 2, Algorithm 1 is applied to every intent to generate attribute sets. Their closure is then computed. As such, Algorithm 2 is in O(|Φ| × (X + Y )) where X is the complexity of computing the closure of a set and Y = |A| × L is the complexity of generating successors that depends on the complexity L of the saturation algorithm used. A study of algorithms for computing the implicational closure and their use in our problem can be found in [1]. Note that, since every potential pseudo-intent P is constructed from an intent I with I ⊂ P , computing P can be done on the subcontext containing the objects of I .

Additional reduction of the number of implicational closures required to compute the base can be achieved by making use of the property that every attribute set is constructed by adding an attribute to one of its subsets.

This lets us use the knowledge acquired on a set A to reduce the number of necessary logical closures on its supersets. Indeed, for any B = A ⊕ i with i = min(B \ A), the set B ⊕ j is already known for every attribute lesser than i. This means that, in order to compute the successors of B, we need only to use the ⊕ operator with attributes greater than i.

We can also use the fact that there are pseudo-intents P such that P = A, which means that no object of the context is described by P . Indeed, for an intent A such that A A ⊕ i, there are two possibilities for i. If i ∈ o∈A {o} , meaning there is at least an object described by A ∪ {i}, the set A ⊕ i is either an intent or a pseudo-intent. If i ∈ A \ o∈A {o} , meaning no object is described by A ∪ {i}, the closure of A ⊕ i is A and, for any superset B of A, the set B ⊕ i is either equal to A ⊕ i or A. This means that computing B ⊕ i is unnecessary for every successors B of A in the spanning tree.

A partial implication between two attribute sets A and B, otherwise called association rule, is a relation of the form A → s,c B where s is called the support and c the confidence. It means that s% of the objects of the context are described by A and that c% of them are also described by B. Implications, as defined in Section 2, are partial implications with a confidence of 100%. An attribute set A having the same support as A , the confidence and support of a partial implication A → s,c B can be derived from A → s,c B . As such, to obtain a basis for partial implications, one needs only to know the intents of the formal context.

It has been shown in [7] that a minimal basis for partial implications, called Luxenburger basis, is obtained by considering a set {A → s,c B | A = A and B = B } that forms a spanning tree of the neighbouring graph of the intent lattice such that A is the conclusion of a single partial implication.

In Algorithm 2, every attribute set is generated from a single intent with the exception of some essential intents that lectically follow a pseudo-intent. We would like those intents to be constructed from their lectically greatest subset that is an intent instead of just their lectically greatest subset. Let us suppose that we have an intent A and a pseudo-intent B such that A B and B B . The lectically greatest intent that is a subset of B is either A or a superset of A so it can be constructed by adding attributes of B \ A to A.

Algorithm 3 computes C for a given A, B and B .

Algorithm 3 Lectically Greatest Sub-Intent

end if 6: end for 7: return C Proposition 7. Algorithm 3 terminates and computes the lectically greatest intent that is a subset of B Proof. There is a finite number of attributes and the loop goes through them in a total order so the algorithm terminates. The attribute set it returns, C, is either A or closed under B(.), so it is an intent. It is the implicational closure of a subset of B and it is not equal to B so we have C ⊂ B . Let us suppose that there is an intent D ⊂ B lectically greater than C with i = min(C∆D). The attribute i is such that B(X ∪ {i}) ⊂ B for any A ⊆ X ⊆ D so the algorithm must have added it to C and we have C = D.

Thus, the algorithm returns C, the greatest intent that is a subset of B .

If, in Algorithm 2, we maintain the spanning tree we used to generate attribute sets, it is easy to apply Algorithm 3 to every intent that lectically follows a pseudo-intent. If we change the predecessor of those intents to the attribute set computed by Algorithm 3 we obtain a spanning tree of Φ in which the predecessor of every intent is an intent. As A also has a unique predecessor, it gives us the Luxenburger basis of the context along with the Duquenne-Guigues basis.

We apply Algorithm 2 on the following context with a < b < c < d < e : The algorithm starts with ∅. It is closed so we generate its successors.

The set of Candidates is then {a, b, c, d, e}. Among them, only a is a pseudointent with a = ab so we add a → ab to the basis. Moreover, ab lectically follows a so we add ab to Candidates. Its lectically greatest subset that is an intent is b. We then generate the successors of b, c, d and e. There are no attributes greater than min(e) = e so e has no successors.

The set of Candidates is then {ab, bc, bd, be, cd, ce, de}. Among them, bc, be and cd are pseudo-intents so we add bc → bcd, be → bde and cd → bcd to B. The set bcd lectically follows bc so we add bcd to Candidates. Its lectically greatest subset that is an intent is bd. We then generate the successors of ab, bd, ce and de. The set de has no successors for the same reasons as the set e in the previous step and we already know that c ⊕ d = cd so ce ⊕ d is known and ce has no successors.

The set of Candidates is then {abd, bcd, bde}. Among them, abd is a pseudo intent so we add abd → abcde to B. The set abcde lectically follows abd so we add abcde to Candidates. Its lectically greatest subset that is an intent is ab. We then generate the successors of bcd and bde. We already know bd ⊕ c so we also know bde ⊕ c. As such, computing bde ⊕ c is not needed and no other attribute is available so bde has no successors.

bcd ⊕ e = bcde

The set of Candidates is then {bcde, abcde}. Only bcde has a cardinality of 4 and it is a pseudo-intent so we add bcde → abcde to B. There are no new intents so we continue with the elements of Candidates of cardinality 5. The set abcde is an intent and has no successors since it is equal to A.

The algorithm stops having produced the following implications :

This is the Duquenne-Guigues basis of the context. In addition, the following spanning tree of the intent lattice has been constructed : It corresponds to the following set of partial implications : To compute it, Algorithm 3 has been used a total of 3 times.

To compute the Duquenne-Guigues basis of this context, our algorithm has performed 16 logical closures. Since the version of Next Closure using the optimizations presented in Section 2.1 would have performed only 15, it is more efficient in this case. However, on the context presented in Figure 3, our algorithm needs only 16 logical closures while Next Closure performs 19 of them. This is due to the fact that attributes are not considered if they have been used to generate an implication P → A and this context has a number of pairs of attribute that never appear together. This leads us to believe that our algorithm may be more efficient in those kinds of cases.

We proposed an algorithm that computes the Duquenne-Guigues basis of a formal context. It makes use of the lattice structure of the set of both intents and pseudo-intents in a fashion similar to that of algorithms for computing the concept lattice. The construction of attribute sets is inspired by Next Closure, the most common batch algorithm for computing pseudo-intents, in that it uses the lectic order to ensure the uniqueness of generated sets while avoiding going through what has already been computed. We showed that the algorithm can easily be modified, without much loss complexity-wise, to produce both the Duquenne-Guigues and the Luxenburger bases. Those two bases together are sought after in the domain of association rules mining where it is crucial to obtain a minimal number of rules. They are usually derived from the set of frequent concepts that has to be computed first and, to the best of our knowledge, no algorithm is able to compute them both directly and at the same time without a significant increase in complexity.

Some improvements can be made on the generation of the attribute sets. Most notably, the inclusion test in Algorithm 1 could be done during the computation of the implicational closure and multiple closures could be realized simultaneously. The fact that attribute sets are effectively generated following a partial order instead of a total order could also permit some degree of parallelization. Such optimizations will be the subject of further research on our part.

A Boolean valued function on the subsets of a set N , in short a Boolean function, is said to be anti-monotonic iff it is true for at most one of any two sets A and B for which A B ⊆ N holds. A Boolean function is said to be monotonic iff the fact that it is true for a set B implies that it is true for any subset of B. There is a natural bijection between the set of monotonic functions and the set of antimonotonic functions through the maximal true sets (e.g. [3]). Note furthermore that there is a bijection between anti-monotonic functions and antichains: the true sets of an anti-monotonic function form an antichain, i.e. a set of subsets of N such that no member set is included in another member set. In this paper we will use the antichain to denote an anti-monotonic function. We will denote the set of anti-monotonic functions on the set N ⊂ N by AM F (N ). We will use Greek letters to denote elements of AM F (N ) and Roman capitals to denote subsets of N , e.g. for A ⊆ B, B ⊆ A, α = {A, B} ∈ AM F (N ). Unless otherwise stated, N = {1, . . . n} will be the set of the first n positive integers, and in this case we will occasionally use the notation AM F (n) ≡ AM F (N ). The size of AM F (N ) or AF M (n) is the n-th number of Dedekind [8]. This size is known for values of n up to n = 8 [4]. Asymptotic expansions have been developed building on the size of the middle layer [6,5].

Example 1. For N = {1, 2}, the Boolean function 2 N → B, {∅ → f alse, {∅} → f alse, {1} → true, {2} → true, {1, 2} → f alse} is anti-monotonic. The antichain of true sets is given by {{1}, {2}}. This antichain will be used to denote the antimonotonic function.

For finite N , anti-monotonic functions form a finite distributive lattice with the join, meet and partial order given by

where for a general set S of subsets of N , max(S) is the set containing only the largest sets in S according to ⊆. A comprehensive textbook on Boolean functions is [2]. A recent study on counting non-equivalent monotone Boolean functions is found in [1]. Our antichains correspond to the notion of minimal sets playing an important role in the latter paper. A first analysis of intervals and decomposition is in [9]. We will make extensive use of the intervals in this lattice. For two antichains α, β ∈ AM F (N ), the closed interval with bounds α and β is given by

Analogous definitions hold for (half)open intervals. Note that these intervals are empty in case α ≤ β, in particular in case of non comparable α and β.

Given two intervals [ρ 1 , ρ 2 ] and [ρ 1 , ρ 2 ] in AM F (N ), we have

We will use the notation

A fundamental property in the decomposition of intervals is related to the concept of (dis)-connectedness. Two intervals are said to be disconnected if the decomposition in equation 6 is unique. Two intervals are connected if they are not disconnected. If two intervals are disconnected, we will call the join of these intervals direct:

The decomposition of intervals is based on the following Theorem 1, which is actually valid in a general distributive lattice.

Lemma 1. For two anti-monotonic functions α, β ∈ AM F (N ) we have

Proof. It is clear that for

More generally we have Theorem 1. For three anti-monotonic functions α, β, ρ

Proof. Note that (α∨ρ)∧(β ∨ρ) = (α∧β)∨ρ = ρ so that the interval

Theorem 1 can be strengthened as Theorem 2. For three anti-monotonic functions α, β, ρ

Corollary 2. For two anti-monotonic functions ρ 1 , ρ 2 = ∨ i∈I α i with ∀i, j ∈ I :

Proof. The proof follows from a simple iteration over the indices i ∈ I, applying Theorems 1 and 2 for each component α i , i ∈ I.

In the following, we will use the notation o ρ,γ for any two anti-monotonic functions ρ ≥ γ to denote the largest χ for which χ ∧ ρ = γ. A general partition of an interval is given by Theorem 3.

The intervals [γ, o ρ,γ ∧ ρ 2 ] for γ ≤ ρ are disjoint and nonempty.

the union of these sets is the whole interval. γ is a lower bound on S γ . Since (χ 1 ∧ ρ = γ and χ 2 ∧ ρ = γ) ⇒ (χ 1 ∨ χ 2 ) ∧ ρ = γ, the set has exactly one maximal element. We denote this element in the case of ρ 2 = {N } by o ρ,γ . Since, in addition,

where˜denotes the dual in the lattice AM F (N ).

Note 1. Note that the theorems so far, including the proofs, did not refer explicitly to anti-monotonic functions. In fact, they only relied on the properties of the operators ∧ and ∨ and are seen to be valid in any complete distributive lattice.

The following sections specifically refer to the definition of an anti-monotonic function as a function on subsets of a superset. Although we believe, the following properties, especially Theorem 4, can be generalized as well, we for now restrict the discussion to the space AM F (N ).

In what follows, disconnectedness of intervals turns out to be related to a corresponding property of the top of the interval.

Definition 2. Given two anti-monotonic functions ρ, α ∈ AM F (N ) with ρ ≤ α. Two sets A, B ∈ α are said to be connected with respect to ρ if and only if {A ∩ B} ≤ ρ. Connectedness of such sets is denoted by C ρ (A, B). C ρ (., .) defines a graph with the sets of α as vertices. The vertices of each connected component of this graph correspond to a subset of α and thus to an anti-monotonic function.

We will refer to these anti-monotonic functions as the connected components of α with respect to ρ and denote the set of such components by C ρ,α .

We now have

Proof. The proof follows immediately from Corollary 2. In what follows, we will use the following notations Definition 3. Let ρ 1 , ρ 2 ∈ AM F (N ), ρ 1 ≤ ρ 2 . We use the notion of level λ l in the interval [ρ 1 , ρ 2 ] to denote maximal anti-monotonic functions consisting of elements of a specific size l, and we introduce the (.) + and (.) − operators to transform functions from one level to a neighboring level, as follows:

Note that in Definition 3, in (17) α + ⊆ λ l+1 and in (18

We will now use decomposition to compute the size of any interval. Theorem 4 builds on the following Lemma.

. Then χ has the following unique decomposition:

where ∀l ≥ 0 :

Proof. We start from the decomposition in sets of specific levels:

where s is the size of the largest set in χ. We now set χ l = ∅ for l > s. Further, let χ s = χ ∩ λ s and note that the decomposition does not change if we add χ − s to the sets of level s − 1.

This suggests the recursive definition ∀l ∈ {0, . . . , s − 1} :

and since χ ≥ ρ 1 :

The inequalities in (19) now follow immediately from (22) and Definition 3.

Given the decomposition (19), it follows immediately that χ s = χ∩λ s .

. Since any set in χ s−1 not dominated by a set in χ s is necessarily in χ, we have χ s−1 ≤ χ − s ∨ (χ ∩ λ s−1 ) and equality follows. Recursive application of this reasoning proves uniqueness.

=

Proof. Note that the number of non trivial summations in (25) and ( 26) is always finite: there is a maximal level for any finite interval, above this level α ++ will be empty and the contribution in the power of 2 will be zero. Given the decomposition in Lemma 2, and a list of specific levels l 1 < l 2 < . . . < l k where σ li ⊆ λ li are given such that

where d i = l i+1 − l i and α +/−d = (. . . ((α +/− ) +/− ) . . . ) +/− (d operators (.) +/− ), one can ask for the set of χ decomposing according to (19) such that ∀i : χ li = σ li . This set has a lower bound

. . . and an upper bound χ t = ρ 1 ∨λ 0 ∨λ 1 . . .∨λ l0−1 ∨σ l0 ∨σ + l0 ∨σ +2 l0 . . .∨σ +(l1−l0−1) l0 ∨ σ l1 ∨ σ + l1 . . .. In fact, all elements in the interval [χ b , χ t ] satisfy this requirement. In the case of all odd, respectively all even, levels given, summing the sizes of all such intervals over all possible specifications σ 2l+1 , respectively σ 2l , results in the expansions of the Theorem. Example 6. As a simple application of Theorem 4, consider intervals of the form I N = [{∅}, N 2 ] where, for convenience, we use the notation N k to denote the set of subsets of size k of a set N = {1, 2, ..., n}. I N is seen to have only two nonempty levels. Indeed, λ 0 = {}, λ 1 is the set of all singletons of elements of N and

1 . We find

which is the well known formula for the number of labeled graphs with at most n nodes (Sloane series A006896 [7]). This identity becomes obvious when we apply the alternative expression:

= graphs g on n vertices

5 A Recursion Formula for the Size of the Complete Space

The previous sections were concerned with the structure of arbitrary intervals.

In this section, we present a formula for the size of AM F (n + k), k ≥ 0 summing over the space AM F (n). The formula is used to generate an efficient algorithm to compute the size of AM F (n + 2) from AM F (n). We start from the following observation, using the operator × defined as

Example 7. For χ = {{1}, {2, 3}, {3, 4}} and S = {5, 6, 7} we have according to this definition χ × {S} = {{1, 5, 6, 7}, {2, 3, 5, 6, 7}, {3, 4, 5, 6, 7}}.

We can now prove Lemma 3. Given n, k > 0, N = {1, . . . , n} and K n = {n + 1, . . . , n + k}, for each χ ∈ AM F (N ∪ K) there exists exactly one sequence {χ

Proof. For each

Now consider the restricted homomorphisms (2 K \{∅, K}, ⊆) → (AM F (N ), ≥ ), i.e fix χ S for any S ∈ {∅, N }. Any such restricted homomorphism can be completed by components χ 0 ≥ k∈K χ {k} and χ N ≤ k∈K χ N \{k} . We define coefficients P N,K,ρ0,ρ N as follows Definition 4. For finite N, K ⊆ N, N ∩K = ∅, and for ρ 0 , ρ N ∈ AM F (N ), ρ 0 ≥ ρ N , P N,K,ρ0,ρ N is the number of homomorphisms f :

and we find

Proof. Any restricted homomorphism f can be extended by elements of the intervals [∅, ρ N ] and [ρ 0 , {N }], and any extension results in a different function in AM F (N ∪ K).

The P-coefficients are in general hard to compute. In the special case of |K| = 2 however, the following property leads to a simple algorithm.

Property 1. For finite N, K ⊆ N, N ∩ K = ∅, |K| = 2, we have

Proof. Let K = {k 1 , k 2 }. The coefficient is the number of solutions to the simultaneous equations

Let A, B ⊆ ρ 0 \ρ N such that C ρ N (A, B), i.e. {A ∩ B} ≤ (ρ N \ρ 0 ). Then A and B must be in at least one of χ {k1} or χ {k2} due to (36) and in at most one due to (37). On the other hand, any set A in ρ 0 \ρ N must be in either χ {k1} or χ {k2} and can not be in both.

We thus obtain the formula

A Java implementation of Algorithm 2 , summing over non equivalent functions only for ρ N in AM F (6), allowed to compute AM F (8) in 40 hours on a Macbook Pro. Note that the order of summation can be chosen such as to minimize the number of evaluations of the interval sizes |[ρ 0 , {N }]|. Indeed, although the sizes of these intervals could be computed through the mapping Size of the representative of the class of the dual of ρ 0 , these transformations still are computationally intensive. In this paper, we analyzed intervals in the space of anti-monotonic functions. Some structural properties were derived which allowed decomposition. We used the properties of intervals to derive a formula allowing efficiently computing the size of any interval in spaces with values of n up to 7. Finally, we derived an expansion of the size of the (n+k)th space based on an enumeration of the space n. The terms in this expansion are products of sizes of intervals multiplied by coefficients which we termed 'P-coefficients of order k'. P-coefficients of order 2 turn out to be efficiently computable, and the resulting formula, combined with a reduction to nonequivalent anti-monotonic functions, allowed computing the 8th number of Dedekind on a very standard laptop in less than two days.

The results in sections 1 − 3 were obtained using the operators ∧ and ∨ only and are thus valid for any distributive lattice. The proofs of the results in sections 4, 5 explicitly relied on properties of sets. It is not hard to see that there are more general equivalents of these formulae. We plan to extend the analysis of intervals and derive the more general equivalents in a forthcoming paper.

The success in computing |AM F (8)| on a basic laptop naturally leads to the question how far a more sophisticated hardware could take us towards computing |AM F (9)|. We are presently undertaking such an attempt, but new idea's will be needed to succeed. Computing |AM F (9)| using P-coefficients of order 2 according to Algorithm 2 involves enumerating AM F (7) × nonequivalent AM F (7) which is exactly 2414682040998 × 490013148 = 1183225948328495041704 terms. Each term would require computing a second order P-coefficient and multiplying two interval sizes of intervals in AM F (7). There would be 490013148 such interval sizes to compute.

More promising is the study of the P-coefficients of higher order. Algorithm 2 for n = 6 equipped with a fast evaluator for order 3 P-coefficients could produce |AM F (9)|. Study of these higher order P-coefficients hence is on our research agenda.

Attribute exploration [1] allows the interactive determination of the implications holding between the attributes of a given context. However, there are situations when the object set of a context is too large (possibly infinite) or difficult to enumerate. With the examples (possibly none) of our knowledge we build the object set of the context step-by-step. The stem base of this context, that is a minimal set of non-redundant implications from which all the implications of the context follow, is built stepwise and we are asked whether the implications of the base are true. If an implication holds, then it is added to the stem base. If however, an implication does not hold, then we have to provide a counterexample. While performing an attribute exploration we have to be able to distinguish between true and false implications and to provide correct counterexamples for false implications. This is a crucial point since the algorithm is naive and will believe whatever we tell it. Once a decision was taken about the validity of an implication, the choice cannot be reversed. Therefore, the counterexamples may not contradict the so-far confirmed implications. The procedure ends when all implications of the current stem base hold in general. This way we obtain an object set which is representative for the entire theory, that may also be infinite.

The exploration process can be shortened by taking some background knowledge [2] into account that the user has at the beginning of the exploration.

As many data sets contain fuzzy data, it is a natural wish to generalise attribute exploration to the fuzzy setting. In [3] we have already shown how this can be done. It turned out that we have to make some restrictions on the implications (using the globalisation as the hedge) in order to be able to perform a successful attribute exploration. In this paper we generalise the fuzzy attribute exploration to the case with background knowledge. The main work starts in Section 3 where we show how non-redundant bases can be obtained while using background knowledge. The theory for the exploration is developed in Section 4 including an appropriate algorithm. In Section 5 we use a real-world data set to illustrative both exploration with and without background knowledge.

It should be mentioned that there is some overlap with results presented in the authors PhD thesis [4], see Chapter 5.

We assume basic familiarities with Formal Concept Analysis [1].

In the introductory section we have already explained the principle of attribute exploration. However, we have not yet presented its key to success. This is, why we do not have to reconsider already confirmed implications after adding new objects to the context. Proposition 1. ( [1]) Let K be a context and P 1 , P 2 , . . . , P n be the first n pseudointents of K with respect to the lectic order. If K is extended by an object g the object intent g ↑ of which respects the implications P i → P ↓↑ i , i ∈ {1, . . . , n}, then P 1 , P 2 , . . . , P n are also the lectically first n pseudo-intents of the extended context.

Attribute exploration was successfully applied in both theoretical and practical research domains. On the one hand it facilitated the discovery of implications between properties of mathematical structures, see for example [5][6][7]. On the other hand it was also used in real-life scenarios, for instance in chemistry [8], information systems [9], etc.

In case the user knows some implications between the attributes in advance, attribute exploration with background knowledge [10,2] can be applied. Using background knowledge in the exploration will considerably reduce the time of the process as the user has to answer less questions and provide less counterexamples.

Due to lack of space we omit the introduction of some basic notions from fuzzy logic, fuzzy sets and Fuzzy Formal Concept Analysis. We assume that the reader is familiar with these notions and refer to standard literature. For fuzzy theory we refer to [11,12], in particular, notions like residuated lattices with hedges and L-sets can be found for instance in [13]. For Fuzzy Formal Concept Analysis see [14,15] but also [16,17]. The theory about Fuzzy Formal Concept Analysis with hedges can be found in [13]. In this section we only present some notions concerning lectic order, attribute implications and the computation of their nonredundant bases.

We start with the fuzzy lectic order [18] which is defined as follows: Let L = {l 0 < l 1 < • • • < l n = 1} be the support set of some linearly ordered residuated lattice and M = {1, 2, . . . , m} the attribute set of an L-context (G, M, I). For (x, i), (y, j) ∈ M × L, we write (x, l i ) ≤ (y, l j ) :⇐⇒ (x < y) or (x = y and l i ≥ l j ).

We define

We say that B is lectically smaller than C, written B < C, if B < (x,i) C for some (x, i) satisfying (1). As in the crisp case, we have that B + := B ⊕ (x, i) is the least intent which is greater than a given B with respect to < and (x, i) is the greatest with B < (x,i) B ⊕ (x, i) (for details we refer to [18]).

Fuzzy Implications and Non-redundant Bases. Fuzzy attribute implications were studied in a series of papers by Bělohlávek and Vychodil [19,20]. We denote by S(A, B) the truth value of "the L-set A is a subset of the L-set B". Futher, (−) * denotes the hedge of a residuated lattice L, i.e., (−) * : L → L is a map satisfying a * ≤ a, (a → b) * ≤ a * → b * , a * * = a * and 1 * = 1 for every a, b ∈ L. Typical examples for the hedge are the identity, i.e., a * := a for all a ∈ L, and the globalisation, i.e., a * := 0 for all a ∈ L \ {1} and a * := 1 if and only if a = 1.

A fuzzy attribute implication (over the attribute set M ) is an expression A ⇒ B, where A, B ∈ L M . The verbal meaning of A ⇒ B is: "if it is (very) true that an object has all attributes from A, then it also has all attributes from B". The notions "being very true", "to have an attribute", and the logical connective "if-then" are determined by the chosen L. For an L-set N ∈ L M of attributes, the degree

If N is the L-set of all attributes of an object g, then ||A ⇒ B|| N is the truth degree to which A ⇒ B holds for g. For N ⊆ L M , the degree Due to the large number of implications in a formal context, one is interested in the stem base of the implications. Neither the existence nor the uniqueness of the stem base for a given L-context are guaranteed in general [20].

Let T be a set of fuzzy attribute implications. An L-set of attributes

As in the crisp case the stem base of a given L-context can be obtained through the pseudo-intents. P ⊆ L M is called a system of pseudo-intents if for each P ∈ L M we have: P ∈ P ⇐⇒ (P = P ↓↑ and ||Q ⇒ Q ↓↑ || P = 1 for each Q ∈ P with Q = P ).

) T := {P ⇒ P ↓↑ | P ∈ P} is complete and non-redundant. If (−) * is the globalisation, then T is unique and minimal.

The user may know some implications between attributes in advance. We will call such kind of implications background implications. In this section we will focus on finding a minimal list of implications, which together with the background implications will describe the structure of the concept lattice.

The theory about background knowledge for the crisp case was developed in [2] and a more general form of it in [10]. The results from [2] for implication bases with background knowledge follow by some slight modifications of the results about implication bases without background knowledge presented in [1]. The same applies for the fuzzy variant of this method. Hence, if we choose the empty set as the background knowledge, we obtain the results from [19,20].

We start by investigating the stem bases of L-contexts relative to a set of background implications. Afterwards we show how some notions and results for fuzzy implications and their stem bases change for our new setting.

The attribute sets of L-contexts and the residuated lattices L will be considered finite. Further, L is assumed to be linearly ordered. Definition 1. Let K be a finite L-context and let L be a set of background attribute implications. A set B of fuzzy attribute implications of K is called Lcomplete if every implication of K is entailed by L ∪ B. We call B, L-nonredundant if no implication A ⇒ B from B is entailed by (B \ {A ⇒ B}) ∪ L. If B is both L-complete and L-non-redundant, it is called an L-base.

Note that if we have L = ∅ in the above definition, then all L-notions are actually the notions introduced for sets of fuzzy implications. This remark holds also for the other notions introduced in this section.

For any set L of background attribute implications and any attribute L-set X ∈ L M we define an L-set X L ∈ L M and an L-set X Ln ∈ L M for each non-negative integer n by

An operator L on these sets is defined by

From [20] we know that L(−) is an L * -closure operator for a finite set M of attributes and a finite residuated lattice L.

Definition 2. For an L-context (G, M, I), a subset P ⊆ L M is called a system of L-pseudo-intents of (G, M, I) if for each P ∈ L M the following holds P ∈ P ⇐⇒ (P = L(P ) = P ↓↑ and ||Q ⇒ Q ↓↑ || P = 1 for each Q ∈ P : Q = P ).

As in the case without background knowledge, the usage of the globalisation simplifies the definition of the system of L-pseudo-intents. We have that P ⊆ L M is a system of pseudo-intents if P ∈ P ⇐⇒ (P = L(P ) = P ↓↑ and Q ↓↑ ⊆ P for each Q ∈ P with Q P ).

Theorem 3. The set B L := {P ⇒ P ↓↑ | P is an L-pseudo-intent} is an L-base of K. We call it the L-Duquenne-Guigues-base or the L-stem base.

Proof. First note that all implications from B L are implications of (G, M, I). We start by showing that B L is complete, i.

which is a contradiction because N does not respect this implication.

To finish the proof, we still have to show that B L is L-non-redundant. To this end let P ⇒ P ↓↑ ∈ B L . We show that this implication is not entailed by L := (B L \ {P ⇒ P ↓↑ }) ∪ L. As P = L(P ), it is obviously a model of L. We have ||Q ⇒ Q|| P = 1 for every L-pseudo-intent Q ∈ P different from P since P is an L-pseudo-intent. Therefore, P ∈ Mod(L). We also have that ||P ⇒ P ↓↑ || P = S(P ↓↑ , P ) = 1 and thus P is not a model of B L ∪ L. Hence, we have

In general we write P ⇒ P ↓↑ \ {m ∈ M | P (m) = P ↓↑ (m)} instead of P ⇒ P ↓↑ .

Note that computing the stem-base and closing the implications from it with respect to the operator L(−) will yield a different set of implications than the L-stem-base. Let us take a look at the following example.

Example 1. Consider the L-context given in Figure 1. In order to ensure that its stem-base and L-stem-base exist, we use the globalisation. Further, we use the Gödel logic. The stem-base is displayed in the left column of of the stem-base with respect to the operator L(−), we obtain implications of the form L(P ) ⇒ P ↓↑ , which are displayed in the right column of the figure. As one easily sees, the latter set of implications and the L-stem-base are different.

The set {L(P ) ⇒ P ↓↑ | P is a pseudo-intent with L(P ) = P ↓↑ } contains an additional implication, namely {a, b, c} ⇒ d.

For developing our theory about fuzzy attribute exploration with background knowledge, the following results are useful. First, the set of all intents and all L-pseudo-intents is an L * -closure system, as stated below. Due to lack of space we omit the proofs of the following two lemmas. Lemma 2. Let (G, M, I) be an L-context, let L be a set of fuzzy implications of (G, M, I). Further, let P and Q be intents or L-pseudo-intents such that S(P, Q) * ≤ S(P ↓↑ , P ∩ Q) and S(Q, P ) * ≤ S(Q ↓↑ , P ∩ Q).

Then, P ∩ Q is an intent.

Note that if we choose the globalisation for (−) * , then P ∩ Q is an intent provided that P and Q are (L-pseudo-)intents with P Q and Q P . Now we are interested in the closure of an L-set with respect to the implications of the L-base B L . Therefore, we first define for each L-set X ∈ L M and each non-negative integer n the L-sets X L • , X L • n ∈ L M as follows:

Further, we define an operator L • (−) on these sets by

Lemma 3. If (−) * is the globalisation, then L • given by (4) is an L * -closure operator and {L • (X) | X ∈ L M } coincides with the set of all L-pseudo-intens and intents of (G, M, I).

Remark 1. Note that for a general hedge, L • (−) does not need be an L * -closure operator. For instance, choose the Goguen structure and the identity for the hedge (−) * . Further, let L := { 0.3 /y ⇒ y}. Then,

(66) /y} = { 0.(66) /y}, and L • ({ 0.3 /y})(y) = { 0.3 /y}. Hence, L • (−) does not satisfy the monotony property, because we have

Particularly appealing is the usage of background knowledge in the exploration process. This proves itself to be very useful and time saving for the user. He/she will have to answer less questions, as the algorithm does not start from scratch. Due to Remark 1 and the fact that we are only able to perform a successful attribute exploration if the chosen hedge is the globalisation, we will consider only this hedge in this section. In order to arrive at the exploration with background knowledge we will present the lectic order, the "key proposition" and an appropriate algorithm for attribute exploration in this setting.

The lectic order is defined analogously as in Section 2, see (1). The only difference lies in the definition of "⊕". This time we are using the L * -closure operator (−) L • instead of (−) ↓↑ . Theorem 4. The lectically first intent or L-pseudo-intent is ∅ L • . For a given L-set A ∈ L M , the lectically next intent or L-pseudo-intent is given by the L-set A⊕(m, l), where (m, l) ∈ M ×L is the greatest tuple such that A < (m,l) A⊕(m, l). The lectically last intent or L-pseudo-intent is M . Now we are prepared to present the main proposition regarding attribute exploration with background knowledge in a fuzzy setting.

Proposition 2. Let L be a finite, linearly ordered residuated lattice with globalisation. Further, let P be the unique system of L-pseudo-intents of a finite L-context K with P 1 , . . . , P n ∈ P being the first n L-pseudo-intents in P with respect to the lectic order. If K is extended by an object g, the object intent g ↑ of which respects the implications from L ∪ {P i ⇒ P ↓↑ i | i ∈ {1, . . . , n}}, then P 1 , . . . , P n remain the lectically first n L-pseudo-intents of the extended context.

Proof. Let K = (H, M, J) be the initial context and let (G, M, I) be the extended context, namely G = H ∪ {g} and J = I ∩ (H × M ). To put it briefly, since g I is a model of P i ⇒ P JJ i for all i ∈ {1, . . . , n} we have that P JJ i = P II i . By the definition of L-pseudo-intents and the fact that every L-pseudo-intent Q of (H, M, J) with Q ⊂ P i is lectically smaller than P i , we have that P 1 , . . . , P n are the lectically first n L-pseudo-intents of (G, M, I).

We now have the key to a successful attribute exploration with background knowledge in the fuzzy setting, at least when we use the globalisation. With this result we are able to generalise the attribute exploration algorithm as presented by Algorithm 1. Its input is the L-context K, the residuated lattice L and the set of background implications L. The first intent or L-pseudo-intent is the empty set. If it is an intent, add it to the set of intents of the context. Otherwise, ask the expert whether the implication is true in general. If so, add this implication to the L-stem base, otherwise ask for a counterexample and add it to the context (line 2 − 11). Until A is different from M , repeat the following steps: Search for the largest attribute i in M with its largest value l such that A(i) < l. For this attribute compute its closure with respect to the L • (−)-closure operator given by (4) and check whether the result is the lectically next intent or L-pseudointent (line 12 − 16). Thereby, A i := A ∩ {1, . . . , i − 1}. In lines 17 − 25 we repeat the same procedure as in lines 2 − 11.

The algorithm generates interactively the L-stem base of the L-context. We enumerate the intents and pseudo-intents in the lectic order. Due to Proposition 2 we are allowed to extend the context by objects whose object intents respect the already confirmed implications. This way, the L-pseudo-intents already contained in the stem base do not change. Hence, the algorithm is sound and correct.

Algorithm 1: FuzzyExploration(K, L, L)

For our illustrative example we will consider the data from Figure 2. The objects are different universities from Germany and the attributes are indicators rating these institutions. Study situation overall: M.Sc. students were asked about their overall rating of their studies. IT-infrastructure: the availability of subject-specific software, PC pools and wifi were taken into account. Courses offered: amount of courses and the interdisciplinary references were relevant. Possibility of studying: timing of the courses and content of the curriculum were decisive. Passage to M.Sc.: clearly formulated admission requirements and assistance of the students with the organisational issues were relevant.

Suppose we want to explore the implications between the attributes from the L-context from Figure 2. We also know some examples, namely the TUs. These will be the objects of the L-context we start with. Further, we heard from others that the implications {a, b} ⇒ c, d ⇒ { 0.5 /a, e}, {a, e} ⇒ {c, d} and a ⇒ { 0.5 /b, 0.5 /c, 0.5 /e} hold. These will be considered the set of background implications L. The exploration process is displayed in the left column of Figure 3. The first L-pseudo-intent is ∅ and we ask the expert whether ∅ ⇒ ∅ ↓↑ holds. This is not the case and a counterexample is Uni Bochum. For implications that hold, for instance in step no. 3, the expert answers just "yes" and the implication is added to the L-base. Afterwards, the validity of the implication induced by the next L-pseudo-intent is asked, and so on. The algorithm continues until we reach M as an intent or L-pseudo-intent. In our case, however, the algorithm stops at step no. 10. This is due to the fact that the implications induced by the L-pseudo-intents after {b, 0.5 /d} are confirmed by the implications from the background knowledge. The result of the exploration is an extended context, namely Fig. 2. The data is an extract from the data published in the journal Zeit Campus in January 2013. The whole data can be found under https://bit.ly/ZCinsr-informatik.

that contains our initial examples and the counterexamples we (or the expert) has entered. We also obtain an L-base consisting of the background implications L and the implications we have confirmed during the exploration process.

In the right column of Figure 3 the exploration without background knowledge is displayed. One immediately sees that there are 4 additional steps. The first difference between the explorations appears in step no. 8. Without using background knowledge we have to answer the implication from the right column, while this implication is already confirmed if we use background knowledge. The exploration without background knowledge yields the same extended context whereas the stem base contains the implications we have confirmed during the process.

no. expl. w. background know.

simple expl.

1 Q: {} ⇒ { 0.5 /a, 0.5 /c, 0.5 /d} Q: {} ⇒ { 0.5 /a, 0.5 /c, 0.5 /d} E: no, ex. Uni Bochum E: no, ex. Uni Bochum 2 Q: {} ⇒ { 0.5 /c, 0.5 /d} Q: {} ⇒ { 0.5 /c, 0.5 /d} E: no, ex. Uni Duisburg E: no, ex. Uni Duisburg 3 Q: {} ⇒ 0.5 /d Q: {} ⇒ 0.5 /d E: yes E: yes 4 Q: { 0.5 /d, 0.5 /e} ⇒ 0.5 /b Q: { 0.5 /d, 0.5 /e} ⇒ 0.5 /b E: no, ex. Uni Bielefeld E: no, ex. Uni Bielefeld 5 Q: { 0.5 /b, 0.5 /d} ⇒ 0.5 /e Q: { 0.5 /b, 0.5 /d} ⇒ 0.5 /e E: no, ex. Uni Erlangen E: no, ex. Uni Erlangen 6 Q: { 0.5 /d, e} ⇒ 0.5 /c Q: { 0.5 /d, e} ⇒ 0.5 /c E: yes E: yes 7 Q: { 0.5 /a, 0.5 /b, 0.5 /c, 0.5 /d, e} ⇒ b Q: { 0.5 /a, 0.5 /b, 0.5 /c, 0.5 /d, e} ⇒ b E: no, ex. Uni Saarbrücken E: no, ex. Uni Saarbrücken 8 Q: { 0.5 /a, 0.5 /b, 0.5 /c, d, e} ⇒ {a, c} Q: d ⇒ { 0.5 /a, 0.5 /c, e} E: no, ex. Uni Heidelberg E: yes 9 Q: {c, 0.5 /d} ⇒ {a, 0.5 /b, d, 0.5 /e} Q: { 0.5 /a, 0.5 /b, 0.5 /c, d, e} ⇒ {a, c} E: yes E: no, ex. Uni Heidelberg 10 Q: {b, 0.5 /d} ⇒ { 0.5 /a, 0.5 /c} Q: {c, 0.5 /d} ⇒ {a, 0.5 /b, d, 0.5 /e} E: yes E: yes exploration stopped. 11 Q: {b, 0.5 /d} ⇒ { 0.5 /a, 0.5 /c, 0.5 /e} E: yes 12 Q: {a, 0.5 /d} ⇒ { 0.5 /b, 0.5 /c, 0.5 /e} E: yes 13 Q: {a, 0.5 /b, 0.5 /c, 0.5 /d, e} ⇒ {c, d} E: yes 14 Q: {a, b 0.5 /c, 0.5 /d, 0.5 /e} ⇒ {c, d, e} E: yes exploration stopped.

Fig. 3. Exploration with and without background knowledge.

A Galois lattice, or concept lattice, is a graph providing a representation of all the possible associations between a set of objects, or observations, and their describing attributes. Lattices can be queried, browsed and therefore provide a smart way to represent and retrieve information through a description context. Although they have been introduced a long time ago [1], they were hardly considered helpful for information retrieval before the end of the twentieth century and the work of [9,3,18] due to an exponential computational time issue. Even today, using concept lattices to handle a large set of objects described by an even wider set of attributes can be challenging. Indeed, it is still not trivial to use lattice's properties in a big development project, mainly because of the lack of available software frameworks. Being in need of such a tool to browse and query a dataset on comic books, described by an ontology [10], we propose an efficient Java implementation for the calculation of the immediate successors of a concept (i.e. to get the closest refined concepts according to the description of the starting point). This paper is organized as follows. After introducing our motivations in part 2, the third section reminds how are calculated the immediate successors in the state of the art. The next section details the implemented algorithm and how it has been done in order to be as effective as possible. Section 5 shows some experimentations related to the classical immediate successors algorithm. Finally the last section concludes this paper and brings up some perspectives on our ongoing work.

We are developing a multi-faceted solution to automatically analyze comic books in a) an image processing point of view [19], b) a semantic point of view [10]. One key point is the possibility for a user to retrieve comic books panels, the rectangular frames in which the pictures are drawn, similar to an input query, based on the semantic description of each panel from the dataset [11]. Two panels may share the same kind of content, such as speech balloons, spoken words, objects, characters or even some localized pixel's visual features (e.g colors, textures, shapes, etc.). They can be of the same shape, at the same location in the page or in the narration, drawn by the same person or come from the same volume (Table 1 and Fig. 1 show an example of what could be such shared properties). Possibilities are only limited by the ability of our system to recognize and deduce information. All these heterogeneous pieces of description have to be expressed in a way that can be interrogated and browsed efficiently. 1. Credit [5] One way to browse data is to guide the user by a relevance feedback mechanism as it can classically be seen in content based image retrieval (CBIR) [20] and machine learning [21]. To an input query, which can be a panel or a set of features, follows a loop of interactions between the computer and the final user that will guide him, hopefully sooner than later, to his answer. At each step, the system returns a set of result panels that share the same attributes, weighted by the estimated relevance of these attributes to the query. The user is then invited to label the panels based on what he considers to be important in his query. The relevant (resp. irrelevant) features are identified with the right (resp. wrong) labeled results, their weight is dynamically adjusted, so the query can be refined to produce a more accurate output. The interaction loop between the user and the system goes on and on until the user is satisfied.

The structure of concept lattices seems to fit particularly well to the task as each concept is made of a set of panels described by a shared set of attributes. The output can be composed of panels from several distinct concepts, chosen for the weight of their attributes. The user is then guided through the lattice structure by his choices without being aware of the underlying mechanism.

As we were working with the Java language, we started looking for a way to handle lattices that could easily be integrated to the main solution. The set of observations is meant to be quite large as it does not become very interesting to retrieve data until the volume gets critical. Because of the extreme heterogeneity of comic books' panels, the growth of the observation set (the pictures) automatically implies the growth of the attribute set (the description of those pictures). Therefore, the implementation has to be efficient when dealing with large sets of both attributes and observations.

More formally, a concept lattice is defined from a binary table, also denoted a formal context, (O, I, (α, β)) where O is the set of objects, I the set of attributes, α(A) the set of attributes shared by a subset A of objects, and β(B) the set of objects sharing a subset B of attributes. Each node of a concept lattice is denoted a concept (A, B), i.e. a maximal objects-attributes correspondence, verifying α(A) = B and β(B) = A. A is called the extent of the concept, and B its intent. Two formal concepts (A 1 , B 1 ) and (A 2 , B 2 ) are in relation in the lattice when they verify the following extension-generalization property:

The whole set of formal concepts fitted out by the order relation ≤ is called a concept lattice or a Galois lattice because it verifies the lattice properties, and the cover relation ≺ corresponds to the Hasse diagram of the lattice. The concepts ⊥ = (O, α(O)) and = (β(I), I) respectively correspond to the bottom and the top of the concept lattice. See the book of Ganter and Wille [8] for a more complete description of formal concept lattices.

Numerous generation algorithms have been proposed in the literature [16,7,2,17]. All of these proposed algorithms have a polynomial complexity with respect to the number of concepts (at best quadratic in [17]). The complexity is therefore determined by the size of the lattice (i.e. the number of concepts in the lattice), this size being exactly bounded by 2 |O+I| in the worst case (when the table context is a diagonal matrix of zeros) and by |O+I| in the best case (diagonal matrix of ones). A formal and experimental comparative study of the different algorithms has been published in [13]. Although all these algorithms generate the same lattice, they propose different strategies. Ganter's NextClosure [7] is the reference algorithm that determines the concepts in lectical order (next, the concepts may be ordered by ≤ or ≺ to form the concept lattice) while Bordat's algorithm [2] is the first algorithm that computes directly the Hasse diagram of the lattice, by computing immediate successors for each concept, starting from the bottom concept, until all concepts are generated. Immediate successor calculation is appropriate for an on-demand generation inside the structure, useful for a navigation without generating the whole set of concepts.

Bordat's algorithm, independently rediscovered by [14], is issued from a corollary of Bordat's theorem [2] stating that (A , B ) is an immediate successor of a concept (A, B) if and only if A is inclusion-maximal in the following set system F A defined on the objects set O by:

Immediate successors algorithm first generates the set system F A in a linear time ; then inclusion-maximal subsets of F A can easily be computed in O(|O| 3 ), using an inclusion graph for example. Notice that the inclusion-maximal subsets problem is known to be resolved in O(|O| 2,5 ) using sophisticated data structures ( [15,12]).

It is possible to consider the restriction of a concept lattice to the attributes set. Indeed, a nice result establishes that any concept lattice is isomorphic to the closure lattice defined on the set I of attributes, where each concept is restricted to its attributes part. The closure lattice is composed of all closures -i.e. fixed points -for the closure operator ϕ = α • β. Using the closure lattice instead of the whole concept lattice gives rise to a storage improvement, for example in case of large amount of objects. See the survey of Caspard and Monjardet [4] for more details about closure lattices.

Closure lattices can be generated by an extension of Bordat's algorithm (see Alg. 1) issued from a reformulation of Bordat's Theorem. Indeed, each immediate successor B of a closure B is obtained by

Therefore, immediate successors of a closure B are inclusion-minimal subsets in a set system F B defined on the attributes set I by:

The Limited Object Access algorithm (see Algorithm [6] for a complete description. The key idea behind this algorithm is to improve its efficiency by counting the objects, inspired from relational databases. Instead of considering the subset of observations as the extent of a subset of attributes, the computation of the inclusion-maximal subsets on F A is made considering only its cardinality, and an incremental strategy. Four cases have to be considered to test, for each attribute x of I\B and each already inserted potential successor X ⊆ I\B, the inclusion between ϕ(B + X) and ϕ(B + x):

3. Eliminate X as potential successor of B when ϕ(B + x) ⊂ ϕ(B + X) 4. Insert x as potential successor of B when x is neither eliminated or merged with X.

The inclusion test between ϕ(B + X) and ϕ(B + x) can easily be performed using the count function c and the following proposition from [6].

The count function c associates to any subset X of attributes the cardinality of the subset β(X):

The count function corresponds to the notion of support introduced in association rule-mining, and is in particular used by Titanic algorithm [22].

It has been proven to be effective on a large amount of objects with a complex- The ability of the algorithm to handle huge sets of data is very interesting. The impact of the number of observations on the performances can be limited, depending on the implementation of c, using for example multiple keys and robust algorithms used in databases that do not need to load all data for computing a cardinality [6].

We choose to implement the Limited Object Access algorithm in Java. The performance of the Limited Object Access presented in [6] comes from a PHP/MySQL implementation, backed up by the efficient SQL indexation system. Its behavior without the help of SQL remains to be seen.

While profiling the execution of a naive implementation, conducted without paying attention to optimization, we noticed that up to 86% of the computation time was used for the calculation of the candidate sets of attributes' extent. The extent of a set of attributes is the intersection of the extents of each of its elements. It appears that the most time consuming step of the extent calculation (up to 87% of the running time) is the intersection of two sets of elements. While it only takes around 50 microseconds to perform, the calls pile grows fast with the size of the dataset, resulting in a delivery time of full seconds, even minutes. A particular attention must be paid to the optimization of the extent calculation, both in terms of calls amount and processing time.

The number of calls is limited to three for a foreach loop, as c(B+x), c(B+X) and c(B + X + x) are consistent and can be computed once and for all at the beginning of the second loop. If they were not, the count function would have been called up to 8 times (2 times per if, plus 2 times for the last if).

Classical Java containers, like HashSet or TreeSet, are well suited for the task of storing the observations and attributes but are a bit too sophisticated for the representation of a simple context's binary table. In fact, observations do not necessarily have to be directly manipulated to compute the extent, a fortiori its cardinality, of a set of attributes. Assuming that the observations are sorted in a final order, each of them can be represented by its index in this order. So the extent of an attribute becomes a binary word whose length is the cardinality of the observations set. In this word, a 1 (resp. a 0) means this index's observation is (resp. is not) part of the extent. Java, as many programming languages, has a BitSet class to manipulate and execute operations over such data type.

The extent (resp. intent) of each attribute (resp. observation) of the context is computed and stored as a binary word once and for all at the beginning of the execution. Then, the extent of a set of attributes can be computed using a logical AND on the successive extents of all of its elements (see Table 2). The immediate benefit comes from the rapidity of the AND operation, performed in less than one microsecond (with a complexity of O(E(n/w)), n being the length of the bitset and w the size of the memory words used to store the basic AND operations). It is more than 50 times as fast as an intersection between two TreeSets for the same number of calls. Furthermore, this sticks to the primal boolean representation of a context (see Table 1) and the lattice (nor any part of it) does not have to be generated at any time.

Each attribute and each object is mapped to its bit index in the binary word for output readability purpose.

Extent of the set of attributes {b, h, t}

The dataset is made of 848 comic books panels, the observations, and two kinds of attributes. The first category, made of 100 attributes, is shared by the whole set of observations with a proportion going from 2 to 11 attributes for an average of 7. 28 attributes are assigned to a single observation. The second category includes the first one and adds 3433 attributes, leading to an average distribution of 15 attributes per observation. 3403 out of the 3533 attributes belong to less than 3 observations. Only 15 are shared by more than 100 objects.

As this system is meant to be used in a browsing context through relevance feedback, it has to be efficient going both ways from a concept (towards its successors and its predecessors). We ran our algorithm both on the calculation of the immediate successors of the bottom concept ⊥ and the immediate predecessors of the top concept . We computed the latter as the immediate successors of ⊥ on the inverted context (which is rigorously the same thing as calculating the immediate predecessors of in the regular context -see Fig. 2 and 3). We choose ⊥ as starting point because, according to our dataset, it is the concept that is supposed to have the most immediate successors.

Table 3 shows the processing times in seconds of the classical immediate successors algorithm and the Limited Object Access algorithm, both tuned with TreeSet and BitSet data structures for different scenarios corresponding to different complexity values. Processes have been run on a 8GB DDR3 machine, powered by a 2.7GHz quad core Xeon. The results show a significant improvement of the computation time which can be attributed, for one part, to LOA and, for the other part, to the use of binary words.

Fig. 3. Concept lattice generated from the inversion of the context presented in Table 1 Intent: Observations, Extent: Attributes

The bitset improvement over the LOA implementation shows a reduction of the execution time going from 14 to over 900 times. The calculation of the immediate predecessors of over the set of 3533 attributes is the worst possible case as it results in 848 different concepts of one observation, each of them with a set of around 20 attributes. The running time is almost entirely taken by the million of extent calculations, which is why the gain is more spectacular here.

A test on 500 randomly picked concepts has been run over the third dataset (|O| = 100, |I| = 848) resulting in a mean processing time of 0.18 second.

Computation time shrinkage is minimized on the classical method as the optimization only applies on the closure operation, which is a fraction of the global computation time.

We deal here with computation times kept below the second on a reasonable machine. This starts to be interesting in terms of human-machine interaction capabilities where at least a dozen of concept's immediate successors have to be calculated at each step.

We presented an efficient Java implementation of the immediate successors calculation. The short processing times on quite large datasets are promising and make the query by navigation through a lattice possible. The source code will be made available soon, along a full Java library to handle lattices.

This work was supported by the European Regional Development Fund, the region Poitou-Charentes (France), the General Council of Charente Maritime (France) and the town of La Rochelle (France).

This article, together with the software, originates from an observation about the current state of research in the lattice and the FCA communities. Lattice theory dates back to the works of Dedekind, Birkhoff [7] and Öre [19], and is a rich field in which FCA is deeply and fundamentally rooted. Despite that fact, relatively few studies in FCA takes advantage of lattice properties to enhance their results. This dichotomy of the two communities is apparent in the research interests: on the one hand, researchers from the graph and ordered set communities are focusing on equivalence theorem and characterizations, while on the other hand data mining researchers are more focused on practical or practically oriented results.

Although it is natural that this dichotomy exists because of the nature of each community's focus of interest, it is the author's suggestion that improvement of the communication between the two communities may produce a synergistic effect. The study of lattice cryptomorphisms and lattice properties is important for many reasons: other than giving a better understanding of the tools being used, it was shown to lead to the discovery of efficient algorithms in counting the number of Moore families [16] or calculating the stem basis [6] for example.

There are two main purposes for this software: first, to promote and to give a better understanding of the many shapes and forms of lattices thanks to an incremental approach -any change made in any equivalent cryptomorphism is transcribed to the other cryptomorphisms. Second, to help familiarize users to fundamental latticial properties that are recalculated after any modification. Its purpose is pedagogical for both students and researchers. Students can learn and get a better understanding on what is happening during the construction of the lattice and the implicational basis, while researchers can test hypotheses and find small illustrating examples. The program is written in C and is freely available (executable and source code) at http://www.cs.unic.ac.cy/ florent/software.htm

This paper is organized as follows: we start in Sec. 2 by describing the software itself. Sec 3 will recall the well-known definitions of lattices and some of the existing cryptomorphisms implemented in CryptoLat, together with a short explanation on how the equivalence is done. Finally, we compare in Sec. 5 Cryp-toLat with already existing software.

CryptoLat software is structured around a model view controller type of software architecture: each cryptomorphism described in Sec. 3 is a view with which the user can interact. The model is the reduced context associated with a Moore family on which all the calculations are based. When a view is updated, by adding or deleting a Sperner family for example, then the Moore family associated is calculated, the associated concept lattice, together with all the properties, is computed, and the other views get updated.

Depending on which view getting updated, the process may involve different steps. If the overhanging list or the Sperner village change, then first the Moore family associated with the new list, and the reduced context is then calculated. Similarly, if the input is an arbitrary set system, then the closure system is calculated as in Sec. 3.2. If the input is on the set of implications, since implications are usually on the set of attributes, the corresponding Moore family will be dual to the previous ones. From the reduced context, we are using Closed by One algorithm to calculate the concept lattice.

Fig. 1 shows a screen shot of the software with the five different views: the Moore family on top, the context as a datagrid, the list of implications, the list of overhanging and the list of Sperner families. The drawing of the lattice is done with a simple algorithm that optimise the position of each concept depending on the number (and position) of concepts covered.

In this section, we present the different cryptomorphisms of lattices implemented in CryptoLat in details; we do not claim to be exhaustive, so we refer the readers to [9] for a survey on those cryptomorphisms. Since we are describing implementations, the following descriptions needs only to be for the finite case.

Different yet equivalent definitions for lattices exist: here, we will define a lattice (L, ∧, ∨) as a set L with two binary operators satisfying the following four properties:

One can associate an order on the elements of L to these operators as follow: ∀x, y ∈ L, x ≤ y if x ∧ y = x or, equivalently, x ∨ y = y. Fig. 2 shows a lattice having six elements using its Hasse diagram representation: the elements of L are depicted by nodes in the plane, and a line segment connects the nodes corresponding to a covering pair x ≺ y (i.e. x ≤ y and ∀z, x ≤ z ≤ y implies x = z or y = z), where the node representing y is placed 'higher' in the plane than the node representing x.

Some elements of lattices are of particular interest: in any lattice, we have a minimal element, usually denoted by 0 L or ⊥, and a maximal element 1 L or . Irreducible elements of the lattice are also the subject of studies since they constitute minimal generating sets, and are often used to characterize classes of lattices. An element j of L is join-irreducible if j = ∨X then j ∈ X, or, Let J L and M L be the sets of join and meet-irreducible of L.

Let S be a finite set. A closure system (or Moore family) C on S is a family of subsets of S satisfying S ∈ C and, for all A, B ∈ C, A ∩ B ∈ C. A closure system is a lattice with the following operations:

Let A be an arbitrary set system on a set S. Then one can associate a closure system C A to A:

with the operators previously defined, constitute a lattice isomorphic to the lattice of Fig. 2.

Another fundamental cryptomorphism of lattice concerns closure operators. A closure operator on a set S is a map σ : P(S) → P(S) satisfying ∀X, Y ⊆ S:

These three properties together are equivalent to extensivity and path independence property [20]:

The well-known equivalence between closure operators and closure systems is the following: given the closure system C, the associated closure operator is σ C (X) = ∩{C ∈ C : X ⊆ C}. Conversely, given a closure operator σ, the associated closure system is the set of fixed points of σ, i.e. C σ = {X ⊆ S : X = σ(X)}.

One of the most celebrated cryptomorphism in the FCA community is the one between a lattice and a binary relation, also known as the basic theorem of Formal Concept Analysis [3,13].

Formally, a context (G, M, I) is a binary relation I between a set of objects G and a set of attributes M . One can associate the Galois connection between P(G) and P(M ) to this binary relation as

The lattice associated with the context (G, M, I), also called the concept lattice or Galois lattice, is the set of all concepts (A, B), with A = B and B = A, together with the order (A 1 , B 1 )

. Conversely, any lattice L is isomorphic to the Galois lattice of the context (J L , M L , ≤), also called the reduced context.

Two other binary relations, the arrows relations, on P(J) × P(M ) are often used for characterization theorems. Let j ∈ J, m ∈ M , we define:

Example 1 (continued). The lattice associated with the context of Fig. 3 is isomorphic to the lattice of Fig. 2.

An implicational system I on S is a binary relation on P(S), and if (A, B) ∈ I, we denote it A → I B or A → B if no confusion is possible. We say that A implies B or A → B is an implication (of I). A complete implicational system I is an implicational system on P(S) satisfying, ∀A, B, C, D ⊆ S:

[2] showed that a one-to-one correspondence between closure operators and complete implicational system exists. The closure system associated to a complete implicational system is

Example 1 (continued). The complete implicational system associated with the lattice in Fig. 2 As the above example shows, many implications in a complete implicational system can be redundant: in our example, it is evident that if we have c → e then we have b, c → e. So smaller implicational system allowing a smaller representation of a complete implicational system is of interest. We say that an implicational system Σ is a generating system for I if any implication of I can be obtained from Σ by applying recursively the rules defining a complete implicational system. A minimal generating system for I is called a basis for I, and a minimum basis is called a canonical basis.

One particular basis, called the stem basis [15], can be directly defined: the stem basis is made of all implications X → σ(X) − X, with X a critical set. A set

An overhanging relation O is a binary relation on P(S) that was originated in [1] in consensus theory on trees under the term of nesting, and was generalized in [12] to any lattice. We will indifferently write (A, B) ∈ O or A O B to signify that a set A is overhanged in B. An overhanging relation satisfies the following properties:

We showed in [12] that overhanging relations and closure operators (and so lattices) are in a one-to-one correspondence by associating the overhanging relation defined as A O B ⇐⇒ A ⊂ B and σ(A) ⊂ σ(B) to any closure operator, and, conversely, associating the closure operator σ(X) = {x ∈ S : x O c X ∪ {x}} to any overhanging relation. In fact, an overhanging relation can be seen as a kind of negative implication, as given by the equivalence that A → B if and only if (A, A ∪ B) ∈ O Example 1 (continued). The overhanging relation associated with the lattice of Fig. 2 is as follows:

A Sperner family F on S is a family s.t. ∀X, Y ∈ F, X and Y are incomparable for set inclusion. A Sperner village V = (F 1 , ..., F n ) on S is a set of n Sperner families. The equivalence between a closure operator and a Sperner village is obtained as follows: given σ closure operator, for any x ∈ S we create the Sperner family C x = {X ⊆ S : x ∈ σ(X) and X minimal for that property}. Conversely, the closure operator associated with V is defined as σ(X) = {x ∈ S : X contains a set of C x }.

Example 1 (continued). The Sperner village equivalent with our running example is the following Fig. 4. When we add to the existing Sperner village the Sperner family {{e}, {b, c}}, the software computes the smallest Sperner village possible from the existing village together with the new family, and from this Sperner village finds the associated concept lattice. Fig. 5 shows the results.

The main focus of the software concerns the dependency between the different cryptomorphisms associated with lattices. In the same pedagogical spirit, we also implemented different properties of lattices and elements of lattices, briefly described in Tab. 1 and in Tab. 2 for completeness sake. We refer the readers to [11,14,22] for more information on lattices and lattice properties.

All of the software mentioned in Table 3 have different goals. In terms of ease of use, Concept Explorer is the closest to our goal, but offers limited functionalities. OpenFCA is similar to Concept Explorer, offering an interesting, web based and intuitive approach to context creation, lattice visualization and attribute exploration. FCAstone's main purpose is file formats conversion to improve interoperability between FCA and graph editing. The other software (Galicia, ToscanaJ, Lattice Miner, FCART) were designed to push the boundaries of the scalability of analysis and lattice drawing. Research wise, Formal Concept Analysis Research Toolbox (FCART) is a particularly interesting approach of a universal Tthere is a ranking function r :

Other Lattices Properties δ-hard ∀j, j ∈ JL, jδj , i.e. there exists x ∈ L such that j ≤ x, j ≤ x and j < j ∨ x δ-strong

The transitive graph of the δ relation is complete Sperner poset L is ranked, and the size of the maximal antichain is equal to the maximal size rank Table 2. List of elements properties

integrated environment to lattice construction and Formal Concept Analysis techniques, where one can test new algorithms for drawing lattice for example. Many other cryptomorphisms of concept lattices exist but are not implemented yet. For example, [4] proved that we can associate a minimal separator of the co-bipartite graph to every concept of the concept lattice, and [16] showed a bijection between Moore families and ideal colour sets of the coloured poset. Similarly we are planning to increase the number of properties available, adding for example the dismantlable property (one can repeatedly remove a doubly irreducible element until the lattice becomes a chain) or being a convex geometry (∅ ∈ L and ∀x ∈ L, there is a unique minimal (for inclusion) generator of x). the lattice drawing component is also under consideration, to be enhance and more user friendly.

Ondrej Krídlo 1 and Manuel Ojeda-Aciego 2

1 University of Pavol Jozef Šafárik, Košice, Slovakia 2 Dept. Matemática Aplicada, Univ. Málaga, Spain

Morphisms have been suggested [7] as fundamental structural properties for the modelling of, among other applications, communication, data translation, and distributed computing. Our approach can be seen within a research topic linking concept lattices with the theory of Chu spaces [10,11]; in the latter, it is shown that the notion of state in Scott's information system corresponds precisely to that of formal concepts in FCA with respect to all finite Chu spaces, and the entailment relation corresponds to association rules (another link between FCA with database theory) and, specifically, on the identification of the categories associated to certain constructions.

Other researchers have studied as well the relationships between Chu constructions and L-fuzzy FCA. For instance, in [1] FCA is linked to both ordertheoretic developments in the theory of Galois connections and to Chu spaces; as a result, not surprisingly from our previous works, they obtain further relationships between formal contexts and topological systems within the category of Chu systems. Recently, Solovyov, in [9], extends the results of [1] to clarify the relationships between Chu spaces, many-valued formal contexts of FCA, lattice-valued interchange systems and Galois connections.

This work is based on the notion, introduced by Mori in [8], of Chu correspondences as morphisms between formal contexts. This categorical approach has been used in previous works [3,5,6]. For instance, in [6], the categories associated to L-formal contexts and L-CLLOS were defined and a constructive proof was given of the equivalence between the categories of L-formal contexts with L-Chu correspondences as morphisms and that of completely lattice L-ordered sets and their corresponding morphisms. Similar results can be found in [2], where a new notion of morphism on formal contexts resulted in a category equivalent to both the category of complete algebraic lattices and Scott continuous functions, and a category of information systems and approximable mappings.

We are concerned with the category of fuzzy formal contexts and λ-Chu correspondences, built on the basis of a residuation-preserving isotone Galois connection λ. Then, the corresponding extension of the notion of bond between contexts is generalized to this framework, and its properties are studied.

2.1 Residuated lattice Definition 1. A complete residuated lattice is an algebra L, ∧, ∨, 0, 1, ⊗, → where -L, ∧, ∨, 0, 1 is a complete lattice with the top 1 and the bottom 0, -L, ⊗, 1 is a commutative monoid, -⊗, → is an adjoint pair, i.e. for any a, b, c ∈ L:

Lemma 2. Let ↑, ↓ be a pair of derivation operators defined on an L-fuzzy formal context C. A pair ↑, ↓ forms a Galois connection between complete lattices of all L-sets of objects L B and attributes L A . Definition 5. Let C = B, A, L, r be an L-fuzzy formal context. A formal concept is a pair of L-sets f, g ∈ L B × L A such that ↑ (f ) = g and ↓ (g) = f . The set of all L-concepts of C will be denoted as FCL(C). The object (resp. attribute) part of any concept is called extent (resp. intent). The sets of all extents or intents of C will be denoted as Ext(C) or Int(C), respectively.

2.3 L-Bonds and L-Chu correspondences Definition 6. Let X and Y be two sets. An L-multifunction from X to Y is said to be a mapping from X to L Y .

, 2} be two L-fuzzy formal contexts. The sets L-Bonds(C 1 , C 2 ) and L-ChuCors(C 1 , C 2 ) form complete lattices and, moreover, there exists a dual isomorphism between them.

3 Residuation-preserving isotone Galois connections Definition 9. An isotone Galois connection between two complete lattices

The general theory of adjunctions provides the following result:

Definition 10. An isotone Galois connection λ between two complete residuated lattices

) is said to be a residuationpreserving isotone Galois connection if for any k 1 , m 1 ∈ L 1 and k 2 , m 2 ∈ L 2 the following equalities hold:

The set of all residuation-preserving isotone Galois connections from L 1 to L 2 will be denoted as

There is no need to consider other →-preserving rules, since they follow from the previous ones, as stated by the following lemmas.

Lemma 5. For all k ∈ L 1 and m ∈ L 2 the following equality holds

Proof. Consider the following chain of equivalences

As a result, we can write

It is worth to note that this proof does not work in the case of (6) because, for the construction of λ L , one had to use (3) instead of (2).

Lemma 6. For all k i , m i ∈ L i for i ∈ {1, 2}, the following inequalities hold

Proof. By the adjoint property and the following chain of inequalities

Similarly, we obtain the other one.

Below, we recall the notion of fixpoint of a Galois connection, the definition is uniform to the different types of Galois connection, either antitone or isotone, or with any other extra requirement.

Definition 11. Let λ be a Galois connection between complete residuated lattices L 1 and L 2 . The set of all fixpoints of λ is defined as

, the set of its fixpoints can be provided with the structure of complete residuated lattice

) , and ⊗ and → are defined componentwise.

Proof. We have to check just that the componentwise operations provide a residuated structure to the set of fixed point of λ.

Conditions ( 4) and ( 5) allow to prove that componentwise product ⊗ is a closed operation in FP λ , whereas condition (6) allows to prove that the componentwise implication is a closed operation in FP λ .

It is not difficult to show that, in fact, FP λ , ⊗, 1 is a commutative monoid: commutativity and associativity follow directly; for the neutral element just consider the following chain of equalities: For any

The adjoint property follows by definition.

In this section, the notion of L-Chu correspondence is generalized on the basis of a residuation-preserving isotone Galois connection λ. The formal definition is the following:

such that for any (o 1 , a 2 ) ∈ B 1 × A 2 the following inequality holds

is said to be a λ-Chu correspondence.

Note that (10)

It is not difficult to check that the definition of λ-Chu correspondence generalizes the previous one based on a complete (residuated) lattice L; formally, we have the following Definition 13. Let X be an arbitrary set. Mapping id X defined by id X (x) = x for any x ∈ X is said to be an identity mapping on X.

Lemma 8. Any L-Chu correspondence is a id L , id L -Chu correspondence.

We are now in position to define the category of parameterized fuzzy formal contexts and λ-Chu correspondences between them: Definition 14. We introduce a new category whose objects are parameterized fuzzy formal contexts B, A, L, r and λ-Chu correspondences between them.

The identity arrow of an object B, A, L, r is the id L , id L -Chu correspondence ι such that

for any a ∈ A -where χ x (x) = 1 and χ x (y) = 0 for any y = x.

where, for any

Obviously, one has to check that the proposed notions of composition and identity are well-defined, and this is stated in the following lemmas.

We proceed with the corresponding extension of the notion of bond between contexts, and the study of its properties.

Transposition of such multifunction is defined by ω t (y)(x) = ω(x)(y).

The known relation between L-bonds and L-Chu correspondences is preserved in the λ-case. Formally, Lemma 11. Let β be a λ-bond between two fuzzy contexts

is λ-Chu correspondence.

Proof. By calculation

Lemma 12. Let L 1 , L 2 be two complete residuated lattices satisfying the double negation law and let λ ∈ CRL(L 1 , L 2 ). Then Φ λ satisfies double negation law.

Proof. Consider an arbitrary k 1 , k 2 ∈ FP λ . We have that, by definition,

The result for the second component is obvious; for the first one, taking into account that (λ R (0 2 ), 0 2 ) is a fixed point, we have

where equality ( ) follows because, by Lemma 7, λ R (k 2 ) → 1 λ R (0 2 ) is a closed value in L 1 for the composition λ R λ L , and inequality ( * ) follows from the monotonicity of λ L . As a result of the previous chain we obtain the following equality

and, again by Lemma 7, since k 1 and λ R (0 2 ) are closed for λ R λ L , as a result

We are now ready to include the characterization result on the structure of λ-bonds, but we have to introduce the notion of λ-direct product of contexts.

) is said to be the λ-direct product of C 1 and C 2 , where

Then

Similarly

Then let us define a multifunction β :

where σ and τ are multifunctions above. We see that

Therefore β is a λ-bond between C 1 and C 2 .

Lets have two tables of the following data. First table of students, school subjects and study results. Second table of universities (or areas of study) and their requirements for results of students. We would like to find the assignment of students and universities that depends on study results and requirements of universities.

First table is filled by degrees from well known structure {A,B,C,D,E,F} where A is best and F means failed. Second one is filled by degrees {Ex,G,W} that means Ex-excelent, G-good, W-weak. Now lets define a λ-translation between such truth-degrees structures.

is an isotone Galois connection. In fact, λ L , λ R is a residuationpreserving isotone Galois connection over Lukasiewicz logic, whose set of fixpoints is

The λ-direct product S∆ λ U is the following table that has 510 concepts. Lets simplify the table with translation (A,Ex) as 1, (B,G) as 0.5 and (C,W) as 0. 1 1 0.5 0 1 1 1 0.5 1 1 1 1 1 1 1 1 1 1 1 0.5 1 1 1 1 1 1 1 1 1 1 0.5 0 1 1 1 1 1 1 1 0.5 1 1 0.5 0 1 1 0.5 0 0 0.5 1 0.5 0.5 1 1 1 1 1 1 1 1 1 1 1 0.5 1 1 1 1 1 1 1 1 1 1 1 0 0.5 1 0.5 1 1 1 1 0.5 1 1 1 0 0.5 1 0.5 0 0.5 1 0.5 0 0 0.5 0 0.5 0.5 1 0.5 1 1 1 1 1 1 1 1 0.5 0.5 1 0.5 1 1 1 1 1 1 1 1 0 0 0.5 0 1 1 1 1 0.5 0.5 1 0.5 0 0 0.5 0 0 0 0.5 0 Extents of S∆ λ U are tables of the form students×universities and intents are tables of the form subjects×subjects. One of the concepts that their intents has 1 on diagonal (it means that any subject is assigned to itself) is shown below.

Such concept should be translated into {1; 0.5; 0} structure.

Med Tech CS Anna 0.5 0.5 1 Boris 1 0.5 0 Cyril 0.5 0.5 0 Math Phi Chem Bio Math 1 1 0.5 0 Phi 0.5 1 1 0.5 Chem 0 0.5 1 0.5 Bio 0 0.5 1 0.5

Now we can see the result. Due to results of students and requirements of universities we can advise Anna to study Computer science; similarly, we can advise Boris to study Medicine or Technical area; finally, it is hard to advise anything to Cyril. The assignment is right as it is obvious from study results.

Let's change the λ-connection between such truth degrees structures as follows:

The set of fixpoints is FP λ = {(A, Ex); (B, G); (D, W)} such that is easy to translate (A, Ex) as 1, (B, G) as 0.5 and (D, W) as 0. The direct product is shown below, and has 104 concepts.

1 1 1 1 1 1 1 1 1 1 0.5 0.5 1 1 0.5 0.5 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0.5 0.5 1 1 0.5 0.5 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0.5 0.5 1 0.5 0.5 0.5 1 0.5 1 1 1 1 1 1 1 1 1 1 1 1 0.5 0.5 1 0.5 0.5 0.5 1 0.5 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0.5 0.5 1 1 0 0 0.5 0.5 0 0 0.5 0.5 0.5 0.5 1 1 1 1 1 1 1 1 1 1 0 0 0.5 0.5 0 0 0.5 0.5 0.5 0.5 1 1 1 1 1 1 1 1 1 1

We have chosen one with 1-diagonal in the intent.

Translating the context into {1; 0.5; 0} structure, we obtain Med Tech CS Anna 0.5 1 1 Boris 1 1 0.5 Cyril 0.5 0.5 0 Math Phi Chem Bio Math 1 1 0.5 0.5 Phi 1 1 1 0.5 Chem 0.5 0.5 1 0.5 Bio 0.5 0.5 0.5 0.5

It can seen that our advice is more generous but still coincide to input data.

We continue our study of the general notion of L-Chu correspondence by introducing the category CRL-ChuCors incorporating residuation to the underlying complete lattice L, specifically, on the basis of a residuation-preserving isotone Galois connection λ. Then, the L-bonds are generalized within this same framework, and its structure is related to that of the extent of a suitably defined λ-direct product. A first relationship between extents of λ-direct product have been proved; it is expected to find a proof of the stronger result which states an isomorphism between the extents of the λ-direct product and the λ-bonds between C 1 and C 2 . Potential applications are primary motivations for further future work, for instance, to consider possible classes of formal L-contexts induced from existing datamining notions, and study its associated categories. Abstract. The second order formal context is a formal context such that its object and attribute sets are disjoint unions of object and attribute sets of external formal contexts. Every subset of object or attribute set will be evaluated from concept lattice of corresponding external formal context. The paper provides a method how to compute such second order formal concepts by using of bonds between external formal contexts or by using of heterogeneous formal contexts methods. Last part of the paper shows how this structure generalizes homogenic fuzzy formal context and its derivation operators.

Imagine the following situation as a motivation. Lets have a group of people that everybody knows each other (schoolmates, co-workers, etc.). All of them are going to travel somewhere together and you (as an organizer of the trip) would like to know their requirements for accommodation. Consider the following formal context. Set of objects represents a group of co-workers (Anna, Bob, Cyril, David, Erik). Set of attributes expresses their requirements (TV, Wellness, Closeness to a city center, Restaurant in a hotel). An example of such context is in the following table. Lets denote the following table as P as preferences.

A particular formal concept of the given context describes a set of co-workers such that these people together have a common requirements for accommodation.

In addition, there are another two formal contexts. The first one describes a friendship relation inside the group of such people (denoted as F). The second one describes a situation about hotels and services they offer (denoted as H).

All contexts are filled by truth degrees from the following set {• = true, • = middle, " " = false}. Computing of L-concepts is based on Lukasiewicz logic. Now, we aim at connecting such table data with known intercontextual mechanisms in order to obtain closed sets of friends from F that are able to stay in any of a closed set of hotels from H. The hotels of this closed set offer as much requirements from P as it gets.

Formal Concept Analysis (FCA) as an applied Lattice Theory [7] has become a very useful tool for discovering of hidden knowledge inside a data of objectattribute table, so called formal contexts. Fundamental construction of FCA is a Galois connection between complete lattices of all subsets of objects and attributes. A Galois connection consists of two mappings such that a composition of these mappings form a closure operators on each subsets of complete lattice. Pair of closed subset of objects and subset of attributes connected to each other by the Galois connection is called formal concept. The set of formal concepts forms a complete lattice. The mentioned notions were generalized over a fuzzy logic based on a complete residuated lattice. The notions of order, Galois connection and complete lattice were also generalized by Bělohlávek in [3][4][5][6].

Definition 1. Complete residuated lattice is an algebra L, ∧, ∨, 0, 1, ⊗, → , where -L, ∧, ∨, 0, 1 is a complete lattice with top 1 and bottom 0, -L, ⊗, 1 is a commutative monoid, -⊗, → is an adjoint pair, i.e. Lemma 1. Let ↑, ↓ be a pair of derivation operators defined on an L-fuzzy formal context B, A, r . A pair ↑, ↓ forms a Galois connection between complete lattices of all L-sets of objects L B and attributes L A . Definition 4. Let C = B, A, r be an L-fuzzy formal context. Formal concept is a pair of L-sets f, g ∈ L B × L A such that ↑ (f ) = g and ↓ (g) = f . The set of all L-concepts of C will be denoted by FCL(C). Object or attribute part of any concept is called extent or intent. Sets of all extents or intents of C will be denoted as Ext(C) or Int(C), respectively.

FCA provides the useful methods how to connect two formal contexts. A structure of the so called Chu correspondence was introduced by Mori [13,14] that is very close to the notion of bond [7]. The notions of Chu correspondence and bond were extended into L-fuzzy Chu correspondence and L-bond in [8]. The corresponding notions are introduced now.

is said to be an L-Chu correspondence between C 1 and C 2 . Set of all L-Chu correspondences between L-contexts C 1 and C 2 will be denoted by L-ChuCors(C 1 , C 2 ).

is said to be an L-bond. Set of all L-bonds beyween L-contexts C 1 and C 2 will be denoted by

forms a complete lattice and, moreover, there exists a dual isomorphism between them.

The dual isomorphism between bonds and Chu correspondences is based on the following construction. Consider two L-fuzzy formal contexts

On the other hand, let ϕ ∈ L-ChuCors(C 1 , C 2 ). Then β ϕ defined as

Categories ChuCors and L-ChuCors of classical or fuzzy formal contexts and classical or fuzzy Chu correspondences are described in [9,13]. Important categorical property of * -autonomism is also proved in mentioned papers. The continuation of categorical research in [10] resulted in a categorical equivalence of L-ChuCors and a category L-CLLOS of so called completely lattice L-ordered sets and monotone fuzzy Galois connections. Equivalence is proved by constructing of equivalence functor between these categories.

Definition 7. Lets define a functor Γ : L-ChuCors −→ L-CLLOS in the following way:

where for any multifunction ω :

In [10] is proved that Γ is the equivalence functor. Hence, it holds for the particular two L-concepts that

Proof. Due to order reversing of dual L-context C * 2 for any two L-concepts we obtain f,

3 Formal concept analysis of second order

Once we have introduced preliminaries, the formal context of second order and the corresponding results are presented now in details.

Definition 8. Consider two non-empty index sets I and J and an L-fuzzy formal context i∈I B i , j∈J A j , r , whereby

Moreover, consider two non-empty sets of L-contexts notated

In what follows, consider the below used notation. Lets have an L-set f :

With the help of functor Γ , we define the mappings between products of fuzzy concept lattices of objects and attributes formal contexts of the following form: Definition 9. Lets define the mappings ⇑, ⇓ as follows

Proof. Let the L-context be of the form B, A, r . Hence

Lemma 5. Pair of mappings ⇑, ⇓ forms a Galois connection between complete lattices i∈I FCL(C i ), I and j∈J FCL(D j ), J . Proof. Proof is provided in fuzzy ordering as a generalization of classical one.

In this subsection will be presented a method that simplifies the previous consideration.

, 2} be two L-fuzzy contexts and let β be an arbitrary L-bond between C 1 and C 2 . Consider the following pair of mappings ↑ β :

for any f ∈ L B1 and g ∈ L A2 . Lemma 6. Let C i = B i , A i , r i for i ∈ {1, 2} be two L-fuzzy contexts and let β be an arbitrary L-bond between C 1 and C 2 . A pair ↑ β , ↓ β forms a Galois connection between complete lattices Ext(C 1 ), ≤ and Int(C 2 ), ≤ , where ≤ is ordering based on fuzzy sets inclusion.

Proof. Proof of the fact that ↑ β , ↓ β forms a Galois connection between L B1 , ≤ and L A2 , ≤ is simple, ↑ β , ↓ β is a pair of derivation operators for L-context B 1 , A 2 , β r , where binary L-relation β r is defined as

. Now, we will show that ↑ β , ↓ β is a pair of mappings between complete lattices of extents and intents of C 1 and C 2 , respectively. First, let f be an extent of C 1 .

Proof of ↓ β (g) is an extent of C 1 is easy to obtain similarly with equality

We define an L-context such that its L-concept lattice is isomorphic to a complete lattice of all second order formal concepts. Definition 11. Let K be a second order formal context of the form

where

Formal Concept Analysis of higher order where Ψ j = ↓ j (Ψ j ), Ψ j for any j ∈ J. Then Φ =⇓ (Ψ ) and Φ, Ψ is a second order concept of K.

The motivation example introduced in Section 1 can be considered as the second order formal context {Anna,Bob,Cyril,David,Eva}, F, {TV,W,Ce,R}, H, r , whereby r represents the L-relation from P. Firstly, we find a bond ρ that is the closest to r.

There are just six (instead of twenty-eight L-concepts of P) L-concepts of ρ(P) such that we can easily convert into the form of second order concepts. The following table contains the list of the all second order concepts.

The first concept can be interpreted as follows. Friends Bob and Cyril with their common requirements should stay in hotel H1. They should stay also in H3 and H4 with a little relaxation of their requirements. The fourth concept is saying that Anna as a very lonely person should stay in H1 or H4. The second concept includes the whole group of co-workers who have very poor common requirements. Thus, all people should stay in an arbitrary hotel together.

The fruitful idea is to view the second order formal context in terms of a heterogeneous formal context proposed in [2]. The corresponding notions of the underlying structures are introduced now. Definition 12. Heterogeneous formal context is a tuple B, A, P, R, U, V, , where -B and A are non-empty sets,

Lets describe our situation in terms of heterogeneous formal contexts. Below is the translation:

-B and A will be the index sets I and J, -complete lattices U i or V j for any (i, j) ∈ B × A = I × J will be the complete lattices Ext(C i ), ≤ and Int(D j ), ≤ , -P i,j will be a complete lattice of all fuzzy relations from L Bi×Aj , -any value of relation r will be a binary relation

for any f ∈ Ext(C i ) and g ∈ Int(D j ) and any (b, a) ∈ B i × A j . The mapping • i,j is isotone due to isotonicity of ⊗.

Proof of left-continuity of the second argument is similar.

Definition 13. Lets define a pair of derivation operators , of the following form : i∈I Ext(C i ) → j∈J Int(D j ) and : j∈J Int(D j ) → i∈I Ext(C i ) defined for heterogeneous formal context mentioned above as follows:

Proof. Let j ∈ J be arbitrary.

Hence ↑ K (Φ) ≤ (Φ). Similarly for ↓ K and .

In this part, we focus on an appropriate generalization of the standard homogenic fuzzy formal concept derivation operators in two different ways.

Lemma 10. Lets have an L-fuzzy formal context {x}, L, λ , where for an arbitrary

Proof. Let k be an arbitrary value from L. Similarly for ↓ K =↓.

Moreover, an another connection is presented in this subsection. The connection is based on the fact that concept lattice of X, X, = is isomorphic to L X in the case that L is closed under double negation law.

Lemma 12. Lets have an L-fuzzy formal context X = X, X, = , where L is closed under double negation law. Then any L-set from L X is closed in X . Proof. Index sets I and J are singletons in this case. So due to previous lemma

Because of the previous lemma we know that any row and column or r is closed in B and A, respectively. Hence r ∈ L-Bonds(B, A) and r = ρ.

Finally ↑ K =↑. Similarly for ↓ K =↓.

Lattices for Relational Concept Analysis Xavier Dolques Based on FCA, it produces more results than the latter but also an increase in complexity. Besides, in numerous applications of FCA, AOC-posets are used rather than lattices in order to reduce combinatorial problems. An AOC-poset is a subset of the concept lattice considering only concepts introducing an object or an attribute. AOC-posets are much smaller and easier to compute than concept lattices and still contain the information needed to rebuild the initial data. This paper introduces a modication of the RCA process based on AOC-posets rather than concept lattices. This work is motivated by a big set of relational data on river streams to be analysed. We show that using AOC-poset on these data provides a reasonable concept number.

1 Introduction

Relational Concept Analysis (RCA) [1] is based on iterative use of the classical Formal Concept Analysis algorithm to handle relational data: formal objects are described with formal attributes as in FCA, and with their relationships with other formal objects. Because RCA groups formal objects using relationships to formal objects at any distance, it often comes with a combinatorial explosion, and patterns of interest are dicult to extract from the huge set of built concepts.

Various strategies can be used to cope with this complexity, including separating the initial formal object sets into smallest ones after a rst analysis, or introducing queries [2]. Here we propose to adapt the RCA process in order to use only posets of concepts introducing objects or attributes (AOC-poset) rather than to build full concept lattices at each step of the process. Indeed AOC-posets are smaller and easier to compute than concept lattices [3] and their sets of concepts have interesting properties for extracting implication rules. The context of this research is the FRESQUEAU project 1 which aims at developing new methods for studying, comparing and exploiting all the parameters available concerning streams and water areas. The data we deal with have been collected during 3 years over 40 sites in the Alsace plain. Two other data sets are available on the Rhin-Meuse district (North-east of France, 3400 sites, 10 years) and on the Rhône-Méditerranée district (South-east of France, 18000 sites, 40 years). In a previous work, FCA has been used for classifying characteristics of aquatic species [4]. RCA is now used for discovering relationships between those species characteristics and the characteristics of their habitat.

To perform this analysis, we propose to adapt RCA relying on AOC-poset. We show that this approach provides a reasonable concept number in our case.

The paper is organized as follows. Section 2 gives some useful denitions for our presentation. Section 3 details the RCA process based on AOC-poset. Section 5 presents the data set and results that can be obtained with AOCposets. Related work is presented in section 6 and section 7 concludes the paper opening some perspectives of this work.

Formal Concept Analysis (FCA) [5] aims at extracting an ordered set of concepts from a dataset, called a Formal Context, composed of objects described by attributes. We will denote by K = (G, M, I) a formal context, where

Ani.

Ano.

Ant.

Aph.

Ase.

Ath.

describes animals by characteristics they may own. The considered animals here are macro-invertebrates that can be found in rivers. We took the examples of the following kinds of animals : Ancylus (Anc.), Anisus (Ani.), Anodonta (Ano.), Anthomyiidae (Ant.), Aphelocheirus (Aph.), Asellus (Ase.) and Athericidae (Ath.).

Given a K = (G, M, I) formal context, a formal concept is a C = (Extent(C), Intent(C)) pair where: For simplicity's sake, most lattice representations show attributes (resp. objects) solely where they are introduced. They are said to show the simplied intents and simplied extents which will be denoted respectively Intent S (C) and Extent S (C) for a given concept C.

Let C K be the set of all concepts of a K formal context. This set of concepts provided with the (C K , ≤ s ) specialization order has a lattice structure, and is called the concept lattice associated with K.

Left-hand side of Fig. 1 shows the concept lattice associated with the formal context of Table 1. In several FCA applications (e.g. in [3,6]; only the object concepts (which introduce at least one object) and the attribute concepts (which introduce at least one attribute) are used. In Fig. 1 (left-hand side), ca_5 and ca_8 are examples of object concepts; ca_1 and ca_2 are examples of attribute concepts; ca_9, ca_10 and ca_11 do not introduce any object or any attribute.

The so-called AOC-poset (for Attribute-Object-Concept poset) is the suborder of (C K , ≤ s ) restricted to object-concepts and attribute-concepts. It is also called Galois Sub-Hierarchy, a term we consider less explicit. Right-hand side of Fig. 1 shows the AOC-poset for the context of Table 1. One may have a large dierence of complexity between the two structures, because the concept lattice may have 2 min(|G|,|M|) concepts, while the number of concepts in the AOC-poset is bounded by |G| + |M|.

An example of a RCF is composed of an Animal context, denoted K Animals (Table 1), a Site context, denoted K Sites (Table at the left-hand side of Fig. 2), and a contains relation, denoted r contains (Table 2). Sites are determined by locations on a river where samples are done; two kinds of samples are here considered: physico-chemical samples that measure physical and chemical properties of the water (e.g. temperature or presence of a chemical compound) and biological samples that measure the level of life.

When objects of a category (e.g. Sites) are connected to objects of another category (e.g. Animals) via a relation (e.g. contains), concepts formed on top of objects of the latter category can be used to form concepts on top of objects of the former category. Let us for example consider the AOC-poset of the righthand side of Fig. 1 and the ca_8 concept which groups animals with a transversal distribution on banks (Att5), namely Ancylus (Anc.), Anisus (Ani.) and Asellus (Ase.). Now Site1, Site2 and Site3 can be grouped because they contain at least one animal with Att5, that is at least one animal in Extent(ca_8), e.g. Ancylus (Anc.) for Site 1 (Table 2). In RCA, this relationship between objects of a category and concepts formed on objects of another category is implemented thanks to scaling operators. This results in the creation of special attributes called relational attributes. For a given r relation in a given analysis, its associated scaling operator is denoted by ρ(r). Now, since we rely on AOC-posets, the existential scaling operator is dened slightly dierently from [7]. Nevertheless the reference [7] can be read to have more details on the RCA process which is simplied below for space reasons.

Denition 2 (Existential scaling operator). Let K = (G, M, I) be a context, and r a relation, where G is the domain of r, G ir is the range of r, and K ir = (G ir , M ir , I ir ) is another context. Let also C ir be a set of concepts2 built on K ir . The S ∃ existential scaling operator is applied to the context K, denoted by S ∃ (K, r, C ir ) = K + = (G + , M + , I + ), with:

Table 3 shows S ∃ (K Sites , contains, C Animals ) where C Animals is the set of concepts of the AOC-poset of right-hand side of Fig. 1. In this case I + contains (Site3, ∃ contains(ca_5)) and (Site3, ∃ contains(ca_7)) because Site3 contains one animal from the extent of these two concepts.

Then, for each K context of K, the apposition of K (denoted by symbol '|') with the respective results of the scaling upon each r j of R with G as domain (1 ≤ j ≤ k) and the chosen ρ(r j ), is used to build a new set of concepts (notations are taken from Def. 2). This apposition is the relational extension of the K context considering ρ and a set of concepts C which is a union of concept sets including C ir j , 1 ≤ j ≤ k:

By extension, E * ρ,C (K) denotes the relational extension of K, which is composed of all the relational extensions of all K i in K (and C is a union of concept sets associated with all ranges of all relations).

For example a relational extension of our K example is composed of Table 1 (no outgoing relation), and the left table of Fig. 2 apposed to Table 3. The AOC-poset built from this extended context is shown on gure 3. Now a whole construction process consists in building a (possibly innite) sequence of contexts and AOC-posets associated with (K, R) and ρ. The rst set of contexts (step 0) is K 0 = K. The contexts of step p are used to build the associated AOC-posets. The C p set composed of the sets of the concepts of AOC-posets at step p is used to calculate the relational extension. The set of contexts at step p+1 is dened using the relational extension:

Considering independently the contexts: for some i ∈ {1, . . . , |K|} the i-th context at the step p + 1 is the relational extension of the context of the same rank with the concepts from step p:

The dierence here with classical RCA is that we rely on K i and concepts of the AOC-posets of step p to build K p+1 i , rather than on K p i and lattices of step p. In our example, K 0 = (K Animals , K Sites ) and R = {contains} (see Table 2 In this simple example, the following steps do not produce any new concept (a x-point is reached). This process will be denoted by RCA-AOC in the following. 4 Extracting Implication Rules Implication rules are implications that are veried by the whole data set considered. Some implication rules can be extracted from the AOC-poset concepts by considering their simplied intent. An attribute a from the simplied intent of a concept C is an attribute that is not contained in the intent of any concept more general than C i.e. the set of all the objects sharing a is the extent of C. The objects from the extent also all share the attributes of the full intent of C, but they may not be the only ones. By consequence, for every object o in the data set the presence of a for a given object o implies the presence of all the attributes from the intent of C.

For instance in Fig. 1 we can consider the concept ca_7. Intent(ca_7) = {Att1 , Att0 , Att5 } and Intent S (ca_7) = {Att1 } which means that in all the dataset the rule Att1 → Att0 ∧ Att5 is veried.

All the concepts with no empty simplied intent can be found in the AOCposet meaning that all the rules having one element at the left hand side can be found with an AOC-poset.

Extracting rules from an existing AOC-poset is straightforward as it consists in reading the simplied intent and the full intent of each concept. The concept order permits to extract rules ordered by support, the rules extracted from the most general concepts having a larger support than more specic rules. The use of RCA permits to use relational attributes in implication rules.

A case study

We rely on a large database collecting data on Alsatian streams and water areas (North-east of France) [8], but more data are available through the current FRESQUEAU project, concerning larger areas and periods. The data are either issued from samples (e.g. physical, chemical and biological data collected on stream sites), synthetic data (e.g. biological indices, land cover) or general information issued from the literature (e.g. information about the aquatic species living in the streams). More precisely in this paper we work with three tables. The rst one gives values of 27 physico-chemical parameters (e.g. temperature, pH, SO4, NH4, organic matters) collected on 49 stream sites. The second table gives the level of population for 197 macro-invertebrates (e.g. Ancylus, Anisus, Anodonta ) collected on the same 49 sites. The third one describes the macroinvertebrates with 22 dierent life traits, i.e. their characteristics and functioning, e.g life cycle, reproduction mode, etc. each life trait being represented by several modalities (e.g. for the life trait life cycle there are two possible modalities : less than a year or more than a year ). The sum of the modalities for all life traits is 116. We look for rules combining life traits and physico-chemical parameters, e.g. the M modality of the T life trait is associated with a high value of the C physico-chemical parameter . We modeled our data within 4 formal contexts: stream sites, physico-chemical parameters, life traits and macro-invertebrates and we considered the three relations between them that are described by our tables: level of physico-chemical parameter, population of macro-invertebrates and life trait of macro-invertebrates. The relations being originally numerical ones we applied a preprocessing to separate values into a few classes. So the level of physico-chemical parameter relation has been split into 5 binary relations describing 5 dierent levels, the population of macro-invertebrates relation has also been split into 5 dierent binary relations and the life trait of macro-invertebrates relation has been split into 6 binary relations. This binarisation process has been accomplished under the guidance of a domain expert.

Applying RCA on this data led to a combinatorial explosion that forced us to try other methods of classication as our implementation could not sustain the number of concepts created reaching the limits of time and size. On this same data RCA-AOC gives a result in a few seconds, and can then be used on much bigger data sets. The implementation of RCA-AOC relies on the same algorithm as RCA except for the use of the Hermes algorithm [9] for building AOC-posets instead of an FCA algorithm.

From the obtained AOC-posets we extracted two sets of rules: the rules with a physico-chemical character on the left hand side and the rules with animal traits on the left hand side.

We obtained 49179 rules for the rst set and 56 for the second one. The difference is coming from the granularity of data which is dierent for the physicochemical characters and the biological characters. It comes directly from the choices of the binarization guided by domain experts in order to support the extraction of rules in one direction. Here the goal is to infer biological characters from physico-chemical characters, the former being more expensive to measure than the latter.

The rule presented below is one rule extracted from the experimental data with a support of 67% of the considered sites. For any site of the data set the presence of the component Lig at a concentration of level 1 implies the presence of animals at a concentration of level 2 that have the trait identied by the code FR4 (modality diapause or dormancy of trait resistance kind ) with an anity of 0 and the trait identied by the code SA1 (modality fresh water of the trait salinity ) with an anity of 3.

The levels that are referred here are dened specically to each physicochemical character, each animal species, and each biological character. For the physico-chemical characters they are usually attached to a level of concentration. The same goes for the animals presence. For the biological characters it refers to an anity of the species to the modality of a particular biological trait (e.g. for its habitat, an animal may have a stronger anity with sand than gravel, but may be found in both of them).

Although the modeling can be considered as naive and several approaches could be used to limit the number of concepts, we saw here that RCA has a scale issue as we are only working on a small part of the data. Using AOC-poset allows to handle big data without exploding the number of concepts. Besides, reducing the number of concepts means that the extracted information is also reduced. For the stream site concepts, from which we extract the rules, the AOC-poset keeps the interesting data as we still have the concepts where each attribute is introduced and their order. For the macro-invertebrates however, several concepts are lost that represent combinations of shared life traits. We still have to measure the impact of the missing concepts on the results but it would seem appropriate to combine the RCA-AOC approach with a more traditional lattice building approach that would compute the relevant concepts for the macro-invertebrates while keeping the number of stream site concepts low with AOC-poset. Other approaches to integrate relations in FCA have been proposed, including power context family [10], and Logical Concept Analysis [11]. The originality of RCA is to compute in iterative manner (with a possible stop at each step) several concept lattices from data represented in relational format. The concept lattices are connected by links that abstract the relations between objects. Several operators, borrowed to Description Logics, build the links between concepts.

The original RCA framework, using whole concept lattices, has been used to the analysis and modernization of UML elements [12,13], namely in class diagrams and in use case diagrams. In [14], concept lattices exploit relations between methods and between methods and attributes to detect and x design defects. Model transformations are learned from transformation examples thanks to several kinds of relations between model elements (e.g. between elements inside a model, transformation links between source elements and target elements) [15]. In [16], relations between abstract tasks in an abstract orchestration are used to classify relevant Web services to instantiate the tasks. Other applications can be found in ontology engineering [17,18,19]. In these applications, the datasets are medium-size guarantying the feasibility of the approach. In the FRESQUEAU project, we have larger sets of data where AOC-posets are more suitable than concept lattices. Furthermore, for some issues we want to deal with in the project, like extracting part of the implication rules, AOC-posets are relevant because they contain all the concepts that introduce attributes.

To our best knowledge, the AOC-posets have been introduced by Godin et al [3] in the domain of software engineering (object-oriented programming). The AOC-poset has also been used in applications of FCA to non-monotonic reasoning and domain theory [20] and to produce classications from linguistic data [21,22]. Specic parts of the AOC-poset (mainly the attribute-concepts part) are used in several works. They include approaches for rebuilding class hierarchy [23] and a recent study for extracting feature tree (in the domain of software product lines) from a set of products [24].

Many approaches exist to extract logical rules from data either in a supervised context for building decision tree [25] or classication rules [26] or in an unsupervised context for association rules learning. Our approach is unsupervised, but AOC-posets only allows the extraction of association rules of condence 1.

However, the scaling operation permits to consider dierent kinds of granularity for the relations between the concepts. The relational aspect of the approach permits the extraction of rules from complex relational data which would require to be transformed by propositionalization approaches [27] for many learning approaches. It also could be compared to Inductive Logic Programming [28] in some ways as it will result in rst order logic formulas. ILP being a supervised approach, its goal diers as it will try to nd the right premise for a given conclusion. The expressivity of the results of our approach are far more restricted than with ILP, even with all the scaling operators that can be imagined, leading to better performances but with a restricted output language.

This paper has introduced a RCA process based on AOC-poset in order to deal with computational complexity over big datasets. AOC-posets reduce the number of concepts, with no information lost as the context can still be retrieved from an AOC-poset. In the future we will work on specifying the convergence conditions of AOC-poset based RCA. Indeed, more complex datasets may include cycles between objects. Convergence is ensured with the RCA specication from [7] where the set of concepts used at each step is the set of concepts of the whole lattice. With AOC-poset the convergence is not guaranteed when there are cycles between objects. We also will develop a tool for vizualising the results and assisting their exploration. Finally the approach will be tested on the various datasets of the FRESQUEAU project, and compared with other approaches for relational data mining such as statistical approaches [29] or propositionalization [27].

Formal Concept Analysis (FCA) refers to a mathematized and formal humancentered way to analyze data. It can be described as an ontology-based Lattice Theory. This theory describes ways of visualizing patterns, generate implications, and representing generalizations and dependencies [1]. The theory makes use of a binary relation between objects and attributes, which plays a fundamental role in the understanding of human model conceptualization. FCA formalizes all these ideas, and gives a mathematical framework to work on them [2].

The Concept Lattice is mainly used to represent and describe hierarchies between data clusters (formal concepts or classes), which are inherent in the perceived information. A formal concept can be regarded also as a data cluster, in which certain attributes are all shared by a set of objects. The Concept Lattice is the main subject of the theory of FCA, and it was rst introduced in the early eighties by Rudolf Wille [2,3]. Over time, FCA has become a powerful theory for many interesting applications. Examples of these are in the data analysis of Frequent Closed Itemsets [4], association rules and Functional/Conditional hierarchies discovery [5,6,7]. For all these reasons, concept lattice generation is an important topic in FCA research [8,9,10,11,12,13,14,15]. However, the main drawback of concept lattices generation is the exponential size of the concept lattice and its generation complexity [16].

In this work, we present a Morphological Neural Network based method to generate the Concept Lattice. This batch method is capable of generating the Hasse diagram, and it is a bottom-up generation algorithm. With that in mind, this work is organized as follows. Section 2 is an elementary description of FCA Theory. Next, section 3 is a short introduction on how the Single Lattice Layer Perceptron (SLLP) works. In section 4, a description on how to compute the Maximal Rectangles is given. In this section, we also dene a link between SLLP and the design of a classier for maximal anti-chains search. Section 5 shows a comparison between PIRA and other known algorithms.

2 Basic Denitions

First, it is necessary to dene the concept of a formal context [3]. Denition 1. A binary formal context K is a triple (G, M, I). In this mathematical structure, G and M are two nite sets, called objects and attributes respectively, and I ⊆ G × M is a binary relation over G and M, named the incidence of K.

In order to dene formal concepts of the formal context (G,M,I), it is necessary to dene two derivation operators, named Galois connectors. Denition 2. For an arbitrary subsets A ⊆ G and B ⊆ M :

These two derivation operators satisfy the following three conditions over arbitrary subsets

Next, the denition of a formal concept idea, which represents the building unit of FCA. Denition 3. Let K be a formal context, K := (G, M, I). A formal concept C of K is dened as a pair C = (A, B), A ⊆ G and B ⊆ M , where the following conditions are satised, A = B and A = B, where A is named the extent and B is named the intent of the formal concept (A, B).

Next, we will show some useful notions from Lattice Theory [17,18] to understand the algebraic structure generated by those derivation operators and the formal concept idea. Denition 4. A Partially Ordered Set (Poset) is a set X in which there is a binary relation between elements of X, ≤, with the following properties:

1. ∀x, x ≤ x (Reexive). 2. if x ≤ y and y ≤ x, then x = y (Antisymmetric). 3. if x ≤ y and y ≤ z, then x ≤ z (Transitive).

Formal Concepts can be partially ordered by inclusion. And for any pair C i , C j have a unique greatest lower bound and a unique least upper bound. Then, the set of all formal concept in K, ordered by inclusion, is known as a Concept Lattice. Next denition links some denitions with the Formal Concept notion.

Given the set of Rectangles in K, a special kind of rectangles are dened as follows: Denition 6. (Maximal Rectangles). A rectangle (A 1 , B 1 ) is maximal if and only if there does not exist another valid rectangle

From here, we have the formal concept as a maximal rectangle. Theorem 1. (A, B) is a formal concept of K if and only if (A, B) is a maximal rectangle in K. Now, the following denitions are going to be useful for the proposed bottom-up approach of FCA generation. Denition 7. Let K := (G, M, I) and A ⊆ G. A is said to be an object derivative anti-chain set if and only if A 1 A 2 and A 2 A 1 for any two distinct

We will denote as D a derivative anti-chain and as A(K) the set of all antichains in K. All sets in which the super/subconcept order is not satised for any distinct elements of the set is called anti-chain set. Denition 8. D + is a maximal derivative anti-chain i there does not exist other D ∈ A(K) such that D ⊃ D + . There exists a maximal derivative antichain for objects and one for attributes.

Finally, we use a simple upward closed set denition. Denition 9. Upward closed set. Let (L, ≤) be a poset P . A set S ⊆ L is said to be upward closed if ∀x, y ∈ S with y ≥ x implies that y ∈ S.

Using these denitions of anti-chains, maximal rectangles and upward closed set, it is possible to device a bottom-up approach by means of dendritic neuronal networks.

3 Lattice-Based Neural Networks (LBNN).

Articial Neural Networks (ANN ) are models of learning and automatic processing inspired by the nervous system. The features of ANN make them quite suitable for applications where there is no prior pattern that can be identied, and there is only a basic set of input examples (previously classied or not). They are also highly robust to noise, failure of elements in the ANN, and,nally, they are parallelizable. As we said early, our work is related with LBNN, which is also considered an Articial Neural Network, and are inspired in recent advances in the neurobiology and biophysics of neural computation (author?) [19,20].

The theory of LBNN is actively used in classication [21,20,22], clustering [23], associative memories [24,25], fuzzy logic [26], among others [27,28]. Basically, in the LBNN model, an input layer receives external data, and subsequent layers perform the necessary functions to generate the desired outputs. Single Lattice Layer Perceptrons (SLLP), also named Dendritic Single Layer Perceptron, are basically a classier in which there exists a set of input neurons, a set of output neurons, and a set of dendrites growing from the output neurons. Those dendrites are connected with the input set by some axons from those input neurons. A training set congures those outputs based on the maxima and minima operations derived from the morphological algebra (R, +, , ). FCA and Mathematical Morphology common algebraic framework: Erosion, dilatation, morphological operators, valuations, an many other functions in concept lattices have been previously studied [29].

In SLLP, a set of n input neurons N 1 , . . . , N n accepts input x = (x 1 , ..., x n ) ∈ R n . An input neuron provides information through axonal terminals to the dendritic trees of output neurons. A set of O output neurons is represented by O 1 , ..., O m . The weight of an axonal terminal of neuron N i connected to the k th dendrite of the O j output neuron is denoted by w ijk , in which, the superscript ∈ {0, 1} represents an excitatory = 1 or a inhibitory = 0 input to the dendrite. The k th dendrite of O j will respond to the total value received from the N input neurons set, and it will accept or reject the given input. Dendrite computation is the most important operation in LBNN. The following equation τ j k (x), from SLLP, corresponds to the computation of the k th dendrite of the j st output neuron [21].

Where x is the input value of neurons N 1 , ..., N n and x i is the the value of the input neuron N i . I(k) ⊆ 1, ..., n represents the set of all input neurons with synaptic connection on the k th dendrite of O j . The number of terminal axonal bers on N i that synapse on a dendrite of O j is at most two, since (i) ⊆ {0, 1} . Finally, the last involved element is p jk ∈ {−1, 1} and it denotes the excitatory (p jk = 1) or inhibitory (p jk = =1) response of the k th dendrite of O j to the received input. All the values τ j k (x) are passed to the neuron cell body. The value computation of O j is a function that computes all its dendrites values. The total value received by O j is given by [21]:

In this SLLP model, K j is the set of all dendrites of O j , p j = ±1 represents the response of the cell body to the received input vector. At this point, we know that p j = 1 means that the input is accepted and p j = =1 means that the cell body rejects the received input vector. The last statement related with O j correspond to an activation function f , namely

As, we mention early, dendrites congurations is computed using a training set. For this, they use merge and elimination methods [17].

In PIRA-LBNN model for nding upward-closed set elements, a set of binary patterns are represented by G . Thus, the binary representation of a formal context is itself a set of patterns, in which the derivative of each object is an element x ∈ G . Then, we can dene each element x = (x 1 , ..., x n ) ∈ G as a binary vector. This allows us to dene a simple class classication rule to nd maximal rectangles, and in an equivalent way the maximal anti-chains.

In PIRA algorithm we search all the rectangles with maximum width or height from each formal concept founded. There are two ways to achieve our goal. It means that = 1 or = 0 depending on whether it is calculating, a supremum or an inmum, by using excitatory or inhibitory dendrites. Thus, p jk is also a constant, p jk = 1 or p jk = −1 and it denotes the excitatory or inhibitory response of the k th dendrite of M j to the received input, and another remarkable statement is the fact that we only need to connect zeros as axonal branches. The simplest way to compute the value of the k th dendrite derived from the SLLP equations, is:

This equation, where τ j k (x) is the value of the computation of the k th dendrite of the j th output neuron given a input x, I(k) ⊆ {1, ..., n} is the set of input neurons with terminal bers that synapse the k th dendrite of our output neuron. We realize that all weights w ijk are equal to zero, this is, for our upward closed set classier, we only need to store zero values from the input patterns in the training step. Our goal is that the output of our classication neuron be x ∈ C 1 . This is achieved by processing elements from higher to lower cardinality, Specically, each dendrite k corresponds with one maximal antichain intent to be tested, I(k) is the incidence set of positions where the value of the maximal rectangle is zero for the pattern represented by the k dendrite. We get the state value of M j computing the minimum value of all it's dendrites. Again, as the SLLP, each τ j k (x) is computed, and it is passed to the cell body of M j . Then we can get the total value received by our output neuron as follows:

We realize that the activation function is not required since f [τ j (x)] = τ j (x) where τ j (x) = 1 if x y for all y ∈ C 1 and τ j (x) = 0 if x ≤ y for some y ∈ C 1 . As we mentioned above x is a maximal rectangles if and only if x y and y x for all y ∈ C 1 . Using the previous statement we can ensure that half of the work is done, and the second test, y x, will be performed by processing data in a particular order. In our case, we use cardinality order ensuring that each new computed row is not a superset of the previously computed rows.

As we said before, the idea is to use our LBNN structure to classify maximal rectangles. When we start computing a formal concept, our structure is empty, this means there are not dendrites or axonal connections. So, the rst step is to add each element with the maximal cardinality as a pattern to learn. Algorithm 1 shows how an element is added to our LBNN for maximal rectangles learning. First, algorithm 1 receives as parameter the LBNN which is being trained and a binary vector. As we will see below, this binary vector has been proven as an antichain element. Algorithm 1, rst grows a new dendrite k th in our output neuron O j . Every column in x is checked, if that property is not contained by the object x, then an axonal branch grows from the i position of the input neuron set to the new dendrite. This operation is represented by addAxonalBranch calling. We can assure that we will not misclassify formal concepts in the processed context. The algorithm 2 shows how to compute the Concept Lattice by computing Maximal Antichain Sets recursively. Next, in a third step, if the maximal cardinality of the elements in G' is equal to the Supremum intent cardinality, it adds a link between Supremum and Inmum, and stops. Otherwise, it adds all the elements in G' with the maximal cardinality, to the dendritical neural network structure. Those elements are maximal rectangles in the given binary context. The fourth step is used to check the remaining elements. If an element derivative does not exist already, as an intent, and the evaluation 3 says that it is a maximal rectangle, then, it adds the object and its derivative as a new maximal rectangle. Otherwise, if the element derivative already exists, it is added to the previously formal concept as its extent. In the last step, it processes each maximal rectangle that has been found. If that element is already contained in the lattice, it adds a link between Inmum and the previous element created in the lattice. Otherwise, it adds that link and processes that formal concept recursively. Then, it adds this new element to the lattice structure.

At this point, it computes all the concepts given by the binary context, but B(K) cardinality is bounded by an exponential complexity. A simple way to avoid this issue is to use a Binary Tree to store and recover all elements inB(K). Basically, this binary tree works as a hash function using the concept of intent in their binary representation. Then, it searches, nds and adds any intent in |M | steps. In addition, the processing order enables us to generate the edges of the Hasse diagram without additional computing steps. Therefore, the process of generating the concept lattice and Hasse diagram presented in this paper has an expected polynomial delay time [16] for maximal anti-chains search.

As shown in [16], many parameters are involved in the performance and running time of an algorithm. For our tests, we considered the number of objects, the number of attributes, the density of the context and the worst case for contexts of M × M . Where density is the least percentaje of binary relations for each object in K. Those parameters were tested independently. Four algorithms were selected to compare the Dendritical algorithm performance. Implementations were performed in java.

Figure 1 shows the execution time behavior for a formal context with 10% density and 100 attributes. Here, the V-axis represent the running time of each algorithm in ms, and the H-axis the total number of objects under constant number of attributes. The test was performed by increasing the number of objects from one thousand to twenty thousand, with a random distribution and 10% of density.

We can verify that Bordat algorithm and our algorithm have the best performance when the number of objects increase with respect to the attributes. Figure 2 shows the increase in execution time when the number of attributes increases. All datasets for this test has a 10% density and 1000 objects, and the number of attributes is increasing from ten to one hundred, and, the number of formal concepts is growing too. Here we can notice that Bordat and Dendritical algorithms, are faster than Godin, Nourrine and Valtchev algorithms. We can also notice that Dendritical execution time behavior is faster when the number of objects grows.

Figure 3 shows the increase in execution time when the density percentage becomes higher. All datasets has 1000 objects and 100 attributes and when the density grows the number of formal concepts grows too. As we mention, density is mainly the percentage of attributes for all the objects in the formal context. Here, we notice that when the density grows Dendritical is closer and even faster than the other algorithms. Figure 4 shows running time for zero diagonal contexts where |G| = |M| and yields the complete lattice, which means 2 |M | formal concepts. In this kind of formal contexts, we can see a clear running time superiority of the dendritical algorithm. Finally, table 1 shows some examples of time complexity at each algorithm step.

In this paper, we presented an algorithm based on the main idea of maximal rectangles, using the cardinality notion and the dendritical classier. We have also compared it with some known algorithms for the construction of Concept Lattices.

From the tests presented in this paper, we can see that as the number of objects grows, our algorithm time execution is higher than Bordat or other methods, but it could be a better choice when the density or the number of attributes is high. Also, the results shows a good performance for the M × M contexts in the worst case scenario, which demonstrates the feasibility of our algorithm on some kinds of datsets.

Jan Konecny 1 and Manuel Ojeda-Aciego 2 1 University Palacky Olomouc, Czech Republic ‹ 2 Dept. Matemática Aplicada, Univ. Málaga, Spain ‹‹ Abstract. L-bonds represent relationships between formal contexts. We study properties of these intercontextual structures w.r.t. isotone conceptforming operators in fuzzy setting. We also focus on the direct product of two formal fuzzy contexts and show conditions under which a bond can be obtained as an intent of the product. In addition, we show that the previously studied properties of their antitone counterparts can be easily derived from the present results.

Formal Concept Analysis (FCA) has become a very active research topic, both theoretical and practical, for formally describing structural and hierarchical properties of data with "object-attribute" character. It is this wide applicability which justifies the need of a deeper knowledge of its underlying mechanisms: and one important way to obtain this extra knowledge turns out to be via generalization and abstraction.

A number of different approaches have presented towards a generalization of the framework and scope of FCA and, nowadays, one can find papers which extend the theory by using ideas from rough set theory [21,15,14], possibility theory [8], fuzzy set theory [1,2], the multi-adjoint framework [16,17,19] or heterogeneous approaches [6,18].

Goguen argued in [10] that concepts should be studied transversally, transcending the natural boundaries between sciences and humanities, and proposed category theory as a unifying language capable of merging different apparently disparate approaches. Krotzsch [13] suggested a categorical treatment of morphisms, understood as fundamental structuring blocks, in order to model, among other applications, data translation, communication, and distributed computing.

In this paper, we deal with an extremely general form of L-fuzzy Formal Concept Analysis, based on categorical constructs and L-fuzzy sets. Particularly, our approach originated in relation to a previous work [12] on the notion of Chu correspondences between formal contexts, which led to obtaining information about the structure of L-bonds in such a generalized framework. In this paper, we study properties of L-bonds w.r.t. isotone concept-forming operators in a fuzzy setting. We also focus on the direct product of two formal fuzzy contexts and show conditions under which a bond can be obtained as an extent of the product. In addition, we show that the previously studied properties of their antitone counterparts can be easily derived from the present results.

We use complete residuated lattices as basic structures of truth-degrees. A complete residuated lattice is a structure L " xL, ^, _, b, Ñ, 0, 1y such that Elements a of L are called truth degrees. Operations b (multiplication) and Ñ (residuum) play the role of (truth functions of) "fuzzy conjunction" and "fuzzy implication". Furthermore, we define the complement of a P L as

An L-set (or fuzzy set) A in a universe set X is a mapping assigning to each x P X some truth degree Apxq P L where L is a support of a complete residuated lattice. The set of all L-sets in a universe X is denoted L X , or L X if the structure of L is to be emphasized.

The operations with L-sets are defined componentwise. For instance, the intersection of L-sets A, B P L X is an L-set A X B in X such that pA X Bqpxq " Apxq^Bpxq for each x P X, etc. An L-set A P L X is also denoted t Apxq {x | x P Xu. If for all y P X distinct from x 1 , x 2 , . . . , x n we have Apyq " 0, we also write t Apx1q {x 1 , Apx2q {x 1 , . . . , Apxnq {x n u.

An L-set A P L X is called crisp if Apxq P t0, 1u for each x P X. Crisp Lsets can be identified with ordinary sets. For a crisp A, we also write x P A for Apxq " 1 and x R A for Apxq " 0. An L-set A P L X is called empty (denoted by H) if Apxq " 0 for each x P X. For a P L and A P L X , the L-sets a b A P L X , a Ñ A ,A Ñ a, and A in X are defined by

Apxq " Apxq Ñ 0.

(

An L-set A P L X is called an a-complement if A " a Ñ B for some B P L X . Binary L-relations (binary fuzzy relations) between X and Y can be thought of as L-sets in the universe X ˆY . That is, a binary L-relation I P L XˆY between a set X and a set Y is a mapping assigning to each x P X and each y P Y a truth degree Ipx, yq P L (a degree to which x and y are related by I).

The composition operators are defined by

An L-context is a triplet xX, Y, Iy where X and Y are (ordinary) sets and I P L XˆY is an L-relation between X and Y . Elements of X are called objects, elements of Y are called attributes, I is called an incidence relation. Ipx, yq " a is read: "The object x has the attribute y to degree a."

Consider the following pairs of operators induced by an L-context xX, Y, Iy. First, the pair xÒ, Óy of operators Ò : L X Ñ L Y and Ó : L Y Ñ L X is defined by

Second, the pair xX, Yy of operators X :

Third, the pair x ^, _ y of operators ^:

for C P L X , D P L Y .

To emphasize that the operators are induced by I, we also denote the operators by xÒ I , Ó I y, xX I , Y I y, and x^I , _ I y. Furthermore, denote the corresponding sets of fixpoints by BpX Ò , Y Ó , Iq, BpX X , Y Y , Iq, and BpX ^, Y _ , Iq, i.e.

The sets of fixpoints are complete lattices, called L-concept lattices associated to I, and their elements are called formal concepts.

for every a P L and C P V we have a b C P V ; -V is closed under union, i.e. for C j P V (j P J) we have

for every a P L and C P V we have a Ñ C P V (here, a Ñ C is defined by pa Ñ Cqpiq " a Ñ Cpiq for i " 1, . . . , n); -V is closed under intersection, i.e. for C j P V (j P J) we have Ş jPJ C j P V .

This section introduces some new notions studied in this work. To begin with, we introduce the notion of weak L-bonds as a convenient generalization of bond.

This notion can be put in relation with that of i-morphism.

-hpa b Cq " a b hpCq for each a P L and C P V ; -hp Ž kPK C k q " Ž kPK hpC k q for every collection of C k P V (k P K). An i-morphism h : V Ñ W is said to be an extendable i-morphism if h can be extended to an i-morphism of L X to L Y , i.e. if there exists an i-morphism h 1 : L X Ñ L Y such that for every C P V we have h 1 pCq " hpCq;

The following results will be used hereafter.

).

Proof. We show procedures to obtain the i-morphism from a weak L-bond and vice versa.

"ñ": Let β be a weak L-bond between

q; thus by Lemma 1(3) there exists (1). Then β " I 1 ˝Si is a weak L-bond by Lemma 1(3) and Lemma 1(4).

One can check that these two procedures are mutually inverse.

x ^y if x " 1 or y " 1, 0 otherwise, for each x, y P L. One can easily see that x b Ž j y j " Ž j px b y j q and thus an adjoint operation Ñ exists such that xL, ^, _, b, Ñ, 0, 1y is a complete residuated lattice. Namely, Ñ is given as follows:

One can check that, we have Extptxu X , tyu Y , I 1 q " Extptxu X , tyu Y , I 2 q " tt b {xu, xu and, trivially, Intptxu X , tyu Y , I 2 q " Intptxu X , tyu Y , I 2 q. Thus I 2 is a weak L-bond between I 1 and I 2 w.r.t. xX, Yy.

On the other hand, I 2 is not a weak L-bond between I 1 and I 2 w.r.t. x^, _y since Extptxu ^, tyu _ , I 1 q " tH, t a {xuu Ğ tH, t b {xuu " Extptxu ^, tyu _ , I 2 q.

Theorem 2. The system of all weak L-bonds is an L-interior system. Proof. From properties of i-morphism.

[ \

We provide a stronger version of the previously studied weak L-bond, naturally named strong L-bond. The following lemma introduces equivalent definitions of strong L-bonds.

Lemma 2. The following propositions are equivalent:

2 , Y Y 2 , I 2 q. (c) β " S e ˝I2 " I 1 ˝Si for some S e P L X1ˆX2 and S i P L Y1ˆY2 .

Proof. (a) ô (b): By use of the Lemma 1(3) and ( 4).

(a) ô (c): By definitions.

[ \ In this case, this stronger notion can be related with the c-morphisms, introduced below:

For formally establishing the relationship, the two following results are recalled:

C ^A q is an extendable c-morphism.

Proof. We show procedures to obtain the c-morphism from a strong L-bond and vice versa. "ñ": Let β be a strong L-bond between K 1 " xX 1 , Y 1 , I 1 y and K 2 " xX 2 , Y 2 , I 2 y. By Lemma 2 there is S e P L X1ˆX2 such that β "

2 , Y Y 2 , I 2 q by Lemma 3 (1). Then β " S e ˝I2 is a strong L-bond by Lemma 2.

One can check that these two procedures are mutually inverse.

[ \ Theorem 4. The system of all strong L-bonds is an L-interior system.

Proof. Using Lemma 2 (b), it is an intersection of the L-interior systems from Theorem 2.

[ \

, ∆y with ∆pxx 2 , y 1 y, xx 1 , y 2 yq " I 1 px 1 , y 1 q b I 2 px 2 , y 2 q.

Theorem 5. The intents of K 1 ' K 2 are L-bonds between K 1 and K 2 .

Proof. We have

Now, notice that pI 1 ˝φT q ˝I2 " I 1 ˝pφ T ˝I2 q " β is a strong L-bond by Lemma 2.

[ \ Remark 1. It is worth mentioning that not every strong L-bond is included in IntppX 1 ˆY2 q X , pX 2 ˆY1 q Y , ∆q since there are isotone L-bonds which are not of the form of I 1 ˝φT ˝I2 . For instance, using the same structure of truth degrees and I 1 as in Example 1, obviously I 1 is L-bond on K 1 (i.e. between K 1 and K 1 ), but IntppX 1 ˆY2 q X , pX 2 ˆY1 q Y , ∆q contains only H.

The end of proof of the Theorem 5 also explains which L-bonds are intents of K 1 ' K 2 :

Corollary 1. The intents of K 1 ' K 2 are exactly those L-bonds between K 1 and K 2 which can be decomposed as I 1 ˝φT ˝I2 for some φ P L X2ˆY1 .

Remark 2 (Relationship to the antitone case in [12]).

Assuming the double negation law, we have the equality ExtpX Ò , Y Ó , Iq " ExtpX X , Y Y , Iq. Thus, for a strong L-bond β P L X1ˆY2 " S e ˝I2 " I 1 ˝Si between K 1 and K 2 we have β " S e Ž I 2 " I 1 Ż S i being an antitone L-bond between K 1 and K 2 .

Remark 3. Some papers [9,12] have considered direct products in the crisp and the fuzzy settings, respectively, for the antitone case. In [12] conditions are specified under which antitone L-bonds are present in the concept lattice of the direct product. Corollary 1 and Remark 2 provide a simplification of these conditions. The concept lattice of a direct product K 1 b K 2 defined as in [12] i.e. K 1 b K 2 " xX 2 ˆY1 , X 1 ˆY2 , ∆y with ∆pxx 2 , y 1 y, xx 1 , y 2 yq " I 1 px 1 , y 1 q Ñ I 2 px 2 , y 2 q p" I 2 px 2 , y 2 q Ñ I 1 px 1 , y 1 qq induces concept-forming operator φ Ò ∆ for which we have

Whence an antitone L-bond is an intent of the concept lattice of K 1 b K 2 iff it is possible to write it as p I 1 ˝φT ˝ I 2 q i.e. if its complement is an intent of

We studied L-bonds with respect to isotone concept-forming operators, computation of L-bonds using dirrect products, and the relationship of these results to the previous results on antitone L-bonds.

The present results can be easily generalized to a setting in which extents, intents and the context relation use different structures of truth-degrees. We will bring this generalization in an extended version of the paper.

Our future research in this area includes the the study of yet another type of (extendable) i-morphisms and c-morphisms. In [11], another type of morphism is described: the a-morphism. In contrast to the morphisms used in this paper, the a-morphisms are antitone, and their study could shed more light on antitone fuzzy bonds.

The Chilean National Council of Culture and Arts1 (CNCA) has undergone the mission of documenting the intangible cultural heritage (ICH) of different small zones of the country in the context of a world-wide UNESCO2 crusade to incentivize governments and NGOs to properly maintain our cultural knowledge. The ICH, as drafted in the Convention for the Safeguarding of the Intangible Cultural Heritage3 refers to "traditions or living expressions inherited from our ancestors and passed on to our descendants, such as oral traditions, performing arts, social practices, rituals, festive events, knowledge and practices concerning nature and the universe or the knowledge and skills to produce traditional crafts".

To survey the ICH, the CNCA maintains several "documenters" who meet artists, artisans and other actors of the folkloric stage. Each documenter fills a "file" containing several semi-structured and text-free fields which are later registered in a relational database (DB). This database is later consulted by curators (usually domain experts) who fix problems in data definitions or storage. The CNCA has requested help in two specific aspects. Given the difficulty of documenting very different domains in ICH, the design of a data schema to support its documentation is a hard task which leads to inconsistencies in its model. Currently, the data schema used by the CNCA was designed by a computer engineer with some knowledge on the domain. However, as the ICH documentation process expanded to other cultural domains ("music", "folk festivals", "crafts", etc.) the data schema became too general and some modifications were requested to enable a higher level of details. The CNCA requested to analyse the data schema in order to find "modular" partitions on the model corresponding to different domains in ICH. Thus, each module can be maintained by a related domain-expert avoiding the risk of information conflict.

The second request derives from the fact that, since the ICH documentation is a multi-organizational endeavour motivated by UNESCO, it is expected that data collected by CNCA will be integrated with other databases later on. Because of this, CNCA has asked aid to obtain an ontological schema from its current data schema which can be used for linked data publication.

In this work we propose a novel knowledge discovery in databases process guided by formal concept analysis (also, referred to as conceptual knowledge discovery in databases CKDD [1]) approach to deal with both requirements. We analyse the current data schema definition to construct a concept lattice through FCA in which we apply different techniques to find the modules representing ICH domains. The contributions of this work are firstly, to present a real-world experience using FCA and concept lattices to achieve a task as important as heritage documentation and secondly, the description of a process to elicit an ontological schema from a relational DB schema which can be of benefit in different applications.

The remainder of this article is organised as follows: Section 2 presents the CKDD process while Sections 3, 4 and 5 detail each of its steps. Section 6 describes the case study of applying the CKDD process over the CNCA database for ICH documentation. Finally, Section 7 presents a discussion on related work and concludes the paper.

2 Formal concept analysis and knowledge discovery in databases.

We propose an iterative and human-centred approach to overcome both requirements of the CNCA based on Conceptual Knowledge Discovery in Databases (CKDD) [1]. CKDD is a tool to support humans in the discovery and extraction of knowledge from large collections of data where the conceptual representation of knowledge is a key aspect [12]. Fig. 1: FCA-based KDD process for CNCA Figure 1 presents a 3-step CKDD process designed to take a database schema and convert it into a knowledge base. The process contains a loop between the interpretation and the FCA step in which domain expert knowledge is included. Notice that to avoid conflicts with the CNCA data, we only extract information from the database and never modify it. In the following sections we provide a detailed description of each step and sub-tasks developed.

The first step starts by extracting the database schema and ends when it is converted to a formal context. Currently, most of the relational database management systems are based on the relational model constituted by tables and their relations (there are actually more elements in a relational model which are not of first interest here). We provide an adapted definition of the relational schema model as described in [2].

A relational schema S = {R 1 , R 2 , ..., R |S| } is defined as a set of tables or "relation schemas" R i (A 1 , A 2 , ..., A ni ) consisting of a table name R i and a list of n i fields A j which define value assignments of the domain dom(A j ) to an entry in the table. The notation R i .A j stands for the field A j in table R i . An entry in a table is defined as an ordered n-tuple of values denoted by t

where each value is denoted as t[A j ] = v j ∈ dom(A j ) ∪ {N U LL}. N U LL indicates that the value is unknown for the field in the entry. The relation state r(R i ) = {t 1 , t 2 , ..., t ri } of table R i denotes its total set of entries. In a table R i , the set of fields SK ⊂ R i denotes a superkey which identifies a tuple as unique. A primary key P K is defined as a superkey where |SK| = 1 and |.| denotes set cardinality, i.e. P K is a single field and we say that R i .P K is the primary key of table R i the value of which unequivocally identifies an entry in table R i . Finally, a field R 1 .F K is called a foreign key iff R 1 .F K = R 2 .P K which indicates a relation between R 1 and R 2 . In the particular case of the CNCA database for ICH documentation, a notion of inheritance of tables is supported. We define this as

Considering data schema S = {R 1 , R 2 , ..., R |S| } and the tables of the form R i (A 1 , A 2 , ..., A ni ) composed by the fields A j , we define the formal context K = (S, A, I) where

Formal context K is composed by tables in the set S (all the tables or a sub-set of them), the set of fields A (composed by the set of all fields from all tables considered in S) and the relation set I (the relations between tables in S and their fields in A). Notice that we define a formal context by making the correspondences object-table and attribute-field. To avoid confusions, in this work we differentiate between these correspondences by using different font faces for objects or attributes and for tables or fields. Along with the formal context, we also define the following rules of attribute integration based on the characteristics of the fields:

-The special attribute id represents all primary keys: id ∈ A , (R i , id) ∈ I ∀R i ∈ S. -Fields with the same name are integrated into a single attribute (e.g. attribute name represents Agent.name and Ritual .name)

In the context of FCA, foreign keys correspond to relational attributes. For example, in Figure 2 we do not say "table Ritual contains a foreign key" (as in the case of Ritual contains a primary key), but rather "Ritual is related to Agent by a foreign key". Such kind of attributes cannot be included in a binary formal context. To deal with relational attributes, we scale them and treat them as normal attributes in the lines of [11]. We do so by prepending the prefix related to: to the name of the table where the foreign key directs to (e.g. in the formal context in Table 1, we say that the object Ritual contains the attribute related to:Agent). This is formalized as This step receives a formal context and ends when a concept lattice is constructed. Figure 3(a) shows the concept lattice calculated for the formal context in Table 1. Along with the concept lattice, the original formal context is sent to step 3 to allow modifications in it for further iterations of the process. We develop two tasks related to the identification of elements which would help in the redesign of the data schema.

The attribute concept of attribute A j is defined by µA j = (A j , A j ), where () is the derivation operator in FCA [3]. The identification of attribute concepts is rather simple and we do it by navigating from the top to the bottom of the lattice. Attribute concepts are the most general concepts in the lattice containing a given attribute. In our case, the attribute concept of a given field contains the largest set of tables related to it. This is important since, as we will describe in the next step of interpretation, we process each field separately in order to create the ontological schema. Attribute concepts make this simpler as for each field we only need one concept and not the whole lattice.

Since we are looking to enhance the design of a data schema in the database, within the lattice we would like to have only those concepts which group together in their extents tables of the same domain. This would allow us to address the modularization of information per domain issue which is one of the request of the CNCA, assuming that tables in the same domain are likely to share similar fields.

In order to do so, we use the notion of extensional stability as firstly described in [6] and later in [10] as a way to measure "the probability of a concept to preserve its extent after leaving out an arbitrary number of attributes".

The final step receives a formal context and its associated concept lattice where each attribute concept is identified and each formal concept contains an extensional stability value. Since CKDD is an iterative process, this step has two possible outputs. If the expert decides to make another iteration, the process goes back to step 2 sending a modified version of the formal context received including feedback of the expert. If the expert decides to end the process, this will create an "ontological schema" which will be stored in a knowledge base and the process ends. For the iteration, there are two tasks to perform: Question creation/answering and Modularization. The task which transforms the concept lattice into an ontological schema ends the process. A further step of annotation which converts the entries in tables into linked data using the ontological schema can be considered, but for the sake of space we have left it out of this paper.

We use extensional stability as an indicator of how related are tables within a given concept extent. A lower stability indicates that those tables are grouped more as an accident (for example, because of the misuse of a single (or several) field name(s)) rather than because they belong to the same domain. We look for unstable attribute concepts because they are the most general concepts containing a given attribute, so they are those that relate more tables together. Moreover, we can create questions for the expert to answer in the hope they provide information to "break" the attribute concept and separate domains.

Consider the example in Figure 3(a) in which two domains are illustrated. The first relates events while the second relates people and communities. The most unstable attribute concepts (extensional stability of 0.5) correspond to those labelled with the attributes background and place. In the case of place, it only contains one table meaning that "breaking" this concept does not help in separating domains 4 . The attribute concept of background contains four objects, namely FestiveEvent, Agent, IndividualAgent and CollectiveAgent for which FestiveEvent belongs to a different domain than the others.

Regarding the questions posed to the expert, we have:

1. Would you like to assign attribute to all the objects? 2. Would you like to eliminate the attribute from a single/a set of objects/s? 3. Would you like to split attribute into different attributes for different objects?

If the expert selects option 1, the attribute will be shared by every object and hence, it will be placed as part of the intent of the top of the lattice (like id and name in Figure 3(a)). In the case of option 2, the attribute is erased from the formal context and hence, its attribute concept is removed. With option 3, we can recommend the partition of the attribute by looking at the sub-concepts of the attribute concept. Then, a new attribute is created for each partition made while the original attribute disappears. Consider A i to be the attribute for which the expert has to answer a question. For each option we can define a new formal context as follows:

1. Option 1:

3. Option 3: Let A j be the splits of attribute A i assigned to objects R j , then

In the example, the expert selected option 3 splitting background into an attribute for FestiveEvent (practice background) and another for the Agents (records). This example is actually an extract of a real case study where the expert realized that the term "background" was used with multiple meanings and that it should be separated into an attribute registering the history of past events and another for the official records of people. Figure 3(b) presents the concept lattice created from the formal context yielded by this decision.

The expert may choose to perform this task disregarding answering questions. We start from the already processed concept lattice L and find its sublattices such as L i ∩ L j = { , ⊥} where L i , L j are sublattices of L and , ⊥ represent the top and the bottom of L respectively. We achieve this by obtaining the connected graphs from the lattice once and ⊥ are removed. Each sublattice is a candidate to represent a domain which must be labelled by the expert. The label is included into the formal context as a special attribute of the form domain:Label with relations to all the objects in the sublattice. The concept lattice is later recalculated. Figure 3(b) depicts the final form of the lattice for the running example. Finally, the expert may also be interested in merging more than one sublattice into a single domain. In that case, the special attribute is added to all objects in the set of sublattices selected by the expert.

The final task of the process derives an ontological model from the concept lattice that can be used for data integration and linked data publication. This is done Table 2: Formal concept translation into RDF triples. Triples in the third column are created for the elements described in the second column within the formal concepts in the first column by creating a set of RDF triples5 for given elements in the formal concepts of the lattice. Table 2 shows this conversion where for example, in the first row it is shown that for the top concept, all the tables in its extent are modelled as RDFS classes6 [7]. For simplicity purposes, Table 2 only presents a part of the total set of triples created considering the top , the bottom ⊥ and attribute µA j concepts.

The database schema of the CNCA for ICH documentation consists of nearly 300 tables, however only 27 tables were selected by the experts on the basis of their representative and multi-disciplinary knowledge. Selected tables consider descriptions of agents, collective agents, festive events, culinary manifestations, geolocations and more. The formal context derived from the database contains 27 objects, 56 attributes, and 25 relational attributes. Figure 4 depicts the concept lattice built from this formal context. Table 3: Iterations made for the case study Table 3 shows the actions taken by the domain expert during 9 iterations of the CKDD process. We distinguished between facts, questions and actions. Facts represent database assertions which are displayed for helping the expert in decision taking. For example, in iteration 1 the expert is presented with the facts: "71% of the objects contain the attribute name" and "The attribute name has a value in 100% of the entries in the objects where it appears". The first fact helps the expert to understand that name is actually very common among the objects and can easily be extended to the whole object set. The second fact combines information from the DB and the concept lattice to tell the expert that in all the entries t which contain the field name (represented by the attribute name), the value t[name] is different than N U LL. This indicates him that the attribute should not be removed from any object. Questions and actions were already detailed in Section 5.1.

In iterations 3 and 4 the expert split the attribute background ("antecedentes" in Spanish). This attribute appears in several objects (46% of object set) through all the domains, however with different semantics. Finally, the expert created the attributes historical background, records, practice background and culinary background. In iteration 5 and 6, the expert decided to eliminate some attributes from the object set. For example, the relation related to:Commune which represented a foreign key in the database, was not being used in 3 tables from which it was removed. Finally, in iterations 7, 8 and 9 the expert labelled the modules as subdomains of ICH FestiveFeatures, Geo and AgentFeatures. Modelling semantic relations in DBs is proposed in [8] where the author presents a framework to formalize semantics in a lexical database. A lexical database maintains information about concepts and their semantic position w.r.t. each other (hypernymy or meronymy). In general, relational DBs do not share the same characteristics nor structure as lexical databases, allowing to store more heterogeneous data. In [9] the same author proposes an algebra for relational DBs which can be interpreted also in terms of a formal context in FCA. A similar idea was proposed by [5] where the author uses the algebra to translate a relational database into a family of formal contexts to benefit from both, the simplicity of the relational model description and the power of FCA in analysis. By contrast, our approach is more straightforward since we are not interested in data operations using the concept lattice, but rather in a direct translation of the data schema. Thus, we do not work with the entries in the tables of the database. In our approach we use the concept lattice as a support for guiding the redesign process in which a domain expert is the main provider of knowledge.

To conclude, in this article we have presented an application of a conceptual knowledge discovery in databases process designed to redesign and convert a database schema into an ontological model. The process is heavily human centred as it considers a domain expert as the main source of knowledge to guide the process. To support him, we use formal concept analysis with a formal context created from the set of tables and fields extracted from the database schema. The concept lattice calculated from this formal context is used to analyse the schema and create questions which the user should answer. Each question has an associated set of actions aimed at redesigning the database schema model.

The application is implemented over an excerpt of the Chilean National Council of Culture and Arts (CNCA) database for intangible cultural heritage documentation. Currently, we are implementing the process in full scale including more domain experts. Future work include the annotation process of data using the ontological schema created which has already been considered, however not described in this article. As pointed out by one of the reviewers of this work, the approach presented in this article may also be applied in the context of software engineering, specifically in code re-factoring and object-model re-engineering [4].

Analogical reasoning [1] plays an important role in human reasoning. It enables us to draw plausible conclusions by exploiting parallels between situations, and as such has been studied in AI for a long time, e.g., [2,3] under various approaches [4]. A key pattern which is associated with the idea of analogical reasoning is the notion of analogical proportions, i. e. statements of the form 'A is to B as C is to D'. However, it is only in the last decade that researchers working in computational linguistics have started to study these proportions in a formal way [5][6][7]. More recently, analogical proportions have been shown as being of particular interest for classification tasks [8] or for solving IQ tests [9]. Moreover, in the last five years, there has been a number of works, e.g., [10,11] studying the propositional logic modeling of analogical proportions. The logical view of an analogical proportion amounts to expressing that the difference between A and B (resp. B and A) is the same as the difference between C and D (resp. D and C). Although it can be proved that, beside symmetry, this view agrees with a crucial postulate of analogical proportions, namely that one can exchange B and C in the proportion (as well as A and D), it is not straightforward to see that it holds. In fact, a genuine parallel can be made between analogical proportions and numerical proportions. It suggests that since factorization plays a key role in geometric proportions (which equal two ratios of integers), factorization also makes sense for analogical proportions. This idea is investigated here in the abstract setting of lattices.

In order to do this, we go back to a factorization-based formalization of analogical proportions proposed in [12,13]. On this basis, these authors proposed a definition of analogical proportions in different settings such as sets, sets of sequences, set of trees, and lattices. As shown in this paper their definition suggested for the lattice setting is incomplete. We then correct and complete this definition. We show that it encompasses the Boolean lattice case that corresponds to the propositional logic encoding of analogical proportions. We then study the more general setting of distributive lattices, identify canonical proportions, and show how analogical proportions can be decomposed into canonical ones, before discussing the solving of analogical proportion equations, a key issue for application to algorithms for analogical reasoning. We also illustrate the approach in the case of a distributive lattice induced by fuzzy sets.

The paper is organized as follows. The next section provides the necessary background on lattices and on analogical proportions. Section 3 establishes the basic form of analogical proportions in distributive lattices, which is illustrated on Boolean and on graded proportions, and then investigates their basic properties. Section 4 introduces the notion of canonical proportions and takes advantage of them for studying the composition and the decomposition of analogical proportions. Section 5 discusses the resolution of analogical equations, and briefly studies the transitivity of analogical proportions.

This paper is a preliminary investigation into the connexions between lattices and analogical proportion. In particular, we are interested in detecting analogical proportions in concept lattices (e.g. see [20]). However, since these lattices are generally non distributive, we will have to investigate which of the properties demonstrated here still hold true in concept lattices, and which of them have to be abandoned or weakened. A few hints are given in Sections 3 and 5.

Lattices. They are mathematical structures commonly encountered in the semantics of representation and programming languages, in formal concept analysis, machine learning, data mining, and in other areas of computer sciences.

(L, ∨, ∧, ≤) is a lattice when [14]: i) L has at least two elements, ii) ∧ and ∨ are two binary internal operations, both idempotent, commutative, associative, and satisfying the absorption laws. A lattice is distributive when u

for all u, v and w in L. A bounded lattice has a greatest (or maximum) and least (or minimum) element, denoted and ⊥. A bounded lattice is complemented if each element x has a complementary y such that x ∧ y = ⊥ and x ∨ y = . A distributive, bounded and complemented lattice is called a Boolean lattice.

Duality theorem. If a theorem T is true in a lattice, then the dual of T is also true. This dual is obtained by replacing all occurrences of ∧ (resp. ∨, ≤) by ∨ (resp. ∧, ≥).

Examples. Analogical proportions. They are characterized by three axioms. They acknowledge the symmetrical role played by the pairs (A, B) and (C, D) in the proportion 'A is to B as C is to D', and enforce the idea that B and C can be interchanged if the proportion is valid, just as in the equality of two numerical ratios where means can be exchanged. This view dates back to Aristotle [15]. A third, optional, axiom insists on the unicity of the solution x = B for completing the analogical proportion A : B :: A : x . These axioms are studied in [16]. Example. Let us take the lattice (2 Σ , ∪, ∩, ⊆), where Σ is a finite set {a, . . . , n}. Σ may be for example a set of Boolean properties, and a subset of Σ can be used to characterize some object described by the corresponding properties. The four objects described by the subsets x = {a, b, e}, y = {b, c, e}, z = {a, d, e} and t = {c, d, e} are in analogical proportion in this order. Indeed, it suggests an intuitive meaning for 'is to': To transform x into y, one has to remove property a and to include property c; namely x \ y = {a} and y \ x = {c}. z is transformed into t by exactly the same operations; namely z \ t = {a} and t \ z = {c}. Such a view of the relation linking x, y, z, t is clearly symmetrical, and satisfies the exchange of the means: namely x \ z = {b}, z \ x = {d} and y \ t = {b}, t \ y = {d}. This idea that x (resp. y) differs from y (resp. x) in the same way as z (resp. t) differs from t (resp. z) is at the core of the definition of the analogical proportion x : y :: z : t in the Boolean setting [10], as further discussed in the following.

Proportions in commutative semigroups. Stroppa and Yvon [12,13] have given another definition of the analogical proportion, based on the notion of factorization, when the set of objects is a commutative semigroup (X, ⊕).

Definition 2 A 4-tuple (x, y, z, t) in a commutative semigroup (X, ⊕) is an AP x : y :: z : t when:

1) either (y, z) ∈ {(x, t), (t, x)}, 2) or there exists

This definition satisfies the two basic axioms of the analogical proportion (Definition 1). For example, in (X, ⊕) = (N + , ×), with x 1 = 2, x 2 = 3, t 1 = 5 and t 2 = 7, one has (2×3) : (2×7) :: (5×3) :: (5×7), i.e. 6 : 14 :: 15 : 35, a numerical geometric analogical proportion. Note that this particular proportion corresponds equivalently to the equality: 6 × 35 = 14 × 15.

In this section, we are interested in studying how the definition of an analogical proportion by factorization applies to lattices. In particular we are wondering whether the equivalence of the two formulations in the preceding example can be transposed to this algebraic structure.

Considering that a lattice (L, ∨, ∧) is both a commutative semigroup (L, ∨) and (L, ∧), we define an analogical proportion as follows.

Definition 3 A 4-tuple (x, y, z, t) in (L, ∨, ∧) is an AP (x : y :: z : t) when:

1) there exists

2) and there exists (

Note that when x 2 = t 2 then y = x and z = t and that when x 1 = t 1 then y = t and z = x. Hence we can have (y, z) = (x, t) or (y, z) = (t, x).

Examples. (a) In (N + , gcd, lcm, |), we have (20 : 4 :: 60 : 12), with x 1 = 20, x 2 = t 1 = 60, t 2 = 12, x 1 = t 2 = 4, x 2 = 20 and t 1 = 12. (b) In the lattice S of closed intervals on R, we have ([0, 3] : {3} :: [0, 4] : [3,4]) with

Proposition 1 A 4-tuple (x, y, z, t) in (L, ∨, ∧) is an AP (x : y :: z : t) iff: The antisymmetry of ≤ implies that x = (x ∧ y) ∨ (x ∧ z). We show the other equalities in the same manner.

The above definition applies to general lattices. In this paper, we focus on distributive lattices, since most of the properties to come require this property.

Every finite Boolean lattice is isomorphic to the lattice (X, ∪, ∩, ⊆), where X is a finite set. When considering this lattice, the quantities involved in Definition 1 can be described more precisely (see [16,17]), as explained below. The link with Definition 3 is made by taking4 .: x 1 = c∪e, x 2 = a∪e, t 1 = d∪e and t 2 = b ∪ e, and by duality:

It is also easy to check that this definition is equivalent to Definition 3.

b c e a d f It is worth noticing that the above result has a nice interpretation in practice. Let us view x, y, z, t as subsets of properties that hold true in four different situations. It is then clear that a is the subset of properties that are true in the first situation, but false in the second one, and again true in the third situation and false in the fourth one. Conversely, b is the subset of properties that are false in the first situation, true in the second one, and again false in the third situation and true in the fourth one. Besides, c (resp. d) is the set of properties that are true for both the first and the second situations and false for the third and the fourth ones (resp. false for the first and the second situations and true for the third and the fourth ones. In other words, the disjoint subsets a, b, c, d, e, f have the following interpretations a = x \ y = z \ t, b = y \ x = t \ z, c ∪ e = x ∩ y, d ∪ e = z ∩ t, where e = x ∩ y ∩ z ∩ t is the set of properties that are true in all situations (and f the set of properties that are false in all situations); see Figure 1. Thus, one can say that x, y, z, and t are respectively factorized under the form of pairs of disjoint subsets, namely (a, c ∪ e) for x, (b, c ∪ e) for y, (a, d ∪ e) for z, and (b, d ∪ e) for x, which perfectly parallels the equality of two numerical ratios of the form α×γ β×γ = α×δ β×δ . Moreover, the above decomposition using the partition of the referential into six subsets exactly corresponds to the truth table of the analogical proportion in a propositional setting [10,18] defined equivalently by

x : y :: z : t = (x ∧ ¬y) ≡ (z ∧ ¬t) ∧ (y ∧ ¬x) ≡ (t ∧ ¬z) or x : y ::

Indeed, in the Boolean lattice associated to the two truth values 0, 1, x : y :: z : t is true (i.e., is equal to '1') for the six patterns (x, y, z, t) = (1, 0, 1, 0), (x, y, z, t) = (0, 1, 0, 1), (x, y, z, t) = (1, 1, 0, 0), (x, y, z, t) = (0, 0, 1, 1), (x, y, z, t) = (1, 1, 1, 1) and (x, y, z, t) = (0, 0, 0, 0), and false for the ten other possible patterns which are (x, y, z, t) = (1, 0, 0, 1), (x, y, z, t) = (0, 1, 1, 0) and the eight patterns having an odd number of '1' and '0' (e.g., (x, y, z, t) = (0, 0, 1, 0) or (x, y, z, t) = (0, 1, 1, 1)). The six above patterns which make x : y :: z : t true clearly correspond to the subsets a, b, c, d, e, f .

The case of graded properties Analogical proportions have been also extended when properties are graded on a chain which is finite, or such as the unit interval [0, 1] [19]. For instance, a property may be half-true. Then, in the case of a finite chain with three elements {0, ω, 1}, two views make sense, for which the patterns having truth value '1' are respectively -the 15 patterns, that includes the 6 of the binary case (1, 0, 1, 0), (0, 1, 0, 1),

(1, 1, 0, 0), (0, 0, 1, 1), (1, 1, 1, 1), (0, 0, 0, 0), together with their 9 counterparts

(ω, 0, ω, 0), (0, ω, 0, ω), (1, ω, 1, ω), (ω, 1, ω, 1), (ω, ω, 0, 0), (0, 0, ω, ω), (1, 1, ω, ω), (ω, ω, 1, 1), (ω, ω, ω, ω)

-the 15 above patterns together with the 4 additional ones (1, ω, ω, 0), (0, ω, ω, 1), (ω, 0, 1, ω), (ω, 1, 0, ω).

In the second view, we acknowledge the fact that when there is a change from x to y there is the same change from z to t, and otherwise there is no change between x and y, and between z and t, but also the fact that the proportion still holds when the change from x to y has the same direction and intensity as the change from z to t (considering that ω is exactly in the "middle" between 0 and 1). It is easy to see that the lattice-based definition proposed here agrees with the first view only, while the 4 additional patterns do not make analogical proportions.

In the case of the unit interval [0, 1], this leads to the following graded view of the analogical proportion:

x : y ::

It is easy to see that the above definition is a direct counterpart of the second form of the propositional expression of the analogical proportion given above. Moreover, it is equal to 1 only for the 15 patterns mentioned above.

We show here that in distributive lattices, a 4-tuple in analogical proportion is such that "the product of the means is equal to the product of the extremes".

Proposition 3 In a distributive lattice, (x : y :: z : t) is an AP iff: The next property is a stronger result: the four values of the bounds in the preceding property are actually only two.

Proposition 4 In a distributive lattice, (x : y :: z : t) is an analogical proportion iff x ∨ t = y ∨ z and x ∧ t = y ∧ z.

Proof. (⇒). Using the expressions of x, y, z and t given by Proposition 1, we easily check that x ∨ t = y ∨ z and x ∧ t = y ∧ z. (⇐). By absorption law and distributivity, we have

The other equations of Proposition 1 can be obtained in a similar way.

Comment 1. In [13,7], an incomplete definition of a proportion in a lattice has been given. Actually, only four equalities of Definition 3 were given, and only four equalities of Proposition 1 were demonstrated (in a different manner than here). This definition was flawed, since for example in the lattice ({0, 1}, ∨, ∧) it would have given (0 : 1 :: 1 : 1) as a proportion, although it does not satisfy the basic axioms. In the particular case of Boolean lattices, Proposition 4 has been shown in [10].

Comment 2. If the lattice is not distributive, Proposition 4 is not an equivalence, but an implication. For example, let us consider the elements x = [2, 3], y = [2,6], z = [8,9] and t= [6,9] of the lattice of closed intervals on R. We have x ∨ t = y ∨ z and x ∧ t = y ∧ z but the conditions of Definition 3 are not satisfied. We are currently studying in general lattices and concept lattices the properties of what can be called a weak analogical proportion, namely the fact that four elements are linked by the equalities x ∨ t = y ∨ z and x ∧ t = y ∧ z.

The first and second axioms of Definition 1 are straightforwardly verified by Definition 3. What about the third axiom? Proposition 5 (Determinism in a distributive lattice) Let x and y be two elements of a distributive lattice, the equation in z: (x : x :: y : z) has the unique solution z = y. This is also true for the equation (x : y :: x : z).

Proof. Let us consider a solution z of (x : x :: y : z). From Proposition 4, we have

(2)

Besides, using absorption law, z = (x∨z)∧z. Consequently, using (2) and distributivity, z = (x ∨ y) ∧ z = (x ∧ z) ∨ (y ∧ z). Then, using (2), distributivity and absorption, we can conclude:

We present in this section a particular case of analogical proportion which will be shown later (see section 4) to be a "building block" of the general proportion.

Proposition 6 (Canonical proportions) Let y and z be two arbitrary elements of a lattice. Then the following analogical proportion is true:

Proof.

Equations of Proposition 4 are straightforwardly satisfied.

In the following, we will call this particular analogical proportion a canonical analogical proportion (CAP ). Note that the previous property holds in general lattices, not only distributive lattices.

In general, analogical proportions in a lattice are not canonical, such as (14 : 21 :: 10 : 15) in (N + , gcd, lcm, |).

Note that a canonical proportion can be written in eight different forms (see Definition 1), by applying the axioms of analogical proportion. We suppose in the following that one of the two particular following forms are used: y : y ∨ z :: y ∧ z : z or z : y ∨ z :: y ∧ z : y. This form is called the CAP 1 form, as opposed to the CAP 2 one: y : y ∧ z :: y ∨ z : z or z : y ∧ z :: y ∨ z : y.

We are interested in here in defining primitive proportions, that will be used as "building blocks" of the general proportion. This is done in particular to enlighten primitive chunks in a process of reasoning by analogy. Definition 4 Let a = (x, y, z, t) and A = (X, Y, Z, T ) be two 4-tuples of a distributive lattice (L, ∨, ∧). We define the ∨ -composition and the ∧ -composition of these two 4-tuples as the 4-tuples:

Note that these operations are commutative and associative.

Using Proposition 4 and distributivity.

This property is a generalisation of a property in Boolean lattices, shown in [10]. Analogical proportions are not closed for general composition, as shown below.

Note that the composition of two AP 's is not necessarily an AP (nor is the composition of an AP and a SAP ) and that the composition of two CAP 's is not necessarily an AP .

Proposition 8 In a distributive lattice, for every AP a 1 there exists a SAP 1 a 2 and a SAP 2 a 3 such that a 1 = a 2 ∨ a 3 . There also exists a SAP 1 a 3 and a SAP 2 a 4 such that a 1 = a 3 ∧ a 4 .

We check that (x : y :: z : t) is the ∧ -composition of (x ∨ y) : (x ∨ y) :: (z ∨ t) : (z ∨ t) and (x ∨ z) : (y ∨ t) :: (x ∨ z) : (y ∨ t), by proposition 1. It is also the ∨ -composition of (x ∧ y) : (x ∧ y) :: (z ∧ t) : (z ∧ t) and (x ∧ z) : (y ∧ t) ::

Proposition 9 In a distributive lattice, for every AP a 1 there exists a CAP 1 a 2 and a CAP 2 a 3 such that a 1 = a 2 ∨ a 3 . There exists also a CAP 1 a 3 and a CAP 2 a 4 such that a 1 = a 3 ∧ a 4 .

We check that (x : y :: z : t) is the ∨ -composition of (x ∧ y) : y ::

Proposition 10 In a distributive lattice, for every AP a 1 there exists a CAP 1 a 2 such that a 1 ∨ a 2 is a CAP 2.

Proof. Let a1 = (x : y :: z : t), and take a2 = ((z ∧t) : z :: (x∧y ∧z ∧t) : (x∧z)).

We have to show that [x∨(z∧t)] : (y∨z) :: z : [t∨(x∧z)]. According to property 1, we show equivalently the two equalities:

The first equality has a similar demonstration.

In this section, we answer the following question: given three elements of an AP , can we find the fourth one? This is an important issue in analogical reasoning.

Let us suppose that in a distributive lattice we know three elements a, m and M . We are looking for an x satisfying the couple of equations:

This is a more general question that wondering whether the analogical equation Proof. Firstly, we show that x∧a = m with the equalities:

Secondly, the equality x ∨ a = M is demonstrated in the same manner, using M ≤ ( a ∨ a) instead of ( a ∧ a) ≤ m. Then x = (M ∧ a) ∨ m is the solution.

Thirdly, we show in the same manner that x = (m ∨ a) ∧ M is a solution to (4). Since the solution is unique, the property is demonstrated.

When two or three elements are comparable, the solutions of the analogical equation are severely constrained.

Proposition 13 Let x, y, z and t be four elements of a distributive lattice such as (x : y :: z : t). If the three first elements are comparable then this AP is a SAP or a CAP . More precisely, (x : y :: z : t) is 1) (y ∧ z : y :: z : y ∨ z) if x ≤ y ∧ z, and (y ∨ z : y ::

Proof.

1) We have from (1) y ∧ z ≤ x ≤ y ∨ z. Let us consider the case where x ≤ y ∧ z. We then have x = y ∧ z and we can easily check that t = y ∨ z is solution of equations x ∨ t = y ∨ z and x ∧ t = y ∧ z. Then, using Propositions 4 and 11, t = y ∨ z is the unique solution of (y ∧ z : y :: z : t). Moreover, if x ≤ z ≤ y, t = y ∨ z = y and then x = z. The other cases have a similar demonstration.

2) If z ≤ x ≤ y, y = x ∨ t and z = x ∧ t using Proposition 4,

3) The reasoning is similar to the previous one.

In the Boolean case, we recall a previous result.

Proposition 14 ([16]) The analogical equation in t: (x : y :: z : t) has a solution in a Boolean lattice if and only if y ∩ z ⊆ x ⊆ y ∪ z. In this case, the unique solution is t = ((y ∪ z)\x) ∪ (y ∩ z).

Finally, let us investigate transitivity, which propagates (dis)similarity. In the Boolean case, (a : b) :: (c : d) :: (e : f ) holds for general proportions [10]. In the distributive case, CAP 1 (resp. CAP 2) are transitive. Proof is omitted due to space limitation.

Proposition 15 (Transitivity of CAP ) If (x : (x ∨ t) :: (x ∧ t) : t) and ((x∧t) : t :: u : v) are two canonical proportions of form CAP 1 (resp. CAP 2), then x : (x ∨ t) :: u : v is a canonical proportion of form CAP 1 (resp. CAP 2).

Conjecture 1 (Non transitivity of proportions) If (x : y :: z : t) and (z : t :: u : v) are two analogical proportions in a distributive lattice, it does not necessarily imply that (x : y :: u : v) is an analogical proportion.

We have not found any example to show this property, albeit the transitivity seems impossible to prove. Therefore, the non transitivity in a general distributive lattice is a conjecture. However, we have found an example to show that transitivity doesn't hold in general in a non transitive lattice.

We have not found any counter example to show this property. We conjecture there is no transitivity in distributive lattices. Indeed, in a non distributive lattice, transitivity does not holds, as shown in the following example. In S (see section 2) we have [0, 3] : {3} :: {0} : ∅ by considering Definition 3 and 4] and t 2 = {4}. However, [0, 3] : {3} :: [0, 4] : {4} is not true because it is impossible to satisfy the second condition of Definition 3. Indeed, if there exists four elements

The results of this paper provide a better understanding of analogical proportions in the general setting of lattices structures. In particular, it relates a factorization-based view of analogical proportions to its propositional logical reading in the case of Boolean lattices. For graded proportions, where the underlying lattice of grades is a chain, it leads to consider that the only fully valid logical proportions are of the form x : y :: x : y (and x : x :: y : y ) where x and y are elements in the chain. It acknowledges the fact that the change should be exactly the same on both sides of the proportion in order to make it (completely) valid, an idea which is for instance (successfully) at work in [9]. The paper has also introduced canonical forms of analogical proportions that are instrumental in the decomposition of analogical proportions in distributive lattices. The unicity of the solution of an analogical proportion equation when it exists, is a important property that is preserved in distributive lattices, and which enables us to generate accurate conclusions.

Generally speaking, the results presented should be useful to design algorithms helping to propagate information in lattices, especially for purposes of reasoning and learning. Moreover, in [20] a first attempt has been provided for relating analogical proportions to formal concept analysis, and searching for analogical proportions that may hold in a formal context by exploiting the lattice structure of the set of formal concepts. This study of analogical proportions in lattice structures should contribute in the long range to a clearer view of the links between these formalizations of the two key cognitive processes that are conceptual categorization and analogical reasoning.

Marketa Krmelova, Martin Trnecka

Data Analysis and Modeling Lab (DAMOL) Department of Computer Science, Palacky University, Olomouc marketa.krmelova@gmail.com, martin.trnecka@gmail.com

Abstract. The Boolean factor analysis is an established method for analysis and preprocessing of Boolean data. In the basic setting, this method is designed for finding factors, new variables, which may explain or describe the original input data. Many real-world data sets are more complex than a simple data table. For example almost every web database is composed from many data tables and relations between them.

In this paper we present a new approach to the Boolean factor analysis, which is tailored for multi-relational data. We show our approach on simple examples and also propose future research topics.

Many data sets are Boolean by nature, that is, they contain only 0s and 1s. For example, any data recording the presence (or absence) of variables in observations are Boolean. Boolean data can be seen as a binary data table (or matrix or formal context) C, where the rows represent objects and the columns represent attributes of these objects. Between objects and attributes exists an incidence relation with meaning that an object i has an attribute j and this fact is represented by one in the Boolean table, i.e. C ij = 1. If an object i has not an attribute j, than C ij = 0. Many real-word data sets are more complex that a simple data table. Usually, they are composed from many data tables, which are interconnected by relations. An example of such data can be found in almost every sector of human activity. We call this kind of data multi-relational data. In this kind of data, this relations are crucial, because they represent additional information about the relationship between data tables and this information is important for understanding data as a whole.

The Boolean factor analysis (BFA) is used for many data mining purposes. The basic task in the BFA is to find new variables, called factors, which may explain or describe original single input data. Finding factors is obviously an important step for understanding and managing data. Boolean nature of data is in this case beneficial especially from the standpoint of interpretability of the results. On the other hand BFA is suitable for single input Boolean data table with just one relation between objects and attributes. The main aim of this work is to present the BFA of multi-relational data, which takes into account relations between data tables and extract more detailed information from this complex data.

We assume familiarity with the basic notions of FCA [3]. In this work, we use the binary matrix terminology, because it is more convenient from our point of view. Consider an n × m object-attribute matrix C with entries C ij ∈ {0, 1} expressing whether an object i has an attribute j or not, i.e. C can be understood as a binary relation between objects and attributes. Because there is no danger of confusion we can consider this matrix as a formal context X, Y, C , where X represents a set of n objects and Y represents a set of m attributes.

A formal concept of X, Y, C is any pair E, F consisting of E ⊆ X (socalled extent) and F ⊆ Y (so-called intent) satisfying

The goal of the BMF (the idea from [1,6]) is to find decomposition

of I into a product of an n × k object-factor matrix A over {0, 1}, a k × m matrix B over {0, 1}, revealing thus k factors, i.e. new, possibly more fundamental attributes (or variables), which explain original m attributes. We want k < m and, in fact, k as small as possible in order to achieve parsimony: The n objects described by m attributes via C may then be described by k factors via A, with B representing a relationship between the original attributes and the factors. This relation can be interpreted in the following way: an object i has an attribute j if and only if there exists a factor l such that i has l (or, l applies to i) and j is one of the particular manifestations of l.

The product • in ( 1) is a Boolean matrix product, defined by

where denotes maximum (truth function of logical disjunction) and • is the usual product (truth function of logical conjunction). For example the following matrix can be decomposed into two Boolean matrices with k < m.

The least k for which an exact decomposition C = A • B exists is in the Boolean matrix theory called the Boolean rank (or Schein rank).

An optimal decomposition of the Boolean matrix can be found via Formal concept analysis. In this approach, the factors are represented by formal concepts, see [2]. The aim is to decompose the matrix C into a product A F • B F of Boolean matrices constructed from a set F of formal concepts associated to C. Let

where B(X, Y, C) represents set of all formal concepts of context X, Y, C . Denote by A F and B F the n × k and k × m binary matrices defined by

for l = 1, . . . , k. In other words, A F is composed from characteristic vectors A l .

Similarly for B F . The set of factors is a set F of formal concepts of X, Y, C , for which holds C = A F • B F . For every C such a set always exists. For details see [2]. Interpretation factors as a formal concepts is very convenient for users and we follow this point of view in our work. Because a factor can be seen as a formal concept, we can consider the intent part (denoted by intent(F )) and the extent part (denoted by extent(F )) of the factor F .

The Boolean matrix factorization (or decomposition), also known as the Boolean factor analysis, has gained interest in the data mining community during the past few years.

In the literature, we can find a wide range of theoretical and application papers about the Boolean factor analysis. The overview of the Boolean matrix theory can be found in [8]. A good overview from the BMF viewpoint is in e.g. [12]. For our work is the most important [2], where were first used formal concepts as factors.

Several heuristic algorithms for the BMF were proposed. In our work we adopt algorithm GreConD [2] (originally called Algorithm 2), but there exist several different approaches, which use so-called "tiles" in Boolean data [4], hyper-rectangles [15] or which introduce some noise [12,10] in Boolean data.

From wide range of applications papers let us mentioned only [13] and [14], where the BMF is used for solving the Role mining problem.

In the literature, there can be found several methods for the latent factor analysis of ordinal data and also of multi-relational data [9], but using these methods for Boolean data has proved to be inconvenient many times.

The BMF of multi-relational data is not directly mentioned in any previous work. Indirectly, it is mentioned, in a very specific form, in [11] as Joint Subspace Matrix Factorization, where there are two Boolean matrices, which both share the same rows (or columns). The main aim is to find a set of shared factors (factors common for both matrices) and a set of specific factors (factors which are either in first or second matrix, not in both). This can be viewed as particular, very limited setting of our work.

From our point of view are also relevant works [5,7]. These introduce the Relational formal concept analysis (RCA), i.e. the Formal concept analysis on multi-relational data. Our approach is different from the RCA. In our approach, we extract factors from each data table and connect these factors into more general factors. In RCA, they iteratively merge data tables into one in the following way: in each step they computed all formal concepts of one data table and these concepts are used as additional attributes for the merged data table. After obtaining a final merged data table, all formal concepts are extracted. Let us mention that our approach delivers more informative results than a simple use of BMF on merged data table from RCA, moreover getting merged data table is computationally hard.

In this section we describe our basic problem setting. We have two Boolean data tables C 1 and C 2 , which are interconnected with relation R C1C2 . This relation is over the objects of first data table C 1 and the attributes of second data table C 2 , i.e. it is an objects-attributes relation. In general, we can also define an objectsobjects relation or an attributes-attributes relation. Our goal is to find factors, which explain the original data and which take into account the relation R C1C2 between data tables. Definition 1. Relation factor (pair factor) on data tables C 1 and C 2 is a pair

where

There are several ways how to define the meaning of "satisfying relation" from Definition 1. We will define the following three approaches (this definition holds for an object-attribute relation, other types of relations can be defined in similar way):

where R k is a set of attributes, which are in relation with an object k. This approach we called narrow (it is analogy of the narrow operator in [7]).

-F i 1 and F j 2 form pair factor

We called this approach wide (it is analogy of the wide operator in [7]).

-for any α ∈ [0, 1], F i 1 and F j 2 form pair factor F i 1 , F j 2 if holds:

We called it an α-approach.

Remark 1. It is obvious, that for α = 0 and replacing ≥ by >, we get the wide approach and for α = 1, we get the narrow one.

Lemma 1. For α 1 > α 2 holds, that a set of relation factors counted by α 1 is a subset of a set of relation factors obtained with α 2 .

We demonstrate our approach to factorisation of mutli-relational Boolean data by a small illustrative example.

Example 1. Let us have two data tables C W (Table 1) and C M (Table 2). C W represents women and their characteristics and C M represents men and their characteristics. 3) between the objects of first the data table and the attributes of the second data table. In this case, it could be a relation with meaning "woman looking for a man with the characteristics". Remark 2. Generally, nothing precludes the object-object relation (whose meaning might be "woman likes a man") and the attribute-attribute relation (whose meaning might be "the characteristics of women are compatible with the characteristics of men in the second data table ").

{wants kids, is attractive} These factors were obtained via GreConD algorithm from [2]. We have two sets of factors (formal concepts), first set

For the above defined approaches we get results which are shown below. We write it as binary relations, i.e F i W and F j M belongs to relational factor F i W , F j M iff F i W and F j M are in relation:

The relational factor in form F i W , F j M can be interpreted in the following ways:

-Women, who belong to extent of F i W like men who belong to extent of F j M . Specifically in this example, we can interpret factor F 1 W , F 1 M , that Abby and Daphne should like Ben and Carl.

-Women, who belong to extent of F i W like men with characteristic in intent of F j M . Specifically in this example, we can interpret factor F 1 W , F 1 M , that Abby and Daphne should like undergraduate men, who want kids.

-Women, with characteristic from intent F i W like men who belong to extent F j M . Specifically in this example, we can interpret factor F 1 W , F 1 M , that undergraduate, attractive women, who want kids should like Ben and Carl.

-Women, with characteristic from intent F i W like men with characteristic in intent of F j M . Specifically in this example, we can interpret factor F 1 W , F 1 M , that undergraduate, attractive women, who want kids should like undergraduate men, who want kids.

W and F j M is driven by used approach. If we obtain factor F i W , F j M by narrow approach, we can interpret relation between F i W and F j M : "women who belong to F i W , like men from F M j completely". For example factor F 1 W , F 1 M can be interpreted: "All undergraduate attractive women, who want kids, wants undergraduate men, who want kids."

If we obtain factor F i W , F j M by wide approach, we can interpret the relation between F i W and F j M : "women who belong to F i W , like something about the men from F M j ". For example F 2 W , F 1 M can be interpreted: "All athlete woman, who want kids, like undergraduate men or man, who want kids."

If we get F i W , F j M by α-approach with value α, we interpret the relation between F i W and F j M as: "women from F i W , like men from F M j enough", where α determines measurement of tolerance. For each factor, we take the extent of this factor and compute concept in C 1 , which contains this extent. Similarly for intents of factors and concepts in C 2 . For example one of the factors of R C W C M from Example 1 is: {Becky, Daphne}, {athlete, wants kids} .

Relational factor computed from this factor will be {Becky, Daphne}, {athlete, wants kids} , {Carl}, {athlete, undergraduate, wants kids} . This approach seems to be better in terms of that we get pair of concepts for every factors, but we do not get an exact decomposition of data tables C 1 and C 2 . Moreover this approach can not be extended to n-ary relations.

Above approaches can be generalized for more than two data tables. In this generalization, we do not get factor pairs, but generally factor n-tuples. Now we extend Definition 1 to general definition of relational factor.

We considered only binary relations between data tables, for which holds, that there exists only one relation interconnecting data tables C i and C i+1 for i ∈ {1, . . . , n − 1}. We left more general relations into the extended version of this paper. Let us mentioned, that this generalization of our approach is possible in the opposite of Remark 5. We show n-tuple relational factors on example.

Example 2. Let data table C P (Table 4) represents people and their characteristic, C R (Table 5) represents restaurants and their characteristics and C C (Table 6) represents which ingredients are included in national cuisines. One of the relational factors, which we get by 0.5-approach, is

and could be interpreted as "men would enjoy eating in luxury restaurants where the meals are cheap". Another factor is F 3 P , F 2 C , F 1 R and could be interpreted as "women enjoy eating in ordinal cheap restaurants".

We can represent the relational factors via graph (n-partite). See Figure 1, which presents the results from the previous example. Each group of nodes (F i P , F i C , F i R ) represents factors of a specific data table. Between two nodes, there is an edge iff factors representing nodes satisfy the input relation. Relational factor is path between nodes, which include at most one node from each group. For example,

R is a relational factor because there is an edge between nodes F 2 P and F 3 C and between F 3 C and F 1 R .

Fig. 1: Representation factors connections via graph.

In this paper we present the new approach to BMF of multi-relational data, i.e. data which are composed from many data tables and relations between them. This approach, as opposed from to BMF, takes into account the relations and uses these relations to connect factors from individual data tables into one complex factor, which delivers more information than the simple factors.

A future research shall include the following topics: generalization multirelational Boolean factorization for ordinal data, especially data over residuated lattices. Design an effective algorithm for computing relational factors. Develop new approaches for connecting factors which utilize statistical methods and last but not least drive factor selection in the second data table, using information about factors in the first one and relation between them, for obtaining more relevant data.

(with an application on care trajectories)

Aleksey Buzmakov 1,2 , Elias Egho 1 , Nicolas Jay 1 , Sergei O. Kuznetsov 2 , Amedeo Napoli 1 , and Chedy Raïssi 11 LORIA (CNRS -Inria NGE -U. de Lorraine), Vandoeuvre-lès-Nancy, France 2 National Research University Higher School of Economics, Moscow, Russia {aleksey.buzmakov, chedy.raissi}@inria.fr, {elias.egho, nicolas.jay, amedeo.napoli}@loria.fr, skuznetsov@hse.ru Abstract. In this paper, we are interested in the analysis of sequential data and we propose an original framework based on FCA. For that, we introduce sequential pattern structures, an original specification of pattern structures for dealing with sequential data. Sequential pattern structures are given by a subsumption operation between set of sequences, based on subsequence matching. To avoid a huge number of resulting concepts, domain knowledge projections can be applied. The original definition of projections is revised in order to operate on sequential pattern structures in a meaningful way. Based on the introduced definition, several projections of sequential pattern structures involving domain or expert knowledge are defined and discussed. This projections are evaluated on a real dataset on care trajectories where every hospitalization is described by a heterogeneous tuple with different fields. The evaluation reveals interesting concepts and justify the usage of introduced projections of sequential pattern structures. This research work provides a new and efficient extension of FCA to deal with complex data, which can be an alternative to the analysis of sequential datasets.

Analysis of sequential data is a challenging task. In the last two decades, the main emphasis has been on developing efficient mining algorithms with effective pattern representations for sequences of itemsets [1][2][3][4]. The traditional sequential pattern mining algorithms generate a large number of frequent sequences while a few of them are truly relevant. Moreover, in some particular cases, only sequential patterns of a certain type are of interest and should be mined first. Are we able to develop a framework for taking into account only patterns of required types? Furthermore, in many cases sequential data are described by sequences with complex elements, e.g. a text is a sequence of syntactic trees. To process such kind of data with existing algorithms, elements of sequences can be scaled into itemsets as it is done in the case of multilevel multidimensional data [5]. However, in this case it is rather difficult to introduce expert requirements within a sequence, which leads to even a larger set of resulting patterns.

We approach this problem with FCA and pattern structures [6,7]. FCA is successfully used for analysis of sequential data [8,9]. Moreover, it allows one to use different measures of interestingness for the resulting patterns (concepts). Pattern structures allows to directly process sequential data without a scaling step. Furthermore, there are projections of pattern structures, which were introduced in order to simplify the computation of pattern lattices, by simplifying descriptions. Moreover, projections can be efficiently used as special domain knowledge requirements, allowing to reduce the number of irrelevant patterns. We generalize the original definitions of projections, in order to deal with projections respecting domain knowledge. For example, sequences of length 1 are rare useful but they cannot be excluded by the original definition of projections.

The rest of the paper is organized as follows. In Section 1 we remind FCA, pattern structures and measures of concept interestingness. Section 2 states the problem of complex sequences analysis and introduces sequential pattern structures. In Section 3, first, the generalization of projections is defined, and, second, some projections specific to sequential pattern structures are introduced and analyzed. And finally before concluding the paper, we discuss an experimental evaluation in Section 4.

FCA [6] is a mathematical formalism having many applications in data analysis. Pattern structures is a generalization of FCA for dealing with complex structures, such as sequences or graphs [7]. Definition 1. A pattern structure is a triple (G, (D, ), δ), where G is a set of objects, (D, ) is a complete meet-semilattice of descriptions and δ : G → D maps an object to a description.

The lattice operation in the semilattice ( ) corresponds to the similarity between two descriptions. Standard FCA can be presented in terms of pattern structures. In this case, G is the set of objects, the semilattice of descriptions is (℘(M ), ), where a description is a set of attributes, with the operation corresponding to the set intersection (℘(M ) denotes the powerset of M ). If x = {a, b, c} and y = {a, c, d} then x y = x ∩ y = {a, c}. The mapping δ : G → ℘(M ) is given by, δ(g) = {m ∈ M | (g, m) ∈ I}, and returns the description for a given object as a set of attributes.

The Galois connection for (G, (D, ), δ) is defined as follows:

The Galois connection makes a correspondence between sets of objects and descriptions. Given a set of objects A, A returns the description which is common to all objects in A. And given a description d, d is the set of all objects whose description subsumes d. More precisely, the partial order (or the subsumption order) on D ( ) is defined w.r. As in standard FCA, a pattern concept corresponds to the maximal set of objects A whose description subsumes the description d, where d is the maximal common description for objects in A. The set of all concepts can be partially ordered w.r.t. partial order on extents (dually, intent patterns, i.e ), within a concept lattice. An example of a pattern structure is given and described in the next sections. It can be noticed that Table 1 defines a pattern structure, while the corresponding lattice is depicted in Figure 1.

It is worth mentioning, that the size of the concept lattice can be exponential w.r.t. to the number of objects, and, thus, we need a special ranking method to select the most interesting concepts for further analysis. Several techniques are considered in [10], where it is shown that stability index [11] is more reliable in noisy data. Thus, we use this index in our current work.

Stability measures how much the concept depends on the initial dataset. The larger the stability the more objects can be deleted from the context without affecting the intent of the concept, i.e. the intent of the most stable concepts are likely to be a characteristic pattern of a studied phenomena rather than an artifact of a data set.

After a brief general description of the analysis with pattern structures, the analysis of sequential data can be specified.

Imagine that we have medical trajectories of patients, i.e. sequences of hospitalizations, where every hospitalization is described by a hospital name and a set of procedures. An example of sequential data on medical trajectories with three patients is given in Table 1. There are a set of procedures P = {a, b, c, d}, a An important task is to find the "characteristic" sequences of procedures and associated hospitals in order to improve hospitalization planning, optimize clinical processes or detect anomalies. This sequences can be found by searching for the most stable concepts in the lattice corresponding to a pattern structure.

A sequence is constituted of elements from an alphabet. The classical subsequence matching task requires no special properties of the alphabet. Several generalizations of the classical case were made by introducing a subsequence relation based on itemset alphabet [8] or on multidimensional and multilevel alphabet [5], scaled to itemset alphabet as well. Both these alphabets are certain semilattices, and, thus, we generalize the previous cases, requiring for an alphabet to form a general semilattice (E, E )1 . Thanks to pattern structure formalism we are able to process in a unified way all types of sequential datasets with poset-shaped alphabet. However, some sequential data can have connections between elements, e.g. [12], and, thus, cannot be immediately processed by our approach.

Definition 4. A sequence is an ordered list of e ∈ (E, E ), such that e = ⊥ E .

Here, ∀e ∈ E, ⊥ E = ⊥ E E e. The bottom element is required by the lattice structure but provide us with no useful information (it matches to any other element), thus, it is excluded from the sequences. In the same way, in mining of sequences of itemsets the empty itemset cannot be a proper element [2]. Definition 5. A sequence t = t 1 ; ...; t k is a subsequence of a sequence s = s 1 ; ...; s n , denoted t ≤ s, iff k ≤ n and there exist j 1 , ..j k such that 1 ≤ j 1 < j 2 < ... < j k ≤ n and for all i ∈ {1, 2, ..., k}, t i E s ji (⇔ t i E s ji = t i ). Fig. 1: The concept lattice for the pattern structure given by Table 1. Concept intents reference to sequences in Tables 1 and 2. 1.

With complex sequences and such kind of subsequences the computational procedure can be difficult, thus, to simplify the procedure, only "contiguous" subsequences are considered, where only the order of consequent elements is taken into account, i.e. given j 1 in Definition 5, j i = j i−1 +1 for all i ∈ {2, 3, ..., k}. Such a restriction makes sens for our data, because a hospitalization is a discrete event and it is likely that the next hospitalization has a relation with the previous one, for example, hospitalizations for treating aftereffects of chemotherapy. Below the word "subsequence" refers to "contiguous" subsequence.

Example 1. In the running example (Section 2.1), the alphabet is E = T H ×℘(P ) with the similarity operation (h 1 , P 1 ) (h 2 , P 2 ) = (h 1 h 2 , P 1 ∩ P 2 ), where h 1 , h 2 ∈ T H are hospitals and P 1 , P 2 ∈ ℘(P ) are sets of procedures. Thus, the sequence ss 1 in Table 2 is a subsequence of p 1 in Table 1 because if we set j i = i + 1 (Definition 5) then ss 1 1 p 1 j1 ('CH' is an ancestor for H 1 and {c, d} ⊆ {c, d}), ss 1 2 p 1 j2 (the same hospital and {b} ⊆ {b, a}) and ss 1 3

('*' is an ancestor for anything and {d} ⊆ {d}).

Using the previous definitions, we can precisely define the sequential pattern structures that are used for representing and managing sequences. For that, we make an analogy with pattern structures for graphs where the meet-semilattice operation respects subgraph isomorphism [13]. Thus, we introduce a sequential meet-semilattice respecting subsequence relation. Let us consider S as the set of all sequences based on an alphabet (E, E ). S is partially ordered w.r. Example 2. The sequential pattern structure for our example (Subsection 2.1) is (G, (D, ), δ), where G = p 1 , p 2 , p 3 is the set of patients, (D, ) is the semilattice of sequential descriptions, and δ is the mapping (shown in Table 1) associating a patient in G to a description in D. Figure 1 shows the resulting lattice of sequential pattern concepts for this particular pattern structure.

The set of all possible subsequences for a given sequence can be rather large. Thus, it is more efficient and readable to keep a pattern d ∈ D as a set of only maximal sequences d, d = {s ∈ d | s * ∈ d : s * ≥ s}. In the rest of the paper, every pattern is given only by the set of its maximal sequences. For example, p 2 p 3 = ss 6 , ss 7 , ss 8 (see Tables 1 and 2), i.e. ss 6 , ss 7 , ss 8 is the set of all maximal sequences specifying the intersection result of two sets of sequences p 2 and p 3 , in the same way ss 6 , ss 7 , ss 8 p 1 = ss 4 , ss 5 . Note that representing a pattern by the set of all maximal sequences allows for an efficient implementation of the intersection " " of two patterns. The next proposition is follows from this subsection and Definition 5.

Proposition 1. Given (G, (D, ), δ) and x, y ∈ D, x y if and only if ∀s x ∈ x there is a sequence s y ∈ y, such that s x ≤ s y .

Pattern structures can be hard to process due to the usually large number of concepts in the concept lattice and the complexity of the involved similarity operation (make the parallel with the graph isomorphism problem). Moreover, a given pattern structure can produce a lattice with a lot of patterns which are not interesting for an expert. Can we save computational time by avoiding the construction of unnecessary patterns? Projections of pattern structures "simplify" to some degree the computation and allow one to work with a reduced description. In fact, projections can be considered as constraints (or filters) on patterns respecting certain mathematical properties. These mathematical properties ensure that the projection of a lattice is a lattice where projected concepts have certain correspondence to original ones. Moreover, the stability measure of projected concepts never decreases w.r.t the corresponding concepts. We introduce projections on sequential patterns, revising them from [7]. An extended definition of projections w.r.t. the definition in [7] should be provided in order to deal with interesting projections for real-life sequential datasets. Note that in [7] ψ((G, (D, ), δ)) = (G, (D, ), ψ • δ). Now we should show that (D ψ , ψ ) is a semilattice. Proposition 2. Given a semilattice (D, ) and a projection ψ, for all x, y ∈ D ψ(x y) = ψ(ψ(x) y).

then (ψ(x) y) ψ(x y) and ψ(ψ(x) y) ψ(ψ(x y)) = ψ(x y) 4. From ( 2) and (3) follows that ψ(x y) = ψ(ψ(x) y).

Corollary 2. Given a semilattice (D, ) and a projection ψ, (D ψ , ψ ) is a semilattice, i.e. ψ is commutative, associative and idempotent.

The concepts of a pattern structure and a projected pattern structure are connected with the next proposition, following from Corollary 1:

, where d is the intent of the concept with the same extent.

Moreover, preserving extents of some concepts, projections cannot decrease the stability of the projected concepts, i.e. if the projection preserves a stable concept, then its stability (Definition 3) can only increase. Proof. Concepts c and c have the same extent. Thus, according to Definition 3, in order to prove the proposition statement, it is enough to prove that for any subset A ⊆ Ext(c), if A = Int(c) in the original pattern structure, then A = Int(c) in the projected one. It can be proven from contrary.

Suppose that ∃A ⊂ Ext(c) such that A = Int(c) in the original pattern structure and A = Int(c) in the projected one. Then there is a descendant concept d of c in the projected pattern structure such that A = Int( d) in the projected lattice. Then there is an original concept d for the projected concept d with the same Ext(d). Then A Int(d) Int(c) and, so, A cannot be equal to Int(c) in the original lattice. Contradiction.

No we are going to present two projections of sequential pattern structures. The first projection comes from the following observation. In many cases it may be more interesting to analyze quite long subsequences rather than short one. This kind of projections is called Minimal Length Projection (MLP) and it depends on the minimal allowed length parameter l for the sequences in a pattern. The corresponding function ψ maps a pattern without short sequences to itself, and a sequence with short sequences to the pattern containing only long sequences, ψ(d) = {s ∈ d | length(s) > l}. Later, propositions 1 and 5 stay that MLP is coherent with Definition 6.

Example 3. If we prefer common subsequences of length ≥ 3, then between p 2 and p 3 in Table 1 there is only one maximal common subsequence, ss 6 in Table 2, while ss 7 and ss 8 are too short to be considered. Figure 2a shows the lattice corresponding the projected pattern structure (Table 1) with patterns of length more or equal to 3. Proposition 5. MLP is a monotone, contractive and idempotent function on the semilattice (D, ).

Proof. The contractivity and idempotentcy are quite clear from the definition. Remains the proof for monotonicity.

If X Y where X and Y are sets of sequences then for every sequence x ∈ X there is a sequence y ∈ Y such that x ≤ y (Proposition 1). We should show that ψ(X) ψ(Y ), or in other words for every sequence x ∈ ψ(X) there is a sequence y ∈ ψ(Y ), such that x ≤ y. Given x ∈ ψ(X), since ψ(X) is a subset of X and X Y , then there is a sequence y ∈ Y such that x ≤ y, with |y| ≥ |x| ≥ l (l is a parameter of MLP), and thus, y ∈ ψ(Y ).

The second projection of a sequential pattern structure is connected to a projection of an alphabet semilattice, (E, E ).

Example 4. An expert is interested in finding sequential patterns on how a patient changes hospitals, but he has little interest in procedures. Thus, any element of the alphabet lattice, containing a non-empty set of procedures can be projected to the element with the same hospital but with the empty set of procedures.

Example 5. An expert is interested in finding sequential patterns containing some information about the hospital in every hospitalization, and the corresponding procedures, i.e. hospital field in the patterns cannot be equal to the element "any hospital", denoted * , e.g., ss 5 is an invalid pattern, while ss 6 is a valid pattern in Table 2. Thus, any element of the alphabet semilattice with * hospital can be projected to the ⊥ E . Figure 2b shows the lattice corresponding to the projected pattern structure (Table 1), where projection comes from the projection of the alphabet semilattice.

Below we formally define how the alphabet projection of a sequential pattern structure should be processed. Intuitively, every sequence in a pattern should be substituted with another sequence, by applying the alphabet projection to all its elements. However, the result can be an incorrect sequence, because ⊥ E is forbidden to be in a sequence, thus, sequences in a pattern should be "developed" w.r.t. ⊥ E , as it is explained below. Fig. 2: The projected concept lattices for the pattern structure given by Table 1.

Concept intents refer to the sequences in Tables 1 and 2.

Definition 7. Given an alphabet (E, E ), an alphabet projection ψ and a sequence s based on E, the projection of the sequence ψ(s) is the sequence s such that, si = ψ(s i ) (s i is the i-th element of sequence s).

Here, it should be noted that s can be incoherent with Definition 4, since it allows ⊥ E to be an element. For simplicity, we allow this incoherence here. Definition 8. Given an alphabet (E, E ), an alphabet projection ψ, and a pattern d ∈ D, an alphabet-projected pattern d = ψ(d), is the set of sequences obtained by the following procedure. For every sequence s ∈ d, the projection of s is computed (Definition 7) and, then, the projection of the sequence is substituted by the set of its maximal subsequences containing no ⊥. All the resulting sequences constitute the set d, and d is the set of maximal sequences in d. Example 6. {ss 6 } is an alphabet-projected pattern for the pattern {ss 10 }, where alphabet lattice projection is given in Example 5.

{ [CH, {c, d}] } is an alphabet-projected pattern for the pattern {ss 2 }, where alphabet lattice projection is given by projecting every element with medical procedure b to the element with the same hospital and with the same set procedures excluding b. The projected sequence of sequence ss 2 is [CH, {c, d}]; [ * , {}]; [ * , {d}] , but [ * , {}] = ⊥ E , and, thus, in order to project the pattern {ss 2 } the projected sequence is substituted by its maximal subsequences, i.e.

Proposition 6. Considering an alphabet (E, E ), the projection of an alphabet ψ, a sequential pattern structure (G, (D, ), δ), the procedure given by Definition 8 is monotone, contractive and idempotent.

Proof. This procedure is idempotent, since the projection of the alphabet is idempotent. It is contractive because for a pattern d, for any sequences s ∈ d, the projection of the sequence s = ψ(s) is a subsequence of s. In the Definition 8 the projected sequences should be substituted by its maximal subsequences in order to avoid ⊥ E , building the sets {s i }. Thus, s is a supersequence for any si , and, so, the projected pattern d = ψ(d) is subsumed by the pattern d.

Finally, we should show monotonicity. Given two patterns x, y ∈ D, such that x y, i.e. ∀s x ∈ x, ∃s y ∈ y : s x ≤ s y , consider the projected sequence of s x , ψ(s x ). As s x ≤ s y for some s y then for some j 0 < j 1 < j |s x | (see Definition 5)

(by the monotonicity of the alphabet projection), i.e. projected sequence preserve the subsequence relation. Thus, the alphabet projection of the pattern preserve pattern subsumption relation, ψ(x) ≤ ψ(y) (Proposition 1), i.e. the alphabet projection is monotone.

Nearly all state-of-the-art FCA algorithms can be adapted to process pattern structures. We adapted AddIntent algorithm [14], as the lattice structure is important for us to calculate stability (see the algorithm for calculating stability in [15]). To compute the semilattice operation ( , ) between two sets of sequences S = {s 1 , ...s n } and T = {t 1 , ..., t m }, S T is calculated according to Section 2.3, i.e. maximal sequences among all maximal common subsequences for any pair of s i and t j . To find all common subsequences of two sequences, the following observations is useful. If ss = ss 1 ; ...; ss l is a subsequence of s = s 1 ; ...; s n with j s i = k s +i (Definition 5: k s is the index difference from which ss is a subsequence of s) and a subsequence of t = t 1 ; ...; t m with j t i = k t + i (likewise), then for any index i ∈ {1, 2, ..., l}, ss i E (s j s i t j t i ). Thus, to find maximal common subsequences between s and t, we, first, align s and t in all possible ways, and then for every alignment we compute the resulting intersection and keep only the maximal ones.

The experiments are carried out on an "Intel(R) Core(TM) i7-2600 CPU @ 3.40GHz" computer with 8Gb of memory under the Ubuntu 12.04 operating system. The algorithms are not parallelized and are coded in C++.

The dataset considered here comes from a French healthcare system [16]. Each elements of a sequence has a "complex" nature. This dataset contains 2400 patients suffering from cancer. Every patient is described as a sequence of hospitalizations without any timestamps. The hospitalization is a tuple with three fields: (i) healthcare institution (e.g. University Hospital of Paris (CHU P aris )), (ii) reason of the hospitalization (e.g. a cancer disease), and (iii) set of medical procedures that the patient underwent. An example of a medical trajectory of a patient is [CHUP aris, Cancer, {P1, P2}]; [CHNancy, Chemo, {}]; [CHNancy, Chemo, {}] . This sequence represents a patient trajectory with three hospitalizations. It expresses that the patient was first admitted to the University Hospital of Paris (CHU P aris ) for a cancer problem as the reason, and underwent procedures P 1 and P 2 . Then he had two consequent hospitalizations in Central Hospital of Nancy (CH N ancy ) in order to do chemotherapy with no additional procedures.

For this dataset the computation of the whole lattice is infeasible. However a medical expert is not interested in all possible patterns, but rather in patterns which answer his analysis question(s). First of all, the patterns of length 1 are unlikely to be of interest for him. Thus, we use the MLP projection of length 2 or 3 taking into account the small average length of the sequences in the dataset.

For the search of patterns containing only information about reasons and medical procedures, we should project every alphabet element on the element with the same reason and the same set of procedures, but substitute hospitalization institution by the most general element in the corresponding taxonomy. Moreover, we do not want to allow reason to be empty, i.e. all such elements should be projected onto ⊥ E . In this case computation takes 18 seconds producing a lattice with around 34700 concepts. One of the stable concepts has the following intent [Cancer, {App.}]; [Ch.P rep, {}]; [Chemo, {}] , specifying that a cancer was found during the appendix removal surgery, followed by a chemotherapy. This patterns highlight a discovered fact that acute appendicitis has been shown to occur antecedent to cancer within three years because of a carcinoma in colon or rectum [17].

To find patterns revealing dependences between hospitals and reasons all the procedures should be removed from each alphabet element and elements with most general hospital and/or with most general reason should be projected to ⊥ E . The computation of the corresponding lattice takes 10 seconds, producing around 4200 concepts. [Region Lorraine, Cancer]; [Clinic in Lorraine, Chemo] is among stable concepts which is rather interesting, because the patients detected cancer somewhere in Region A but then went to exactly the same clinic for chemotherapy. It suggests that the department can lack from clinics for chemotherapy or the quality of the clinic is high.

In this paper, we present sequential pattern structures, an original specification of pattern structures able to deal with complex sequences. Projections of sequential pattern structures allow us to efficiently build concept lattices, by specifying expert demands. To be able to introduce interesting projections, their classical definition is extended. This extension allows us to introduce special projections for sequential pattern structures. The introduced projections are efficiently used for analysis of a dataset on care trajectories.

There are two main directions for future work. First, a study on properties of generalized projections within the overall framework of FCA should be carried out. Second, projections of sequential pattern structures can be deeper analyzed, for producing even more interesting and readable patterns.

The eigenvectors and eigenspaces over certain naturally ordered semirings called dioids seem to be intimately related to multi-valued extensions of Formal Concept Analysis [1]. For instance [2,3] prove that formal concepts are optimal factors for decomposing a matrix with entries in complete residuated semirings. Notice the strong analogy to the SVD, with formal concepts taking the role of pairs of left and right eigenvectors. Indeed, [4] prove that, at least on a particular kind of dioids, the idempotent semifields, formal concepts are related to the eigenvectors of the unit in the semiring. This result, however, cannot be unified with the former both for theoretical reasons, since idempotent semifields are incomplete (see below), as well as for practical reasons, since the carrier set of idempotent semifields is almost never included in [0, 1] .

A possible way forward is to develop these theories under the common framework of the L-fuzzy sets, where L is any complete lattice [5]. Such an endeavour has already been called for [6], although it remains unfulfilled, hence this paper has a two-fold aim:

1. to clarify the spectral theory over completed idempotent semifields, and 2. to take steps towards a common framework for the interpretation of L-Formal Concept Analysis as a spectral construction.

First steps have been taken in this direction with the development of a spectral theory of irreducible matrices [7] over complete idempotent semifields, whose summary we include below, but the general case, here presented, shows a more intimate relation to lattice theory.

A semiring is an algebra S = S, ⊕, ⊗, , e whose additive structure, S, ⊕, , is a commutative monoid and whose multiplicative structure, S\{ }, ⊗, e , is a monoid with multiplication distributing over addition from right and left and with additive neutral element absorbing for ⊗, i.e. ∀a ∈ S, ⊗ a = .

Let M n (S) be the semiring of square matrices over a semiring S with the usual operations. Given A ∈ M n (S) the right (left) eigenproblem is the task of finding the right eigenvectors v ∈ S n×1 and right eigenvalues ρ ∈ S (respectively left eigenvectors u ∈ S 1×n and left eigenvalues λ ∈ S) satisfying:

The left and right eigenspaces and spectra are the sets of these solutions:

Since Λ(A) = P(A t ) and U λ (A) = V λ (A t ) , from now on we will omit references to left eigenvalues, eigenvectors and spectra, unless we want to emphasize differences.

With so little structure it might seem hard to solve (1), but a very generic solution based in the concept of transitive closure A + and transitive-reflexive closure A * of a matrix is given by the following theorem: Theorem 1 (Gondran and Minoux, [8, Theorem 1]). Let A ∈ S n×n . If A * exists, the following two conditions are equivalent:

. In [7] this result was made more specific in two directions: on the one hand, by focusing on particular types of completed idempotent semirings-semirings with a natural order where infinite additions of elements exist so transitive closures are guaranteed to exist and sets of generators can be found for the eigenspacesand, on the other hand, by considering more easily visualizable subsemimodules than the whole eigenspace-a better choice for exploratory data analysis.

Specifically, every commutative semiring accepts a canonical preorder, a ≤ b if and only if there exists c ∈ D with a ⊕ c = b . A dioid is a semiring D where this relation is actually an order. Dioids are zerosumfree and entire, that is they have no non-null additive or multiplicative factors of zero. Commutative complete dioids are already complete residuated lattices. Similarly, semimodules over complete commutative dioids are also complete lattices.

An idempotent semiring is a dioid whose addition is idempotent, and a selective semiring one where the arguments attaining the value of the additive operation can be identified.

Of the semirings above, only the boolean lattice and the fuzzy semirings are complete dioids, since the rest lack the top element as an adequate inverse for the bottom in the order.

The second important feature of spectra over complete dioids, as proven in [7], is that the set of eigenvalues on complete dioids is extended with respect to the incomplete case, and it makes sense to distinguish those which are associated to finite eigenvectors, the proper eigenvalues P p (A), and those associated with non-finite eigenvectors, the improper eigenvalues P(A)\P p (A).

Moreover, as said above, the eigenspaces of matrices over complete dioids have the structure of a complete lattice. But since these lattices may be continuous and difficult to represent we introduce the more easily-represented eigenlattices L ρ (A) and L λ (A), complete finite sublattices of the eigenspaces to be used as scaffolding in visual representations.

A semiring is a semifield if there exists a multiplicative inverse for every element a ∈ S, notated as a −1 , and radicable if the equation a b = c can be solved for a. As exemplified above, idempotent semifields are incomplete in their natural order. Luckily, there are procedures for completing such structures [9] and we will not differentiate between complete or completed structures, Example 2. The maxplus R max,+ and minplus R min,+ semifields can be completed as,

In this notation we have ∀c, −∞ + c = −∞ and ∞ + c = ∞, which solves several issues in dealing with the separately completed dioids. These two completions are inverses R min,+ = R −1 max,+ , hence order-dual lattices. Indeed they are better jointly called the max-min-plus semiring R min, + max,+ .

In fact, idempotent semifields K = K, ⊕ , ⊕, ⊗ , ⊗, • −1 , ⊥, e, , appear as enriched structures, the advantage of working with them being that meets can be expressed by means of joins and inversion as a ∧ b = (a −1 ⊕ b −1 ) −1 . On a practical note, residuation in complete commutative idempotent semifields can be expressed in terms of inverses, and this extends to eigenspaces.

Given A ∈ M n (S), the network (weighted digraph) induced by

This allows us to apply intuitively all notions from networks to matrices and vice versa, like the underlying graph G A = (V A , E A ), the set of paths Π + A (i, j) between nodes i and j or the set of cycles C + A . Matrix A is irreducible if every node of V A is connected to every other node in V A though a path, otherwise it is reducible.

We will use the spectra of irreducible matrices as a basic block for that of reducible matrices: if

+ be the normalized transitive closure of A, and define the set of (right) fundamental eigenvectors of irreducible A for ρ as FEV ρ

) spectral theory for irreducible matrices, [7]). Let A ∈ M n (K) be an irreducible matrix over a complete commutative selective radicable semifield. Then:

In this paper we try and find analogue results to Theorem 2 for the reducible case. First, we completely describe the spectra with Theorem 3 in Section 3.1. Then, we provide in Section 3.2 a bottom-up construction of the eigenspaces of certain reducible matrices from that of their irreducible blocks, using from Section 2.2 a recursive scheme to render matrices over idempotent semifields into specialised Upper Frobenius Normal Forms (UFNF). Finally, we discuss our findings in Section 4 and relate them to previous approaches.

In this paper we assume familiarity with basic order notions as described in [1,10]. We only introduce notation when departing from there.

Recall that every set V with |V | = n elements and a total order ≤ ⊆ V × V is isomorphic to a lattice called the chain of n elements, V, ≤ ∼ = n . When the relation is the empty order relation ∅ ∈ V × V , it is called an anti-chain of n elements, V, ∅ ∼ = n . Lattice 1 ∼ = 1 is the vacuously-ordered singleton. Lattice 2 is the boolean lattice isomorphic to chain 2. Lattice 3 is a lattice lying at the heart of completed semifields, the 3-bounded lattice-ordered group ⊥ < e < , isomorphic to chain 3.

If set of order ideals of a poset P is O(P ), then Proposition 1 ( [10, Chap. 1]). Let P, ≤ be a finite poset. Then O(P ), ⊆ is a lattice obtained by the embedding ϕ :

Note that x ≤ y in P if and only if ↓ x ⊆↓ y in O(P ). Furthermore, O(P ) can be obtained systematically from the ordered set in a number of cases:

Proposition 2 ( [10, Chap. 1]). Let P, ≤ be a finite poset. Then 1.

Recall that a digraph (or directed graph), is a pair G = (V, E) with V a set of vertices and E ⊆ V × V a set of arcs (directed edges), ordered pairs of vertices, such that for every i, j ∈ V there is at most one arc (i, j) ∈ E . If (i, j) ∈ E then we say that "i is a predecessor of j" or "j is a successor of i", and E ∈ M n (B) is the associated relation of G. If there is a walk from a vertex i to a vertex j in G we say that "i has access to j" or j is reachable from i, i j . Hence, reachability is the transitive closure of the associated relation, = E + [11]. However, vertices j ∈ V with no incoming or outgoing arcs cannot be part of any cycle, hence j j for such nodes, so it is not reflexive, in general. ( ∩I V ) is the reflexive restriction of , that is, the biggest reflexive relation included in it.

If there is a walk from a vertex i to vertex j in G or viceversa we say that i and j are connected, i j ∨ j i. Connectivity is the symmetric closure of the reachability relation: its transitive, reflexive restriction is an equivalence relation on V G whose classes are called the (dis)connected components of G . Note that each of the (outwards) disconnected components is actually (inwards) connected. Let K ≥ 1 be the number of disconnected components of G. Then V and E are partitioned into the subsets of vertices {V k } K k=1 and arcs

On the other hand, since reachability is transitive by construction, its symmetric, reflexive restriction i j ⇔ i j ∧ j i is a refinement of connectivity called strong connectivity. Its equivalence classes are the strongly connected components of G . For each disconnected component G k , let R k be the number of its strongly connected components. If R k = 1 then the k-th component is strongly connected, otherwise just connected and composed of a number of strongly connected components itself. G is strongly connected

Given a digraph G = (V, E), the reduced or condensation digraph, G = (V , E) is induced by the set V = V / of strongly connected components, and C, C ∈ V , (C, C ) ∈ E iff there exists one arc (i, j) ∈ E for some i ∈ C, j ∈ C and we say that component C has access to C , and write C C . It is well known that G = (V , E) is a partially ordered set called a directed acyclic graph (dag).

Given a matrix A ∈ M n (S), its condensation digraph is the partial order of strong connectivity classes G A = (V A , E A ), as in Figure 2b in Example 4, of its associated digraph G A = (V A , E A ) . This can be proven by means of an Upper Frobenius Normal Form (UFNF) [12], a structure for matrices that we intend to specialise and use as a scheme for structural induction over reducible matrices.

In the following, for a set of indices V x ⊆ n we write P (V x ) for a permutation of it, and E xy is an empty matrix of conformal dimension most of the times represented on matrix patterns as elliptical dots.

Lemma 1 (Recursive Upper Frobenius Normal Form, UFNF). Let A ∈ M n (S) be a matrix over a semiring and G A its condensation digraph. Then, 1. (UFNF 3 ) If A has zero lines it can be transformed by a simultaneous row and column permutation of V A into the following form:

where: either A αβ or A αω or both are non-zero, and either A αω or A βω or both are non-zero. Furthermore, P 3 is obtained concatenating permutations for the indices of simultaneously zero columns and rows V ι , the indices of zero columns but non-zero rows V α , the indices of zero rows but non-zero columns V ω and the rest V β as P 3 = P (V ι )P (V α )P (V β )P (V ω ) . 2. (UFNF 2 ) If A has no zero lines it can be transformed by a simultaneous row and column permutation P 2 = P (A 1 ) . . . P (A k ) into block diagonal UFNF

where {A k } K k=1 , K ≥ 1 are the matrices of connected components of G A .

A is reducible with no zero lines and a single connected component it can be simultaneously row-and column-permuted by P 1 to

where A rr are the matrices associated to each of its R strongly connected components (sorted in a topological ordering), and P 1 = P (A 11 ) . . . P (A RR ) .

The particular choice of UFNF is clarified by the following Lemma, since the condensation digraph will prove important later on: Lemma 2 (Scheme for structural induction over reducible matrices). Let A ∈ M n (S) be a matrix over an entire zerosumfree semiring and G A its condensation digraph. Then:

Note that for A in UFNF 1 , G A may be any connected ordered set.

The following lemma clarifies the order relation between eigenvectors in ordered semimodules, Lemma 3. Let X be a naturally-ordered semimodule. 1. Vectors with incomparable supports are incomparable. 2. If X is further complete, vectors with incomparable saturated supports are incomparable.

Proof. Let v and w be two vectors in X . Comparability of supports lies in the ⊆ relation: if supp(v) supp(w) then supp(v) ⊆ supp(w) and supp(w) ⊆ supp(v) . Therefore from supp(v) ∩ supp(w)

Claim 2 is likewise argued on the support taking the role of n, and the saturated support taking the role of the original support.

Let A ∈ M n (S) be a matrix and G A be its condensation digraph. Consider a class C r ∈ V A and call

the sets of upstream, downstream and parallel vertices for C r , respectively. Using permutation P r = P (V u )P (C r )P (V p )P (V d ) we may suppose a blocked form of A(C r ) like the one in Fig. 1 without loss of generality. Notice that any of V u , V d or V p may be empty. However, if V u (resp. V d ) is not of null dimension, then A ur (resp. A rd ) cannot be empty. Proposition 3. Let A ∈ M n (K) be a matrix over a complete commutative selective radicable semifield with C + A = ∅. Then a scalar ρ > ⊥ is a proper eigenvalue of A if and only if there is at least one class in its condensation

Fig. 1: Matrix A focused on C r , A(C r ) = P r t ⊗ A ⊗ P r and associated digraph. The loops at each node, consisting of (possibly empty) A uu , A rr , A pp , A dd are not shown.

Proof. The proof, for instance, in [8] extends even to ρ = ,.

The proper spectrum is clarified by: Lemma 4. Let A ∈ M n (S) be a reducible matrix over a complete radicable selective semifield. Then, there are no other finite eigenvectors in V ρ (A) contributed by Ãρ than those selected by the critical circuits in

Proof. If ρ = µ ⊕ (A rr ), from Proposition 3 we see that the finite eigenvectors mentioned really belong in V ρ (A). If ρ > µ ⊕ (A rr ) then ( Ãρ rr )

ii < e = ( Ãρ rr ) * ii hence the columns selected by C r do not generate eigenvectors. If ρ < µ ⊕ (A rr ) then ( Ãρ rr )

+ ij = and whether those classes with cycle mean ρ are upstream or downstream of C r the only value that is propagated is , hence the eigenvectors are all saturated.

Theorem 3 (Spectra of generic matrices). Let A ∈ M n (D) be a reducible matrix over an entire zerosumfree semiring. Then,

and no other non-null proper eigenvalues may exist by Lemma 4. ⊥ is only proper when zc(A) = ∅ hence claims 2a and 2b follow.

Translating to UFNF terms: Corollary 1. Let A ∈ M n (K) be a matrix over a complete selective radicable semifield with C + A = ∅. Then P(A) = K\{⊥} and

Proof. If A is irreducible or in UFNF 1 or UFNF 2 it has no empty columns or rows. This can only happen in UFNF 3 in which case the result follows from Theorem 3.

Since this solves entirely the description of the spectrum, only the description of the eigenspaces is left pending.

In this section we offer an instance of how the UFNF can be used to obtain, inductively, the spectrum of reducible matrices.

If for every parallel condensation class C p ⊆ V A in A(C r ) illustrated in C r of Fig. 1 A up = E up or A pd = E pd or both, then A is in UFNF 1 with a single connected block. In this case, we can relate the order of the eigenvectors to the condensation digraph: define the support of a class supp(C) as the support of any of the non-null eigenvectors it induces in A. Lemma 5. Let A ∈ M n (S) be a matrix in UFNF 1 over a complete zerosumfree semiring. Then, for any class

Proof. Since A rr is irreducible, if ρ = µ ⊕ (A rr ) then for any v r ∈ V ρ (A rr ) we have that supp(v r ) = V r , hence V r ⊆ supp(C r ) . Also, since S is complete and zerosumfree ( Ãρ ) + rr exists and is full [7]. Since ( Ãρ )

ur must have a full column for any C lr ∈↓ C r meaning precisely that C r is downstream from C lr , the product ( Ãρ )

+ rr for the nodes in C lr is non-null and V lr ⊆ supp(C r ) .

Lemma 5 establishes a bijection between the supports of condensation classes and downsets in G A which is actually an isomorphism of orders, Proposition 4. Let A ∈ M n (K) be a matrix over a commutative complete selective radicable semifield admitting an UFNF 1 . Then

is the unique saturated eigenvector, since sat-supp ( v) = supp( v) = supp(C), and the bijection follows. By Lemma 3, claim 2 the order relation between classes is maintained between eigenvectors, whence the order isomorphism in claim 2.

For every finite ρ ∈ P p (A) we define the critical nodes

This definition absorbs two cases, actually, Lemma 6. Let A ∈ M n (K) be a matrix over a commutative complete selective radicable semifield admitting an UFNF 1 . Then, 1. for

Proof. If ρ ∈ P(A)\P p (A), then for all ρ ∈ K, δ −1 ρ (ρ ) = . By Proposition 4 claim 1 follows as we range ρ ∈ P p (A) . Similarly, when ρ ∈ P p (A), those classes whose ρ = ρ supply a single saturated eigenvector. However, if ρ = ρ, then δ −1 ρ (ρ ) = e obtains the (partially) finite fundamental eigenvectors FEV 1,f ρ (A), the saturated eigenvectors of which cannot be considered fundamental, since they can be obtained from FEV 1,f ρ (A) linearly, and will not appear in FEV 1 ρ (A). Claim 3 is a corollary of the other two. Call V (A) = FEV 1, (A) K the saturated eigenspace of A , then Corollary 2. Let A ∈ M n (K) be a matrix over a commutative complete selective radicable semifield admitting an UFNF 1 . Then, 1. For ρ ∈ P(A), V (A) ⊆ V ρ (A) . 2. For ρ ∈ P(A)\P p (A), furthermore,V (A) = V ρ (A) .

Proof. Since we have FEV 1, (A) ⊆ V ρ (A), then V (A) ⊆ V ρ (A) . For ρ ∈ P(A)\P p (A), FEV 1 ρ (A) = FEV 1, (A) by Lemma 6, so claim 2 follows.

Hence, V (A) provides a common "scaffolding" for every eigenspace, while the peculiarities for proper eigenvalues are due to the finite eigenvectors. Also, since V (A) is a complete lattice, FEV 1, (A) ⊆ V (A) is actually a lattice embedding, Proposition 5. Let A ∈ M n (K) be a matrix over a commutative complete selective radicable semifield admitting an UFNF 1 . Then 1. For ρ ∈ P(A)\P p (A),

In fact, the generation process may proceed on only a subsemiring of K which need not even be complete. For instance, we may use any of the isomorphic copies of 2 embedded in K, for instance {⊥, k} ∼ = 2, with k = ⊥ . Since the number of saturated eigenvectors is finite, being identical to the number of condensation classes, we only have to worry about binary joins and

, and Corollary 4 ensures that no finite vectors are missing. And dually for left eigenspaces. This actually proves that FEV 1 ρ (A) is join-dense in V ρ (A). As already mentioned, V ρ (A) is a hard-to-visualize semimodule. An eigenspace schematics is a modified order diagram where the saturated eigenspace is represented in full but the rays generated by finite eigenvalues {κ ⊗ ( Ãρ )

r , ρ = µ ⊕ (A rr )} are drawn with discontinuous lines, as in the examples below.

We are now introducing another representation inspired by (7): we define the (left) right eigenlattices of A for (λ ∈ Λ(A)) ρ ∈ P(A) as

Example 3 (Spectral lattices of irreducible matrices). Since irreducible matrices are in UFNF 1 with a single class, FEV 0 µ⊕(A) (A) = FEV 1 µ⊕(A) (A). For ρ ∈ P(A)\P p (A) we have FEV 0, (A) = { n }, whence G A ∼ = 1 and V (A) = {⊥ n , n } ∼ = 2. For ρ ∈ P p (A), ρ < , as proven in [7], V ρ (A) is finitely generable from FEV 0 ρ (A), but the form of the eigenspace and eigenlattice for Λ p (A) = {µ ⊕ (A)} = P p (A) depends on the critical cycles and the eigenvectors they induce.

Example 4. Consider the matrix A ∈ M n (R max,+ ) from [13, p. 25.7, example 2] in UFNF 1 depicted in Fig. 2.(a). The condensed graph G A in Fig. 2 Note that node 4 does not generate an eigenvector in either spectrum, since it does not belong to a critical cycle. Therefore Λ p (A 3 ) = P p (A 3 ) = {2, 1, 0, −3} each left eigenspace is the span of the set of eigenvectors chosen from distinct critical cycles for each class of

, and V µ4 (A) = ( Ã3 µ4 ) + •8 -as described by the column vectors of Fig. 2

The saturated eigenspace is easily represented by means of an order diagram-Hasse diagram-as that of Fig. 2.(e). Note how it is embedded in that of any proper eigenvalue like ρ = 2 in Fig. 2.(f). Since the representation of continuous eigenspaces is problematic, we draw schematics of them, as in Fig. 2.(f). Fig. 2.(g) shows a schematic view of the union of the eigenspaces for proper eigenvalues

In this paper, we have discussed the spectrum of reducible matrices with entries in completed idempotent semifields. To the extent of our knowledge, this was pioneered in [14] and both [7] and this paper can be understood as systematic explorations to try and understand what was stated in there. For this purpose, the consideration of particular UFNF forms for the matrices has been crucial: while the description in [14] is combinatorial ours is constructive.

The usual notion of spectrum as the set of eigenvectors with more than one (null) eigenvector appears in this context as too weak: when a matrix has at least one cycle then all the values in the semifield (except the bottom ⊥) belong to the spectrum. If the matrix has at least one empty column (resp. empty row) and a cycle then all of the semifield is the spectrum. Rather than redefine the notion of spectrum we have decided to introduce the proper spectrum as the set of eigenvalues with at least one vector with finite support.

Regarding the eigenspaces, we found not only that they are complete continuous lattices for proper eigenvalues, but also that they are finite (complete) lattices for improper eigenvalues. Looking for a device to represent the information within each proper eigenspace we focus on the fundamental eigenvectors of an irreducible matrix for each eigenvalue: those with unit values in certain of their coordinates. The span of those eigenvectors by the action of the 3-bounded lattice-ordered group generates the finite eigenlattices. Interestingly, since improper eigenvectors only have non-finite coordinates, their span by the 3-blog is exactly the same finite lattice as their span by the whole semifield itself.

With these building blocks it is easy to build finite lattices for reducible matrices of any UFNF description, as exemplified above. We believe this will be a useful technique to understand and visualize the concept lattices of formal contexts with entries in an idempotent semifield and other dioids.

The fundamentals of mathematical morphology (initiated by G. Matheron [18] and J. Serra [22]), are in the set theory, the integral geometry and the lattice algebra. This methodology is used in the recent years in general contexts related to activities as the information extraction in digital images, the noise elimination or the pattern recognition.

The generalization of this theory, in order to consider fuzzy subsets as objects, was given in [5-9, 16, 17] using L-fuzzy sets as images and structuring elements, which was called fuzzy morphological image processing.

On the other hand, the fuzzy property-oriented concept lattice framework [15] arises as a fuzzy generalization of Rough Set Theory and in which a set of objects and a set of attributes are assumed, following the view point of Formal Concept Analysis. This theory has been considered to solve fuzzy relation equations [12] and important results, in order to obtain the whole set of solutions, are given.

Recently, both theories, fuzzy mathematical morphology and fuzzy propertyoriented concept lattice, have been related [1], extending the initial relation given in [2].

In mathematical morphology, the usual procedure is, given a structuring image, to obtain the dilation and the erosion from an initial image. But what happen if we lose the original image or, simply, we have not got it because we only know its corresponding dilation or erosion, how can the original image be obtained? This paper studies the problem of objects retrieval in the framework of mathematical morphology. It is usual that there is noise in the transmission of information or, in several cases, it is easier to send a kind of image than another one. Hence, the received object is not equal to the original one. Note that this problem is also related to other settings, such as object recognition.

Specifically, we focus on solving the problem of obtaining the original object A from another one received B, assuming a structuring image and that B is the dilation or the erosion of the original image A. For that, this problem will be written as a fuzzy relation equation and the relationship introduced in [1] and the results given in [12] will be used to solve it.

This section recalls the fuzzy property-oriented concept lattice framework [15], fuzzy mathematical morphology [5-9, 16, 17], the relationship beetween them, introduced in [1], and fuzzy relation equations [21].

In this framework a complete residuated lattice (L, ∨, ∧, * , I, 0, 1, ≤ ? ) is considered as algebraic structure. Moreover, a fuzzy (formal) context is assumed, (X, Y, R), where R : X × Y → L is a fuzzy relation between the sets X and Y , where X can be interpreted as a set of objects and Y as a set of properties (attributes).

Given a fuzzy context (X, Y, R), two mappings R ∃ : L X → L Y and R ∀ : L Y → L X can be defined as:

for all A : X → L, B : Y → L, x ∈ X and y ∈ Y , where I is the residuated implication associated with the conjunctor * . Examples of these operators are given in [3,19]. As a first result, the pair (R ∃ , R ∀ ) forms an isotone Galois connection [13]. Therefore, a property-oriented concept (or, a concept based on rough set theory)

The set of all property-oriented concepts of (X, Y, R) is denoted by P(X, Y, R) and it is a complete lattice [15], which is called the property-oriented concept lattice of (X, Y, R) (or, the concept lattice of (X, Y, R) based on rough set theory) [15]. For that isotone Galois connection (R ∃ , R ∀ ) and lattice P(X, Y, R) interesting properties have been proven, e.g., in [3,4,13,15]. This relation provides that the dilation and erosion have the properties of the isotone Galois connection (R ∃ , R ∀ ). The following result shows the connection between the outstanding morphological elements and the L-fuzzy propertyoriented concepts.

Theorem 1. Let S ∈ L X and its associated relation R S ∈ L X×X , the following statements are equivalent:

1. The pair (A, B) ∈ L X × L X is an L-fuzzy property-oriented concept of the context (L, X, X, R S ).

Systems of fuzzy relation equations have been widely studied, for instance in [10,11,20]. This section recalls these kind of systems for which a residuated lattice (L, ∨, ∧, * , I, 0, 1, ≤) is fixed.

A system of fuzzy relation equations with sup- * -composition (SFRE * ), is the following system of equations

where R ∈ L U ×V is an unknown fuzzy relation, A 1 , . . . , A n ∈ L U and B 1 , . . . , B n ∈ L V . Its counterpart is a system of fuzzy relation equations with inf-I-composition (SFREI), that is,

considered with respect to an unknown fuzzy relation R ∈ L U ×V and the fuzzy subsets A * 1 , . . . , A * m ∈ L V and D 1 , . . . , D m ∈ L U . Given the universes U = {u 1 , . . . , u m } and V = {v 1 , . . . , v n }, an unknown fuzzy relation R ∈ L U ×V and two arbitrarily chosen fuzzy subsets of respective universes A 3) can be written as

Consequently, for each v ∈ V , we obtain a column of R, thus, solving n SFRE * systems, we will obtain the unknown relation. In order to obtain a SFREI system where the considered universes U , V and the unknown fuzzy relation R ∈ L U ×V are as in the previous system, an element of U is fixed, u ∈ U , fuzzy subsets A * 1 , . . . , A * m ∈ L V , D 1 , . . . , D m ∈ L U are assumed, such that A * j (v i ) = a ij for i ∈ {1, . . . , n}, j ∈ {1, . . . , m}, R(u, v i ) = y i and D j (u) = d j . Therefore, System (4) can be written as

Therefore, for each u ∈ U , we obtain a row of R, thus, solving m SFRE→ systems, the unknown relation will be obtained.

This section introduces an application of fuzzy relation equation to objects retrieval in the fuzzy mathematical morphology setting. From the relationship between fuzzy mathematical morphology and fuzzy property-oriented concept lattice, recalled in Section 2.3, and the relationship between fuzzy property-oriented concept lattice and fuzzy relation equations [12], we will solve the problem of obtaining the original object A : X → L from another one received B : X → L and a fixed structuring image S : X → L. Specifically, given an image B : X → L, we can consider a structuring image S : X → L and ask if there exists A : X → L such that δ S (A) = B and, if there exists, how to obtain it. Analogously, for each image A : X → L, we can ask if there exists B : X → L such that ε S (B) = A, for a structured image S, and, if there exists, how to obtain it.

First of all, we will write this mathematical morphology problem in terms of fuzzy relation equations.

Given a finite subset X 0 = {x 1 , . . . , x n } of X, an image B : X 0 → L and a structuring image S : X 0 → L, if we want to obtain an image A : X 0 → L such that δ S (A) = B, then we need to solve the following system:

in which B(x i ) = b i , for all i ∈ {1, . . . , n}.

Analogously, given an image A : X 0 → L and a structuring image S : X 0 → L, obtaining an image B : X 0 → L, such that ε S (B) = A, is equivalent to solve the system:

Next, several results will be presented in the fuzzy mathematical morphology framework, based on the properties introduced in [12]. The first one is about the solvability of Systems ( 7) and (8).

Theorem 2. Given a finite subset X 0 ⊆ X and B ∈ L X0 , defined by B(x i ) = b i , for each i ∈ {1, . . . , n}. System (7) can be solved if and only if B is S-open in X 0 . In that case, ε S (B) ∈ L X0 is the greatest solution.

Analogously, given A ∈ L X0 , defined by A(x i ) = a i , for each i ∈ {1, . . . , n}. System (8) can be solved if and only if A is S-closed in X 0 . In that case, δ S (A) ∈ L X0 is the least solution.

As a consequence, if the values b i satisfy that δ S (A)(x i ) = b i ∈ L, for all i ∈ {1, . . . , n}, then we can find a solution A ∈ L X0 of System (7). Analogously, if ε S (B)(x i ) = a i ∈ L is known for all i ∈ {1, . . . , n}, then we can find B ∈ L X0 solving System (8).

The second result relates the independent term and greatest solution to a property-oriented concept.

Theorem 3. System (7) can be solved if and only if (ε S (B), B) is an L-fuzzy property-oriented concept of the context (L, X 0 , X 0 , R S ), where B ∈ L X0 is defined by B(x i ) = b i , for all i ∈ {1, . . . , n}.

Similarly, System (8) can be solved if and only if (A, δ S (A)) is an L-fuzzy property-oriented concept of the context (L, X 0 , X 0 , R S ), where A ∈ L X0 is defined by A(x i ) = a i , for all i ∈ {1, . . . , n}. Now, we present an application to digital signals.

Example 1. Let us assume the set X = {0, 1, 2, . . . , 21, 22} ⊆ Z, the linear structure L = {0, 0.1, 0.2, . . . , 0.9, 1}, the mapping B : X → L, which is represented in Figure 1, and the structuring set S = {−1, 0, 1}. Note that B can be interpreted as a 1-D discrete signal. From this environment a system of fuzzy relation equations similar to System (7) is considered, in order to obtain a signal A with dilation B.

First of all, we need to check if this system has a solution. Hence, we consider the context (L, X, X, R S ), where the fuzzy relation R S ⊆ X × X is defined, for each (x, y) ∈ X × X, as

, by Theorems 2 and 3, we have that the considered system has, at least, one solution and the greatest solution A g is ε S (B), which is given in Figure 2 and defined as

for all x ∈ X. Moreover, (A g , B) is a fuzzy property-oriented concept.

It is clear, in Example 1, that the original signals A may not be the greatest solution, but another one of the proposed system. In order to obtain the whole set of solutions the following result is introduced and can be proven from [12].

is the original object, such that δ S (A) = B, then either A < A ≤ ε S (B) for some (A , B ) lower neighbour of (ε S (B), B) in P(X 0 , X 0 , R S ); or A < ε S (B) and A is incomparable with A , for all (A , B ) lower neighbour of (ε S (B), B) in P(X 0 , X 0 , R S ).

Analogously, given an S-closed object A ∈ L X0 , if B ∈ L X0 is the original object, such that ε S (B) = A, then either δ S (A) ≤ B < B for some upper neighbour (A , B ) of (A, δ S (A)) in P(X 0 , X 0 , R S ); or δ S (A) < B and B is incomparable with B , for all (A , B ) upper neighbour of (A, δ S (A)) in P(X 0 , X 0 , R S ).

Therefore, Theorem 4 can be applied in order to obtain the whole set of solutions of the system given in Example 1. However, we need to remark that, since straightforward ε S (B) ≤ B, we have that A g is the solution closest to B. Hence, considering the greatest solution can be a good election.

The following example focus on images retrieval.

Example 2. We consider a two dimensional pixelated image. Hence, X = Z 2 , L = {0, 1} and the mappings A : Z 2 → L are interpreted as two dimensional images. The elements of X are denoted as

In this case, the image B : Z 2 → L, given in Figure 3, is obtained and we want to retrieve the original image or a good approximation. The structuring binary image S is the unit ball:

given in Figure 4. Therefore, by the previous results, the greatest solution A g : Z 2 → L, associated with B and the structuring image, is the best approximation of B. That is, the image closer to B. This image is given in Figure 5 and it is defined as: there exists (y 1 , y 2 ) ∈ Z 2 such that B((y 1 , y 2 )) = 0 and (y 1 − x 1 ) + (y 2 − x 2 ) ≤ 1 1 otherwise By Theorem 3, the pair (A, B) is a property-oriented concept of the context ({0, 1}, Z 2 , Z 2 , R S ). However, in this case, the considered original image is not the greatest solution A g but a solution less than it. This is given in Figure 6. This is not a problem, but it shows that it is also interesting to compute the whole set of solutions. Theorem 4 provides an interesting mechanism to get all the solutions of Systems ( 7) and ( 8), although another more operative results will be studied in the future.

In mathematical morphology, the usual procedure is, given a structuring image, to obtain the dilation and the erosion of an original image. This paper have We have shown that this problem is associated with solving systems of fuzzy relation equations. Therefore, the results given in [12] and the relationship introduced in [1] have been used to obtain the original image or a good approximation. Moreover, we have introduced some results focus on searching the whole set of possible original images.

In the future, more properties and applications will be studied, for instance in object recognition.

Melisachew Wudage Chekol, Mehwish Alam, and Amedeo Napoli LORIA (INRIA, CNRS, and Université de Lorraine) France {melisachew.chekol,mehwish.alam,amedeo.napoli}@inria.fr Abstract. The description logic EL has been used to support ontology design in various domains, and especially in biology and medicine. EL is known for its efficient reasoning and query answering capabilities. By contrast, ontology design and query answering can be supported and guided within an FCA framework. Accordingly, in this paper, we propose a formal transformation of ELI (an extension of EL with inverse roles) ontologies into an FCA framework, i.e. KELI, and we provide a formal characterization of this transformation. Then we show that SPARQL query answering over ELI ontologies can be reduced to lattice query answering over KELI concept lattices. This simplifies the query answering task and shows that some basic semantic web tasks can be improved when considered from an FCA perspective.

Relying on Semantic Web (SW) languages and principles, several ontologies have been created in various domains, especially, in biology and medicine. In addition to that, since the conception of linked data publishing principles, over 295 linked (open) datasets have been produced 1 . Querying these data is mainly done through the W3C recommended query language SPARQL2 .

In parallel, knowledge discovery in data represented by means of objects and their properties can be done using formal concept analysis (FCA) [9]. Concept lattices can reveal hidden relations within data and can be used for organizing and classifying data. A survey of the benefits of FCA to SW and vice versa has been proposed in [14]. As mentioned in that paper, a few of these benefits ranges from knowledge discovery, ontology completion, to computing subsumption hierarchy of least common subsumers. Additionally, studies in [7] and [12] are based on FCA for managing SW data while finite models of description logics (as EL) are explored in [3,4]. All these studies propose methods to use FCA in the analysis of SW data. Nevertheless, none of them offer a precise way of representing SW data within a formal context. We deem it necessary to provide mathematically founded methods to formalize the representation and the analysis of SW data.

In this work, we focus particularly on ELI (an extension of EL with inverse roles) ontologies. EL is one of OWL 2 profiles (OWL 2 EL). In fact, OWL 2 EL is used mainly for designing large biomedical ontologies such as SNOMED-CT3 , and the NCI thesaurus 4 . A common feature of these ontologies is that they possess large concept hierarchies that can be queried with SPARQL. Answering SPARQL queries is done by binding variables of the query into terms of the queried ontology. However, including inferred data in the query answers requires either a reasoner to infer all implicit data or query rewriting using regular expression patterns (that enable navigation in a hierarchy) [10]. The latter obliges the user to know the nuts and bolts of SPARQL. To overcome these difficulties, we reduce SPARQL query answering in ELI ontologies into query answering in concept lattices along with the transformation of the queried ontology into a formal context. Querying a concept lattice appears to be a less complex task than using SPARQ. Further, the lattice organization, i.e., partial ordering, can help understanding the relations between data and visualization of SW data.

Overall, in this paper, we work towards (i) a formal characterization of the translation of ontologies into a formal context, (ii) minimizing the difficulty of SPARQL query answering over ontologies into LQL (Lattice Query Language) query answering over concept lattices, and finally (iii) providing organization of SPARQL query answers with the use of concept lattices.

Outline: after presenting the basics of ELI, SPARQL and FCA ( §2), we show how to transform ELI ontologies into formal contexts ( §3). We then present a query language for concept lattices called LQL ( §4). Therefore, SPARQL query answering over ELI ontologies can be reduced to LQL query answering over K ELI concept lattices ( §5). Finally, we present the related works ( §6) along with a summary of concluding remarks ( §7).

In this section, we provide a very brief and intuitive introduction of the description logic ELI and FCA. For a detailed discussion, we refer the readers to [11,2,9,6].

In to arbitrary class descriptions is defined inductively [2].

SPARQL is a W3C recommended query language [13] based on simple graph patterns. It allows variables to be bound to components in the queried graph. In addition, operators akin to relational joins, unions, left outer joins, selections, and projections can be combined to build more expressive queries. Queries are formed from query patterns which in turn are defined inductively from path patterns, i.e., tuple t ∈ UBV × e × UBLV, with V a set of variables disjoint from UBL (URIs, Blank nodes and Literals -are used to identify values such as strings, integers and dates.), and e is regular path expression. Path patterns grouped together using operators AND (.) and UNION form query patterns. Definition 1. A query pattern q is inductively defined as:

A SPARQL SELECT query can be formed according to the following syntax: SELECT W FROM O WHERE {q}. The FROM clause identifies the queried ontology O on which the query will be evaluated, WHERE contains a query pattern q that the query answers should satisfy and SELECT singles out the answer variables W ∈ V from the query pattern. For this work, we consider only AND and UNION SPARQL queries.

A formal context represents data using objects, attributes, and their relationships. Formally, it is a triple K = (G, M, I) where G a set of objects, M a set of attributes, and I ⊆ G × M is a relation. A derivation operator ( ) is used to compute formal concepts of a context. Given a set of objects, the operator derives common attributes of these objects and vice versa. A set of formal concepts ordered with the set inclusion relation form a concept lattice [6].

In the next section, we show the transformation of ELI ontologies into formal contexts.

In the following, we introduce some terms and notions that we use. Materialization (closure) refers to computing the deductive closure of an ontology (alternatively, making all implicitly stored data explicit by using inference) [15]. Ontology completion [5] -refers to computing the closure of the ontology and adding additional instances by following class inclusions in the TBox (for instance, if Actor is a subclass of Artist and the instance Tom is an Actor, add another instance who is not an Actor but is an Artist. In this case, if an instance is not known, one can use anonymous resource to identify the unknown instance). Loss of semantics-the transformation of an ontology into a formal context results in loss of semantics if the context mixes TBox (schema axioms) and ABox (instance) data and if the concept lattice obtained from the formal context does not maintain the class hierarchy. Before presenting how a ELI ontology can be transformed into a formal context, we motivate our approach with an example. Starting with Example 1, one can ask whether it is possible to obtain a formal context from the ontology O while maintaining its semantics. The problem here is that DLs and FCA work on different assumptions, i.e, while DL languages are based on the open world assumption (OWA), FCA relies on the closed world assumption (CWA). The former permits to specify only known data whereas the later demands all data should be explicitly specified. To slightly close the gap between these two worlds:

-one can generate the formal context from the closure of the ontology. However, this approach fails when it is not possible to compute the closure of the ontology as this is the case for ontologies created from a DL language equipped with negation and disjunction constructs5 , and -before transforming the ontology into a formal context, complete the ontology. A drawback of the second approach is that it adds unnecessary data, consequently, giving unwanted results when querying. To this end, our main objective is to come up with an approach which transforms an ontology into a formal context while maintaining the semantics. Accordingly, a formal context corresponding to the ontology in Example 1 has an associated lattice that looks like the one in Figure 1a. From this onwards, when we speak of this lattice, we refer to it as the target lattice. The target lattice maintains the semantics because: the class hierarchy of the ontology (TBox) is the same as that of the lattice, and the instance (ABox) and schema (TBox) part of the ontology are treated separately as discussed in Section 3.2.

In the following, we provide various formal contexts associated with the ontology in Example 1. For the sake of readability, we shorten concept and individual names as: ActorsFromNewYork (AFNY), FilmProducer (Prd), Actor (Act), Artist (Art), Person (Per), and tomCruise (tC). Consider the following transformations:

Naive approach: materialized ABox AFNY Prd Act Art Per

This formal context is obtained from the materialized ABox of the ontology. It does not include subclass relations as they can be acquired using attribute exploration [9]. But unfortunately, the resulting lattice considers all the attributes to be equivalent, implying loss of semantics, as it can be seen from the lattice in Figure 2b.

Direct approach: materialized ABox and TBox 2a. As it can be seen, it does not maintain the semantics because the concept hierarchy is different from that of our target lattice (in Figure 1a). In other words, the concept hierarchy of the concept lattice is different from that of the ontology (in Example 1). Everything is mixed: attributes are also objects and vice versa. Obviously, it is possible to find several other ways of transforming an ontology into a formal context. To avoid any semantic loss, we propose an another approach, where we separately manage the transformation of ABox and TBox assertions. In FCA, attribute exploration is used to discover implicit knowledge. In that, given a concept lattice, a domain expert is asked a series of questions to produce implications that correspond to DL like inclusion axioms. Ontologies contain instance and schema data, where the latter is similar to implications of concept lattices. Hence, when transforming, individuals in the ABox to become objects and concept names to become attributes, besides, assertions in the ABox are transformed into relations. Additionally, class inclusions of the TBox become background implications. The overall transformation pro-cedure leads to a formal context with respect to existing knowledge (this is also known as background implications according to [8]). This procedure is formally described in definition 2.

To transform a ELI knowledge base KB = T , A into a formal context K = (G, M, I), the schema axioms in the TBox become background implications L((G, M, I)) and the ABox assertions become objects, attributes and relations. To elaborate, in K, individuals in the ABox constitute objects G, class names in the ABox and TBox yield attributes in M , and ABox assertions create relations between objects and attributes I ⊆ G × M . Here, we consider acyclic TBoxes so as to avoid class names becoming objects in a context.

Construction of concept lattices: there are several algorithms that can compute concept lattices associated with a formal context. Some of these are discussed in the literature [9,6] and have also been implemented. They work on an empty implication base. Thus, most are not suitable for contexts with background implications. In [8], the author provides an algorithm for attribute exploration with background implications. This technique can be employed for our purpose. As a result, the concept lattice associated with the formal context and background implications of Example 2 is depicted in Figure 1b.

Next we show that concept lattices associated with ELI ontologies can be queried by LQL -lattice query language.

4 Querying Concept Lattice SPARQL query answering over ELI ontologies can be considered as lattice query answering over K ELI concept lattices. To do this, we need to introduce a query language for concept lattices. Each node in a lattice can be seen as a query formed by a conjunction of: a concept intent and a concept extent. Intuitively, querying concept lattices amounts to fetching the objects given a set of attributes as query constants, alternatively, fetching the attributes given a set of objects as query constants or terms. Query terms can be connected using the logical operators: AND and OR to form a complex term. A term is either a set of objects called object term (OT) or a set of attributes called attribute term (AT). Based on the definitions of object and attribute terms, we introduce LQL queries. In this paper, we do not address the problem of negation in the query (and thus set difference).

Definition 4 (LQL -Lattice Query Language). Given an object term OT, an attribute term AT, and variables x, y ∈ V where V is a finite set of variables, an LQL query can take the following forms: q(y) = (OT, y); q(x) = (x, AT); q() = (OT, AT ) q(y), q(x), and q() do not necessarily correspond to formal concepts, only when OT and AT are closed sets. If OT is a closed set in q(y) = (OT, y), then y corresponds to the intent associated with OT. The same thing happens with x when AT is a closed set in q(x) = (x, AT). For evaluating x and y in every possible case we do the following:

-if OT = {g}, then y = {g} , i.e., all attributes that are associated with the object g.

Similarly, the evaluation of q(x) = (x, AT) is given as follows:

-if AT = {m}, then x = {m} , i.e., all objects that are associated with the attribute m.

Finally, the evaluation of q() = (OT, AT) is:

-true if OT = AT or AT = OT and false otherwise. -For q 1 (x) = (x, {actor} AND {comedian} AND {writer}), we have x = {JerrySeinf eld}. -q 2 (x) = (x, {writer} OR {director}), we have x = {DavidSchwimmer, W illSmith, JerrySeinf eld}. -q 3 (y) = ({JustinT imberlake} AND {W illSmith}, y), we have y = {actor, musician}. -q 4 (y) = ({DavidSchwimmer} OR {JustinT imberlake}, y), we have y = {actor, director, musician}.

The complexity of answering LQL queries is polynomial in the size of the formal context, i.e., O|(G, M, I)|. The advantage of LQL over SPARQL is that, it allows to compute the least upper bound and greatest lower bound of query answers. We now present one important part of this work which is reducing SPARQL query answering over ELI ontologies into LQL query answering over K ELI concept lattices.

Recently, SPARQL has been extended with different entailment regimes and regular path expressions 6 . The semantics of SPARQL relies on the definition of basic graph pattern matching that is built on top of simple entailment [10]. However, it may be desirable to use SPARQL to query triples entailed from subclass, subproperty, range, domain, and other relations which can be represented using DL schema languages such as ELI. The SPARQL specification defines the results of queries based on simple entailment. The specification also presents a general parametrized definition of graph pattern matching that can be expanded to other entailments beyond simple entailment. Query answering under an entailment regime can be achieved via: (1) materialization (computing the deductive closure of the queried graph), (2) rewriting the queries using the schema, and

(3) hybrid (combining materialization and query rewriting) [10]. SELECT ?x WHERE {? x a A r t i s t . }

Under simple entailment evaluation of a SPARQL query, the answers of Q over O is empty, i.e., Q(O) = ∅. For the reason that, simple entailment is based on graph matching which requires the variable ?x in the query to be bound with a term in the graph. Since there is no term where it can be bound to, the result is empty. However, under higher entailment regimes (such as the RDFS entailment [10]) the result of Q is non-empty because inferred instances obtained through reasoning are taken into account for computing the answers. To get a non-empty answers for the above query, one can use one of the following approaches:

1. Materialization: involves all implicit data to be computed before the evaluation of the query. This can be done by using a DL reasoner. Consequently, in Example 1, the materialization of O is O . Thus, the evaluation of

Query rewriting: is the task of converting a SPARQL query into one that involves schema axioms. It can be done using SPARQL property paths (a.k.a. regular path expressions). For instance, the above query can be rewritten as:

SELECT ?x WHERE {? x a/ * A r t i s t . }

This query Q selects all instances of Artist and that of its subclasses by navigating through the subclass relation ( * ). The rewriting can be evaluated over O to obtain Q (O) = {tomCruise}.

In summary, materialization requires a reasoner to expand the knowledge base, the complexity of this task depends on the type of the schema language. On the other hand, query rewriting requires modifying query patterns using SPARQL property paths. This also results in a further jump in the complexity of query answering.

As described above, unlike SPARQL query answering over ontologies, query answering over a concept lattice is relatively easier. Due to the fact that once the concept lattice is obtained from the ontology, LQL can be used to query the lattice. Consequently, alleviating those expensive tasks. The above SPARQL query can be converted into an LQL query as: q(x) = (x, Artist). The evaluation of this query over a concept lattice obtained from O is as expected

The complexity of SPARQL query answering over ELI ontologies is larger than that of LQL query answering over K ELI concept lattices. Since, the expressive power of SPARQL is superior than that of LQL. For ELI ontologies a query language like LQL is sufficient to retrieve individuals (or objects) and classes (or attributes).

To date, several studies have been carried out to assess the relevance and benefits of FCA for DL [5,3,4,14,7,12]. Notably, the work in [14] presents a survey on the advantageous of FCA for DL ontologies. Accordingly, some of the benefits that FCA can bring to the DL world include: knowledge discovery, extended subsumption hierarchy (of conjunctions of concepts) [1], subsumption hierarchy of least common subsumers, exploring finite models [3,4], role assertion analysis, supporting bottom-up construction and completion of ontologies. Since the survey, other studies, [7] and [12], have carried out experiments to characterize and analyse SW data using FCA tools. The former provides an entry point to a linked data using questions in a way that can be navigated. It gives a translation of an RDF graph into a formal context where the subject of an RDF triple becomes the object, a composition of the predicate and object of the triple becomes an attribute. The latter obliges the user to specify objects and attributes of a context. With that, it creates SPARQL queries to extract content from linked data in order to populate the formal context. Despite the fact that all these works have employed FCA techniques, to the best of our knowledge, none of them provide a formal and precise translation of ontologies into a formal context as we did here.

In this work, firstly, we have proposed a formal transformation of ELI ontologies into formal contexts. This enables to benefit from some advantages that FCA may offer to the DL world. Then we have shown that SPARQL query answering over ELI ontologies can be considered as lattice query answering over K ELI concept lattices. This alleviates some reasoning and query rewriting tasks that are required for SPARQL query answering.

Recently analysis of triadic data attracts more and more attention in Data Mining community [1,2,3,4,5]. One particular example is mining of so-called folksonomies, structures composed by three sets: users, objects and tags. One of the first attempts of such an analysis [1] was done within the framework of Formal Concept Analysis (FCA) [6], namely in Triadic Formal Concept Analysis (TCA) [7]. Triclustering methods, which are objects of our study, allow one to simultaneously discover three-component homogeneous groups in the considered three-sets. For example, these triclusters can be used for community detection [8] and recommender algorithms [9]. As a consequence, we would like to investigate peculiarities and reveal advantages and drawbacks of various triclustering approaches to choose the optimal one depending on the task.

In this paper we compare the following triclustering methods: object-attributecondition triclustering (2 modifications including new one) [10,11], TriBox [2], spectral triclustering [11] and Trias algorithm [1]. Even though there are some recent efficient [12] and even more general algorithms than Trias [13], it is well-known to the FCA community and sometimes outperforms its competitors [12]. Moreover, the aim of the paper is not in comparison of different algorithms for triadic formal concepts generation, but it is rather in comparison of the original patterns with their various approximations (triclusters) in terms of the introduced quality measures. We also suggest investigating different matrix decomposition approaches, e.g. Boolean ones [3,4], in a further study; note that Boolean matrix factorization can be considered as an approach to the reduction of the number of the resulting triconcepts.

The rest of the paper is organised as follows. In section 2 we give main definitions and describe the triclustering methods selected for the comparison. Section 3 describes all the experiments and their results on real and synthetic data along with specially introduced quality measures. Section 4 concludes the paper and indicates some further research direction.

Object-attribute-condition triclustering (OAC-triclustering) is based on Formal Concept Analysis [6] and its triadic extension, Triadic Formal Concept Analysis (TCA) [7]. In this paper we consider 2 types of OAC-triclustering: box operator based (box OAC-triclustering) [10], and prime operator based (prime OAC-triclustering). The latter is introduced in this paper. The set of triclusters is generated one by one and complete enumeration strategy is used.

First, we recall some basic notions of Formal Concept Analysis (FCA) [6]. Let G and M be sets, called the set of objects and attributes, respectively The concepts, ordered by (A 1 , B 1 ) ≥ (A 2 , B 2 ) ⇐⇒ A 1 ⊇ A 2 form a complete lattice, called the concept lattice B(G, M, I).

Here let us define the box operators and describe box OAC-triclustering. We use a slightly different introduction of the main TCA notions because of their further technical usage.

Let K = (G, M, B, I) be a triadic context, where G, M , and B are sets, and I is a ternary relation: I ⊆ G × M × B. In addition to set of objects, G, and set of attributes, M , we have B, a set of conditions. Derivation (prime) operators for a triple ( g, m, b) ∈ I from triadic context K can be defined as follows: The density of a tricluster T = (X, Y, Z) is defined as the fraction of all triples of I in X × Y × Z:

Definition 2. The tricluster T is called dense iff its density is not less than some predefined threshold, i.e. ρ(T ) ≥ ρ min .

Let us elaborate on the structure of box operator based triclusters. Suppose K = (G, M, B, I) is a triadic context, and the triple ( g, m, b) ∈ I is considered. Then object g will be added to

It is clear that this condition is equivalent to the one in eq. ( 4), and can be easily illustrated (Fig. 1): if at list one of the elements from "grey" cells is an element of I, then g is added to g .

The idea of box OAC-triclustering is to enumerate all triples of the ternary relation I for a context K generating a box operator based tricluster for each. If generated tricluster T was not added to the set of all triclusters T on previous steps, then T is added to T . It is possible to implement hash-fuctions for triclusters in order to significantly optimize computational time by simplifying the comparison of triclusters. Also a minimal density threshold can be used.

Prime OAC-triclustering extends the biclustering method from [14] to the triadic case. It uses prime operators (eq. 3) to generate triclusters. Prime based OAC-triclusters are more dense than box operator based ones. Their structure is illustrated on Fig. 2: every element corresponding to the "grey" cell is an element of I. Thus, prime operator based OAC-triclusters in a threedimensional matrix form contain a cross-like structure of ones.

It may also be useful to implement hash functions for triclusters.

Algorithm 1 Algorithm for prime OAC-triclustering.

The TriBox method [2] implements an optimization approach in tricluster generation. Suppose K = (G, M, B, I) is a triadic context. The idea is to select some triple of I, take it for the initial tricluster, and then to modify its extent, intent, and modus so that they covered a significant part of the context while maintaining high density. Thus, TriBox aims at finding a set of triclusters T = {T = (X, Y, Z)} that maximize the criterion 6. The resulting triclusters compose locally optimal solution for the trade-off problem between the density and the volume of various possible triclusters.

Once again, hash-functions for triclusters may be used for optimizations.

Spectral triclustering method [11] is based on the graph partition problem. The idea is to represent the given triadic context as a tripartite graph and then recursively divide it. To find an optimal partitioning spectral clustering uses the second minimal eigenvector of the Laplacian matrix.

Let us elaborate on this technique. Suppose K = (G, M, B, I) is a triadic context First we need to transform K into tripartite graph Γ = V, E . Since I is a ternary relation it is only possible to represent K as a tripartite hypergraph without the loss of information. The following transformation technique is considered: V := G M B, for each triple (g, m, b) ∈ I edges (g, m), (g, b) and (m, b) are added to E to form an undirected non-weighted graph. As the result some additional triples will be added to I after inverse transformation. Still it is clear that these triples will be added only in ,,dense" areas of I thus possibly filling missing values and "optimizing" tricontext for methods aiming at finding formal concepts. Thus this technique is acceptable for solving the problem.

After the transformation Laplacian matrix is built for Γ :

where v i is the i th vertex of V.

The second minimal eigenvector of L is an optimal solution of the continuous variant of the optimal partition problem for Γ (finding the minimal set Ẽ ⊆ E so that the graph Γ = (V, E \ Ẽ) is not connected). The sign of each component of this vector indicates one of the 2 new connected components. For convenience we find the optimal partition vector as the approximation of the obtained vector by setting its components to ±1 values.

In order to avoid partitioning of dangling vertices or small subgraphs the generalized eigenvalue problem must be considered ( [11], Appendix I):

where D is a diagonal matrix containing vertices' degrees on the main diagonal. Also, some minimum size constraint can be used to avoid too deep partitioning. Since spectral triclustering is not able to generate the same tricluster more than once, it is not necessary to use hash functions to speed up the calculations.

Formally, Trias [1] is a method for finding triadic formal concepts that are closed 3-sets. Since triadic formal concepts can be interpreted as absolutely dense triclusters, this method was added to the study.

Trias is based on the NextClosure algorithm that enumerates all formal concepts of the dyadic context in lexicographical order. In Trias this approach is extended to the triadic case and minimal support constraints are added (triclusters with too small extent, intent or modus are skipped).

As well as spectral triclustering, Trias is not able to generate the same tricluster more than once.

In order to test noise-tolerance of the algorithms 26 triadic contexts have been generated. The initial context contains 30 objects, 30 attributes, 30 conditions, and 3 non-overlapping 10 × 10 × 10 cuboids of ones on the main diagonal in its three-dimensional matrix form. Then this context has been sequentially noised by the inversions with the probability of an inversion of a triple varying from 0.1 to 0.5 with 0.1 interval (the latter context can be called uniform context, because probability of (g, m, b) ∈ I is equal for every triple). There have been 5 such series of context. Table 1 contains the average number of triples and total density for these sets of contexts. The noise tolerance of an algorithm has been defined as the ability to build triclusters similar to initial cuboids. We used the Jaccard similarity coefficient to find the most similar tricluster t for the given cuboid c and their similarity. Total similarity has been defined as follows (C is a number of cuboids):

Following size measure for spectral triclustering has been chosen:

s min has been set to 0.34 to stop at the triclusters of correct size. All of the methods have been implemented by authors and incorporated in a single triclustering toolbox in order to make the comparison more accurate. The toolbox has been implemented in C# using MS Visual Studio 2010/2012. All the experiments have been performed on Windows 7 SP1 x64 system equipped with an Intel Core i7-2600 @ 3.40GHz processor and 8 GB of RAM. AlgLib1 library was used for eigenvalue decomposition.

The results of the experiments are represented on Figure 3. It is clear that every method has managed to successfully find initial cuboids, but the results quickly deteriorate for most of methods with the growth of inversion probability. TriBox has shown the best results as it tries to optimize the density-volume trade-off (which most probably is the best for the areas of the former cuboids for small error probability). Though prime OAC-triclustering has been also rather noise-tolerant, it generated significantly more triclusters (most likely the high number of triclusters is the reason for these results). All the other methods have been unable to provide significant results for noisy contexts. Moreover, as it was expected, no adequate triclusters were generated by any of the methods for the contexts with inversion probability 0.5.

The experiments on the computation time, triclusters count, coverage, density, and diversity were conducted on the following contexts (Table 2): in at least one of the triclusters of the resulting set. To define diversity we will use a binary function of 2 triclusters intersect(T i , T j ) that equals to 1 if both triclusters T i and T j have nonempty intersection of the sets of contained triples, and 0 otherwise. It is also possible to define intersect for the sets of objects, attributes and conditions. For instance, intersect G (T i , T j ) is equal to 1 if triclusters T i and T j have nonempty intersection of their extents, and 0 otherwise. Now we can define diversity of the tricluster set T :

The diversity for the sets of objects, attributes or conditions is similarly defined.

Table 3 contains the results for the experiments. The following values for parameters were selected:

1. OAC-triclustering: ρ min = 0 2. SpecTric:

Trias is one of the most time consuming algorithms compared in the paper along with TriBox and SpecTric for large contexts. Though the resulting triclusters (triconcepts) can easily be interpreted their number and small size make it impossible to understand the general structure of the context. Since all triconcepts have been generated and thus every triple has been covered, the coverage is equal to 1. Since the concepts are small general diversity is rather high. Still, the set diversity depends on the size of the corresponding set: the smaller the set -the greater the chance of intersection and the lower the diversity.

Examples of the triconcepts for the IMDB context:

We compared several different triclustering approaches and showed that there is no algorithm-winner with respect to the considered criteria. Also, we can conclude that either (dense) prime OAC-triclustering or TriBox is a good alternative for TCA approach because the total number of triclusers for real data example is drastically less than the number of triconcepts. The proposed algorithm has a good scalability on real-world data and shows acceptable noise-tolerance level. Probably investigated spectral hierarchical partitioning of ternary relations can be a good alternative of concept-based triclustering as a tool for fast exploratory (preliminary) analysis.

Our further work on triclustering will go in the following directions:

-developing a unified theoretical framework for n-clustering, -mixing several constraint-based approaches to triclustering (e.g., mining dense triclusters first and then frequent tri-sets in them), -finding better approaches for estimating tricluster's density, -taking into account the nature of real-world data for optimization (their sparsity, value distribution, etc.). -investigation of the existing approaches and developing their extensions to triadic numerical data for comparison purposes, -applying triclustering in recommender systems and social network analysis.

The lattice is required for the computation and the present lattice of input data before the introduction of new objects would be required for the update of the lattice when adding the objects. However, that lattice can be large, the application may not store it (it can be even impossible due to space requirements) or it can be stored at different (presentation) place than the computation place, or there can be other drawbacks and difficulties of keeping the whole lattice. Moreover, handling of the other changes of input data like deletion or alteration (i.e. changing of values of attributes) of existing objects would call for more or less (depending on the particular algorithm) extensive modifications of the incremental algorithm.

In the following we propose efficient algorithm for updating the concept lattice, i.e. computing the lattice changes resulting by input data changes, from the present (already processed) and new objects only, not requiring the concept lattice of present objects. The algorithm results as a modification of Kuznetsov's Close-by-One (CbO) algorithm [8][9][10] for computing the set of all formal concepts or any of its recent derivatives including FCbO [14], PCbO [7] or PFCbO [6]. When introducing new objects to input data the modified algorithm computes and outputs the resulting new and modified formal concepts only and the respective changes in the lattice order relation (pairs of formal concepts to be created or deleted). Note that (1) new formal concept here is a concept in new data with (some of the) introduced objects in its object set (extent) and attribute set (intent) not equal to intent of any concept in the data before the update and modified formal concept is a concept in new data with the same intent as some existing concept in data before update and enlarging its extent by (some of the) introduced objects, other formal concepts in new data are called old; (2) since the concept lattice (before update) is not required by the algorithm the computed changes in the lattice order relation are output only and have to be applied where the (part of the) lattice is stored and (3) introducing new objects to input data cannot result in removal of formal concepts from the concept lattice [4,15]. Moreover, considering instead the new objects to be some of the objects of input data to be deleted from the data, the present objects to be the set of objects of input data after the deletion and the computed formal concepts to be resulting concepts to remove or modify together with the "inverse" changes of the lattice order relation, we have easily handled also the change of input data consisting of deleting existing objects. The change by altering objects can be handled by first deleting the objects and then by introducing the altered objects, interpreting the output formal concepts accordingly. Finally, changes of input data by introducing new and deleting or altering existing attributes are completely analogical and can be handled (better than by altering objects) by an algorithm re-described with objects and attributes switched or by the present algorithm with objects and attributes switched in input data (transposed data) and in output formal concepts.

The algorithm is described in Section 2, for the case of changing input data by introducing new objects, including an illustrative example. In Section 3 we present an experimental evaluation of performance of the algorithm and a com-parison with AddIntent algorithm [12], which is considered one of the up-to-date most efficient incremental algorithms for computing concept lattice.

We describe the algorithm as a modification of Fast Close-by-One (FCbO) algorithm [14], as it happens to be one of the up-to-date most efficient (sequential/serial) derivatives of CbO [5]. In essence, the modification equally applies also to other CbO derivatives and CbO itself. A deep knowledge of FCbO is not required in the description, however, basic knowledge is beneficial. The modification consists of two parts: (1) computing new and modified formal concepts only when introducing new objects to input data and (2) determining changes in the lattice order relation. We describe the parts separately in Sections 2.1 and 2.2.

In the descriptions below we assume the reader is familiar with basics of FCA, see [2,3] for reference. Input object-attribute data (formal context) is denoted by the triplet X, Y, I , with assumed finite nonempty sets of objects X = {0, 1, . . . , m} and attributes Y = {0, 1, . . . , n}, and I ⊆ X × Y being an incidence relation with x, y ∈ I saying that object x ∈ X has attribute y ∈ Y . Concept-forming operators defined on I as usual [3] are denoted by ↑ I : 2 X → 2 Y and ↓ I : 2 Y → 2 X , B(X, Y, I) denotes the set of all formal concepts in I and ≤ the partial order relation on B(X, Y, I) forming together a concept lattice.

In this section we describe how to compute new and modified formal concepts when introducing new objects to input data. Let us suppose we are introducing to input data X, Y, I (finite nonempty set of) new objects X N = {m + 1, . . . , m } not present in X (X N ∩ X = ∅), sharing (finite nonempty set of) attributes Y N = {i, . . . , k}. We do not assume any overlap of Y N and Y (Y N can contain new attributes not present in Y ) but in usual scenario of introducing new objects to input data we have Y N ⊆ Y . Denote the incidence relation between X N and Y N by N ⊆ X N × Y N and the new input data with new objects added by the triplet X , Y , I , where

Hence I is the union of I and N both extended to X and Y .

First, observe that attributes of Y N which are not shared by any of objects X N cannot participate in any new nor modified formal concept of B(X , Y , I ), with the exception of formal concept Y ↓ I , Y . Hence we will assume in the following, without loss of generality, that all attributes of Y N are shared by at least one object from X N . For an algorithm for computing new and modified formal concepts only it is then sufficient to process only attributes Y N . Now, for any B = B ↓ I ↑ I ⊆ Y N , if B = B = B ↓ I ↑ I then the formal concept A , B ∈ B(X , Y , I ) with the same intent B = B as formal concept A , B ∈ B(X, Y, I) is a modified formal concept enlarging the extent of The procedure accepts as its arguments a formal concept A, B (an initial formal concep t), an attribute y ∈ Y N (first attribute to be processed) and a set {N y ⊆ Y | y ∈ Y } of subsets of attributes Y (see [14] for the meaning of the set), and uses local variables queue as a temporary storage for computed formal concepts and M y (y ∈ Y ) as sets of attributes which are used in pl ace of the third argument for further invocations of the procedure. After invocation, the procedure recursively descends through the space of new and modified formal concepts of X , Y , I resulted by adding new objects X N described by attributes Y N to X, Y, I .

When invoked with A, B and y ∈ Y N (first attribute to be processed) and

), in which case, if further (A∩X) ⊂ A (line 2), A, B is a modified formal concept (see above) and it is listed as such. In the other case, A, B is a new formal concept. Then the procedure behaves exactly as the original procedure FastGenerateFrom, see [14] for full description, with the exception that it goes through attributes j ∈ Y N only (line 13). Let us recall that the set Y j ⊆ Y is defined by

In order to list all new and modified formal concepts of X , Y , I which are not formal concepts of X, Y, I , each of them exactly once, we invoke Up-dateFastGenerateFrom with ∅ ↓ I , ∅ ↓ I ↑ I , y being the first attribute in Y N and {N y = ∅ | y ∈ Y } as its initial arguments. The correctness of Algorithm 1 follows from the correctness of FCbO algorithm [14] and the above description of its modification.

Example 1. We illustrate Algorithm 1 on the following example. Consider an input data given in an usual way (rows correspond to objects, columns to attributes and table entries indicate whether an object has an attribute) by the upper part, rows 0 to 2, of the table depicted below (left). The data induces 8 formal concepts C 1 to C 8 depicted on the right.

Now we introduce to the data two new objects represented by rows 3 and 4 of the lower part of the table. The introduction results in induction of 5 new formal concepts C 9 to C 13 and 5 modified formal concepts C * depicted below the old formal concepts. The concepts are listed down-right in order in which they are listed by procedure UpdateFastGenerateFrom.

Remark 1. Algorithm 1 can be easily used to list all formal concepts of input data X , Y , I incrementally, i.e. processing the data object by object, as incremental algorithms for computing concept lattice do. Namely, we invoke procedure UpdateFastGenerateFrom with initial arguments repeatedly for each object i ∈ X = {0, . . . , n }, setting X, Y, I := {0, . . . , i − 1},

for each invocation, and filter out listed modified formal concepts listing new formal concepts only. Such a computation of all formal concepts of data is, however, quite inefficient due to many repeated (though efficient) computations of formal concepts listed as modified by procedure UpdateFastGenerateFrom, see the performance evaluation in Section 3. The concepts are, moreover, filtered out from the listing but, however, necessary to compute in order to decide whether a concept is new or modified. Incremental algorithms iterate over (so far) incrementally computed and stored concept lattice to decide and compute new formal concepts which is more efficient. On the other hand, as discussed in introduction Section 1, the concept lattice is required for the computation and must be stored by the incremental algorithms, while Algorithm 1 requires input data only/instead and does not need to store anything.

In this section we describe how to determine the changes in the concept lattice order relation which need to be done with the addition of new formal concepts to the lattice. Note that the modified formal concepts cannot raise a change in the relation since attribute set (intent) of a modified concept remains unchanged with introduction of new objects to input data, as discussed above.

In order to determine the changes in concept lattice order relation by the modified FCbO algorithm introduced in previous Section 2.1, we first have to determine the concept lattice order relation alone since the FCbO algorithm, as well as the modification, computes the set of formal concepts of input data only. So, in the following, we describe an extension of Fast Close-by-One (FCbO) algorithm [14] to determine the concept lattice order relation ≤ on the set of all formal concepts B(X, Y, I) of input data X, Y, I computed by the original algorithm, i.e. making an algorithm for computing concept lattice of X, Y, I . In fact, we will not determine the whole order relation but rather its cover relation. Recall that the cover relation on B(X, Y, I) for ≤ is defined such that a formal

, i.e. the cover relation is the transitive reduct of ≤. And since we do not store and use the computed concept lattice in our algorithm for updating the lattice, we will not store and use the computed formal concepts nor the concept lattice order cover relation in the extended FCbO algorithm as well. Besides listing the formal concepts, we will only list the pairs of formal concepts to be created or deleted in the relation at the place where it is stored.

We now describe how to extend FCbO algorithm, as described in [14], to determine the concept lattice order cover relation on the set of computed formal concepts, i.e. to compute concept lattice. We can use the pseudocode in Algorithm 1 if we look apart from the modifications to FCbO introduced there (the check whether A, B is new or modified formal concept between lines 1 and 6 and going through attributes from Y N only at line 12), in which case we obtain the original procedure FastGenerateFrom from [14]. We will need a little knowledge of FCbO (or CbO) now. The algorithm, see the pseudocode of procedure UpdateFastGenerateFrom, computes a formal concept C, D = A ∩ {j} ↓ , (A ∩ {j} ↓ ) ↑ (lines 14 and 15) from a formal concept A, B for all attributes j ∈ Y such that y ≤ j ≤ n which are not present in B (lines 12 and 13). Certainly C, D ≤ A, B . If C, D passes the canonicity test (line 16) and is listed we list the pair C, D , A, B as to be created in the cover relation in spite of that the formal concepts in it need not fulfill the definition of cover relation. We do it since a test for the fulfilment would be too expensive compared to that in the case of nonfulfilment we will list the pair later again as to be deleted from the relation.

Next, since further formal concepts C ∩ {j } ↓ , (C ∩ {j } ↓ ) ↑ are computed from C, D in the next recursive invocation of(Update)FastGenerateFrom for attributes j ≥ j + 1 (j + 1 is passed in y argument in the invocation, line 20), in order to list pairs E, F , C, D to be created in the cover relation, we determine formal concepts E, F = C ∩ {i} ↓ , (C ∩ {i} ↓ ) ↑ for all attributes j − 1 ≥ i ≥ 0 (which are not present in D). Due to the order in which formal concepts are computed by FCbO, formal concepts E, F were already computed (and listed) in some of the previous stages of the algorithm before the computation of C, D . However, since formal concepts are not stored in FCbO nor in our extension, we have to compute the concepts E, F repeatedly. Again, formal concepts E, F , C, D in the pairs need not fulfill the definition of cover relation. Here, however, we can use a cheap test known from Lindig's NextNeighbor algorithm [11], but limited to attributes 0, . . . , j − 1 ∈ Y . The test is based on the fact that a formal concept [11]). If the test passes, we list the pair E, F , C, D as to be created in the cover relation. We do it even for formal concepts in the pair which pass the test and do not fulfill the definition of cover relation due to the limitation of the test to attributes 0, . . . , j − 1 ∈ Y for the same reason as above for pairs C, D , A, B . To resolve these cases we simply, together with listing the pair E, F , C, D , list as to be deleted from the relation the pair E, F , A, B which does not fulfill the definition of the relation and could have been listed as to be created in the cover rela-tion in this or the previous stage (previous recursive invocation of procedure (Update)FastGenerateFrom) of the extended algorithm. The justification of this and that all such pairs will be listed as to be deleted from the cover relation is postponed to the full version of the paper.

The modified procedure LatticeFastGenerateFrom, which implements the above presented ideas to procedure FastGenerateFrom to extend FCbO algorithm to determine the concept lattice order cover relation on the set of formal concepts computed by FCbO, i.e. to compute concept lattice, is depicted in Algorithm 2. As with the procedure UpdateFastGenerateFrom in Section 2.1, we describe only the modifications introduced to FastGenerateFrom.

The original FCbO algorithm remains in essence intact, including its arguments and local variables, all the modifications to original procedure FastGen-erateFrom are in the computed formal concept C, D processing part before the recursive call of the procedure (line 28), between lines 16 and 29. First note that the listing of C, D moved from the beginning of the procedure (see Algorithm 1) here, resulting effectively in the need to list the formal concept passed in the initial invocation of the procedure before the invocation. Note also that this move does not change the order of listed formal concepts. Then, after listing the pair C, D , A, B as to be created in the cover relation, between lines 18 and 27, formal concepts E, F = C ∩{i} ↓ , (C ∩{i} ↓ ) ↑ , i ∈ D covered by C, D are re-computed (lines 20 and 21) and listed in pairs E, F , C, D as to be created in the cover relation, for attributes j − 1 ≥ i ≥ 0. The test of covering (line 23) is performed using the min local variable in a slightly modified form borrowed from the original description of Lindig's NextNeighbor algorithm in [11]. With listing of E, F , C, D , the pair E, F , A, B is listed as to be deleted from the cover relation as discussed above.

In order to output concept lattice of X, Y, I , that means to list all formal concepts of X, Y, I , each of them exactly once, together with all pairs of formal concepts to create or delete (if the pair exists) in order to obtain the cover relation of concept lattice of X, Y, I , each pair of formal concepts in the cover relation listed exactly once, we first list ∅ ↓ , ∅ ↓↑ and then invoke Lat-ticeFastGenerateFrom with ∅ ↓ , ∅ ↓↑ , y = 0 and {N y = ∅ | y ∈ Y } as its initial arguments. The correctness of Algorithm 2 follows from the correctness of FCbO algorithm [14] and the above description of its extension. Determination of changes in (the cover relation of) concept lattice of X, Y, I needed to be done in reaction to the introduction of new objects to input data is then a matter of merging the Algorithms 1 and 2. In addition to that we list, for each new formal concept C, D computed from formal concept A, B (or C, D = ∅ ↓ I , ∅ ↓ I ↑ I ) and its generator E, F = C ∩ X, (C ∩ X) ↑ I , with listing of C, D also pairs F ↓ I , F , C, D as to be created in the cover relation and F ↓ I , F , A, B as to be deleted from the cover relation. The pairs will then not be listed in the extension introduced in procedure LatticeFast-GenerateFrom. Due to space limitations of the paper, the merged algorithm is postponed to the full version of the paper.

Next (to the right) to the lattice there is then the concept lattice and below the listing of the 8 formal concepts the listing of the 5 new formal concepts C 9 to C 13 and changes in the cover relation after the introduction of the two new objects to the data. The changes are depicted in bold face in the lattice and the listing of concepts and pairs of concepts in the changes are again listed down-right in order in which they would be listed by a procedure describing the merged algorithm. •|X|), because when "introducing" all objects to empty data it actually performs FCbO. The complexity of Algorithm 2 is in the worst case |Y | factor higher but on average it performs a constant factor slower than FCbO (and ramification of the worst-case time complexity of FCbO itself remains a challenging open problem [14]).

We have run several experiments to evaluate the performance of Algorithms 1 and 2 and also the merged algorithm. For listing all formal concepts or concept lattice of input data we also compared the algorithms with AddIntent incremental algorithm [12] for computing concept lattice. In the comparison, we also run Algorithm 1 and the merged algorithm in the way processing input data incrementally as mentioned in Remark 1, for the sake of presenting more fair comparison with true incremental algorithm, though such usage of our algorithms is not efficient (as mentioned in the remark).

In the experiments, we used our implementations of the presented algorithms in ANSI C, which are modifications of our (performance efficient) FCbO algorithm implementation used for performance evaluation in [14], while the implementation of AddIntent algorithm was borrowed from one of the authors of [12]. The experiments were run on otherwise idle 32-bit i386 hardware (2× Intel Xeon 3.2 GHz, 3 GB RAM) and we were interested in the performance of all algorithms measured by running time. We have run the algorithms on synthetic randomly generated data with various size and percentage of ×s in the table (fill ratio, with normal distribution) as well as with three selected real benchmark datasets from the UCI Machine Learning Repository [1].

In the first set of experiments we evaluated Algorithm 1 for updating the set of all formal concepts (computing new and modified concepts) when introducing new objects to input data. The performance for introducing a single new object (with randomly generated attributes) to random data with 100000 objects is illustrated in Figure 1. The graphs show the dependency of time required to compute the update on the number of attributes, of data with fixed table fill ratio 5 % (the graph on the left) and on the fill ratio of tables with fixed 150 attributes (the graph in the middle). Figure 1 (right) then illustrates the performance for introducing a growing number of new objects to random data with the number of objects being 100000 minus the number of the new objects, 200 attributes and 5 % table fill ratio. Note that the number of new objects in the graph is in logarithmic scale. The illustration for the benchmark datasets, of the performance of introducing a growing number of last objects of the data to the data without the objects, is presented in Figure 2 (right). In the graph the solid line is for data with objects ordered as in the original dataset and the dashed line is for data with randomly ordered objects (the time is an average from three orderings).

We can see from the graphs showing the performance of updating the set of all formal concepts when introducing a single new object to the data (Figure 1, left and middle) that this operation is extremely fast compared to computing all formal concepts which took 7061 seconds for 500 attributes and 355 seconds for fill ratio 10 %! The reason is of course computing only a bare fraction of new and modified formal concepts among all concepts. Introducing more new objects (Figure 1, right, and Figure 2) is much faster too, up to a limit of the number of new objects depending on the total number of objects in data and then being close to the time of computing all formal concepts (compare for benchmark datasets with FCbO times in Table 1). Note also that running times for mushroom dataset differ for original and random orderings of objects.

In the second set of experiments we evaluated Algorithm 2 for determining the cover relation of concept lattice of input data. The performance for random data is illustrated in Figure 3. The graph on the left shows the dependency of required time on the number of attributes, of data with 10000 objects and fixed table fill ratio 5 %, the graph in the middle shows the dependency on the fill ratio of tables with 1000 objects and fixed 100 attributes. The graphs show also the comparison with AddIntent algorithm and the original FCbO algorithm; the solid line is for Algorithm 2, the dashed line is for AddIntent and the dotted line is for FCbO. The performance for the benchmark datasets is presented in Table 1. Again, the times are given for data with objects ordered as in the original dataset and for data with randomly ordered objects (the time is an average from three orderings), and we also put information on size, fill ratio and the number of all formal concepts for each dataset.

From the graphs we can see that Algorithm 2 considerably outperforms AddIntent algorithm on synthetic random data (in particular for higher fill ratio of data table), while for real benchmark datasets this must not always be the case (T10I4D100K, closely mushroom). This, however, heavily depends on the concept lattice structure (size of the cover relation) of the datasets. We can also Finally, the comparison of performance of Algorithm 1 and the merged algorithm with AddIntent, of computing the set of all formal concepts or concept lattice when processing input data incrementally as mentioned in Remark 1, is presented in Figure 3 (right) and Table 2. The graph shows the performance for the data with 10000 objects and fixed table fill ratio 5 % from the preceding evaluation of Algorithm 2 (the time is an average from three random orderings of objects); the solid line is for the merged algorithm, the dashed line is for AddIntent and the dotted line is for Algorithm 1. In the table we also put, for our algorithms, for the sake of comparison, the numbers of formal concepts computed in total (for original ordering of objects in datasets).

The results are really interesting here. For the real benchmark datasets AddIntent algorithm significantly outperforms our algorithms, see Table 2. This was expected since, as hinted by Remark 1, the algorithms are not designed and ment to be used as incremental algorithms (processing objects one by one). What is, however, very surprising is that on synthetic random data both Algorithm 1 and the merged algorithm considerably outperform AddIntent and, moreover, computing concept lattice (determining cover relation) takes just a little more time than computing the set of formal concepts only. It seems that the usage of the algorithms as incremental algorithms, after all, deserves more attention!

We have introduced algorithms for updating the set of all formal concepts of object-attribute relational data when the data change (new objects or attributes are introduced or existing are deleted or altered) by computing only new and modified formal concepts and for determining the concept lattice order relation, i.e. computing concept lattice of the data. Together the algorithms form an algorithm for updating concept lattice of object-attribute data from the data only, not requiring the possibly large concept lattice computed before the update as the so-called incremental (update) algorithms do. The algorithms result as modification or extension of FCbO algorithm for computing the set of all formal concepts of data and the modifications can be equally applied to any other recent algorithms (PCbO, PFCbO) derived from Kuznetsov's CbO algorithm. The experimental evaluation of performance of the algorithms have shown that the update is performed by the first algorithm significantly faster than re-computing all formal concepts or whole concept lattice and that the second algorithm is performance comparable to incremental algorithms for computing concept lattice.

The future research will be focused on further experimental and real-world application use evaluation of the algorithms and performance comparison with other incremental (update) algorithms for computing concept lattice. This section discusses the basis for creating a taxonomic classification network. The first subsection notes that a disciplinary taxonomist provides the a priori categories for the taxonomy. This subsection also provides examples of categories for two kinds of Earth science data. These categories depend on the disciplines providing the data. Thus, this paper treats them as axiomatic. The second subsection provides a formal discussion of the AIC and AIU data structures. The third subsection deals with a rough scaling analysis of a taxonomic network.

The a priori basis for creating a taxonomy for an archive's collection lies in the scientific disciplines that produce the IO's. As with the OAIS RM, we assume that the IO's are atomic so they have no internal components that the archive records. In Earth science, IO's may be physical objects, such as biological or geological specimens. They may include hand-written or printed observational records or technical reports. Finally, Earth science IO's may be digital files, the bulk of which contain numerical values based on measurements from automated instruments.

A second axiomatic basis is the Formal Context (FC) formed by all the IO's in the archive. The union of the IO's forms the extent of this FC. Its intent is the union of all the IO attributes.

The NOAA Emergency Response Imagery Collection is an archive of digital images taken by an automated camera mounted on an aircraft [2]. The aircraft flew one or two days after disastrous storms. There have been about twenty storms in the last decade that were disastrous enough to lead to aircraft missions. These included Hurricane Katrina in 2005 and Hurricane Sandy in 2012. Each mission produces three kinds of IO's: high resolution gif images, low resolution gif thumbnails, and zipped files containing collections of images. The archive's curators organize the images in a zipped file in a sequence along an aircraft flight path.

The ERI project provides a web site through which emergency responders, such as federal disaster coordinators or insurance adjustors can download IO's. These users evaluate the storm damage and plan appropriate action based on the images. Altogether, the total collection probably contains about 60,000 IO's. Each IO has an ID, a storm name, a data collection date, and a text storm centroid location. The high resolution and thumbnail gif's have four latitude/longitude positions at the corners of each image. With eleven attributes for most of the files, there will be about 660,000 attributes (11 × 60, 000) in the Formal Context intent for this collection's IO's.

In the taxonomic network, the AIC's that lie in the first level below the root refer to images from specific storms. Thus, these collections include images from storms such as Hurricanes Katrina, Ike, or Sandy. In the level below that, each storm AIC has two collections. One is an AIC for a collection of images in coarse geographic bins. Those images include the high-resolution gif images and the thumbnails. The second AIC is a collection of zipped files along the flight paths. The AIC's that are children of each geographic bin AIC contain AIC's with one high resolution image and one low-resolution image. The AIC's below the one with the flight path collection contain AIU's based on an individual flight path. The network replicates this layered AIC structure across the entire collection of IO's. Even so, each PFC is unique.

For biological specie classification, the categories for the AIC's are Kingdoms, Subkingdoms, Classes, Orders, Families, Genera, Species, and Races. The individual specimens in an archive's biological specimen collection are the IO's in the AIU's.

A disciplinary taxonomist creates AIP's and AIU's. This is a familiar process in biology. [3] [p. viii] notes that such a "grouping . . . though based on natural characters and relationships is not governed by any rule drawn from nature for determining just what [. . .attributes] shall be sufficient to constitute a Specie, a Genus or a Family. These groups are, therefore, necessarily more or less arbitrary and depend upon the judgement of scientific experts."

The AIC's and AIU's are vertices in a graph. The pseudo code in the Taxonomy Network Data Structure provides a pointer-based formalization of the relationship between the AIC's and the AIU's. If all of the PFC's in the graph were diagonal, each object in the PFC would have only one unique attribute. The taxonomic graph would collapse to a tree. There would be a unique edge that linked each AIC to each of its children. When the parent PFC is not diagonal, the formal concepts formed from the PFC create a lattice that links parents to their children. For a taxonomic network, the lattice must provide a unique path from a parent to each of its children. would need to match the attributes of her sample against the standard attributes that identify the particular specie within a probable Genus.

The search behavior of a disciplinary specialist differs markedly from that of an individual with an unclear target for his or her search. A person browsing needs a recommender site rather than a navigational one [4].

The taxonomic classification approach expects that a user can identify a useful IO based on the taxonomy network traversal. If the user obtains his or her goal, then the search terminates successfully. If the user recognizes that the search is not likely to reach the target, he or she can back up to a higher level and make different selections. Thus, we expect the user search to be iterative. In addition, the user can get tired of searching and terminate the interaction. The following pseudo code outlines the search algorithm. The user-guided navigational search algorithm outlined in the pseudo code starts at the root AIP. The loop moves down the taxonomic AIP graph from the root at Level 0 to deeper levels where the user can find the desired target IO. The first step for the user is to prune the selected AIP attributes to create a pruned formal context. In pruning, the user removes attributes regarded as irrelevant to finding the target IO. Pruning the static Formal Context removes the irrelevant columns and thereby produces a smaller Formal Context. The pruning also removes any rows that contain no objects after removal of the attribute columns. The pseudo code for the NSN subalgorithm provides the logic for lines 5 and 6 of this listing.

Nearest Superset Navigation (NSN) Subalgorithm

This paper shows how a taxonomic classification with FCA can fit within the OAIS RM's standard structure for information packages in an Archive of Earth science data. The scaling analysis of the computational load of user-guided navigation and dynamic FCA needs refinement. Even so, it suggests that this approach is affordable. [2] shows that a navigational approach similar to one derived from this algorithm offers an alternative to the conventional metadata query approach for selecting IO's from an archive of Earth science data. concepts result from this noise, (2) experts are not satisfied with the resulting knowledge model and wish it to be more in accordance with their needs, i.e. the application that will use the knowledge model.

The rest of the paper is structured as follows. Firstly, section 2 explains how the system and experts collaborate in building and changing the lattice, illustrates the approach by removing a concept from a lattice. Next, section 3 presents experimental results. Finally, section 4 concludes with a summary and draws perspectives.

In our approach, experts do not have access to the formal context; they can browse concepts, run through subsumption paths, look at extents and intents of concepts. Then, they express their wishes to change the lattice using operations. An operation on the lattice is a kind of retro-engineering: experts select an operation on the lattice (ex: remove this concept), the system assesses the impact of the change, suggests different strategies and then, for the chosen strategy, calculates what to change in data for the new lattice to meet the requirements. The lattice is then built accordingly. Experts repeat the process until they reach an agreement between the model and their knowledge.

We list basic changes on a lattice to add or remove one element from the lattice (Table 1). There could be more complex operations such as merging two concepts into one, splitting one concept into two sub-concepts, creating a common concept for a set of concepts... For each operation, we need to define an algorithm to compute the set of possible strategies to perform the change, to identify related changes in the lattice, to rank them according to a cost function and to keep a trace in a history. Adding or removing objects or properties in a formal context motivated the development of incremental algorithms to update a lattice [6][7][8][9]. Concept removing is somehow complex: several strategies are possible and impacts on other concepts in the lattice (side effects). We detail this operation to explain our approach in the next part.

Removing a concept while keeping the lattice structure means moving it down to one of its children or up to one of its parents. These solutions correspond to what we call different strategies.

Add an object to a lattice Remove an object from a lattice Add an object to a concept Remove an object from a concept Attribute Add an attribute to a lattice Remove an attribute from a lattice Add an attribute to a concept Remove an attribute from a concept Add an attribute to an object Remove an attribute from an object Concept Add a concept to a lattice Remove a concept from a lattice Add a supper concept to a concept Remove a supper concept from a concept Add a sub concept to a concept Remove a sub concept from a concept We benefit from incremental algorithms that have been implemented to build lattices ( [6], [8]) not only to avoid complete recalculation of the lattice but also for identifying the different possible strategies to perform a given change in the current lattice. Incremental algorithms, at the i th step, produce the concept set or diagram graph for i first objects of the context. The new object i + 1 th is dynamically added by modifying the existing lattice without recomputing the whole lattice from scratch. ( [8])

Let us explain our approach through the algorithm for moving concept down -Strategy 1. In Strategy 1, the set of objects and the set of properties remain unchanged. Only the relation I is enriched. Moreover, a new closed set (Extent(C), Intent(C child )) is a formal concept of the new lattice L * .

From the new closed set (Extent(C), Intent(C child )) and the existing lattice L, we generate the new lattice L * by identifying the categories of concepts. The new lattice is obtained from the existing lattice by taking, deleting or modifying some concepts and creating new concepts. Thus, concepts are classified into four Finally, all the strategies are suggested to the expert with their impacts (Table 2) so that the expert can consider choosing one strategy. Once the expert makes a choice, the system will update the lattice accordingly.

We experimented our approach for extracting knowledge from a real text corpus of Fibromuscular Dysplasia extracted from PubMed1 . The corpus consists of 400 texts.

In the preprocessing step, we used SemRep ( [11]) to annotate the texts. 2402 annotation objects were identified from the corpus, of which only 668 objects are shown in the right or left side of a triplet relationship and 481 objects on the right side. 36 different relationships are identified in these texts. Given an annotation (object1, relationship, object2), we consider object1 as an object and the name of the relation is concatenated with object2 to become a binary attribute of object1. For example, Fibromuscular Dysplasia is an object and ISA Disease is one of its attributes. SemRep annotation process can be noisy but, of course, no automatic tool is perfect. Moreover, any annotation process could annotate the texts, including manual annotation. This is one of our goals to take the advantage of expert interaction in the construction of the knowledge model.

Next, we built a Java script to transform the set annotations into a formal context. The lattice was produced by Galicia2 and exported as the XML document. The context built from our corpus contains 481 objects, 545 attributes formed by the association of the relationship of the object with which it relates. The lattice contains 523 concepts and the longest path from the Top to the Bottom is 7.

Then, we implemented a system with operation removing a concept from a lattice. When an expert, during the evaluation phase, asks for removing a concept, the system suggests a list of strategies and makes explicit their impacts on the lattice (lists of modified, deleted and new concepts) to the expert. Once the expert chooses one strategy, the system will update the lattice accordingly.

The required time for the expert to remove concepts has not yet been evaluated. Our experience shows that a judicious choice of a strategy in order to remove concepts has a strong impact on the speed of convergence towards a satisfactory knowledge model.

We presented a collaborative approach for FCA-based knowledge extraction. Our study shows how domain experts and machines can collaborate in building and changing a lattice. The system handles changes in a lattice and keeps a trace from the previous lattice. In that way, experts know the impact of a change. Our iterative and interactive approach takes advantage from FCA and reduces limitations due to the use of a formal method to model a complex cognitive process.

This approach opens several perspectives. We can do more to help the expert. Refining the cost function associated to changes can make easier the choice of one strategy. Tagging concepts that the expert agrees with and wants to keep unchanged all along the process could reduce the number of the suggested strategies. Performing several changes at once needs also more investigations.

represents derivative in the formal context T = (U RL, Key, F ). Recall that U RL Sh&Ga = {Shilov, Garanina} in K G , U RL Gr = {Grebeneva} in K Y . So we can not write the following equality U RL Sh&Ga\Gr = {Shilov, Garanina} \ {Grebeneva} , but have to write another one U RL Sh&Ga\Gr = {Shilov, Garanina} ↓F \ {Grebeneva} ↓S ↑T ↓T , where '↓ F ' represents the lower derivative in the context F, '↓ S ' -the lower derivative in the context S, and '↓ T ' and ' ↑ T ' -the lower and upper derivatives in the context T. We believe that it would be nice to process queries like this one but (unfortunately) modern search engines can not do it; a part of the reason for this inability is due to lack of theory for processing such multi-context queries.

At the same time polymodal and/or descriptive logics (DL) [1] provide language for presentation of queries as above. In particular, if T d denotes the inverse of the binary relation T , then Sh&Ga \ Gr may be represented in syntax of a polymodal logic by the following formula An interpretation of FCA constructs in DL has been studied in [7]. In these studies DL has been extended by FCA-derivatives and provided with Kripke semantics; as a result all concept terms are interpreted by sets of objects, not by concepts (or their extents), a lattice-theoretic structure of formal concepts (that is so important advantage of FCA) is lost. A variant of description logic (namely ALC, Attribute Language with Complements) with values in concept lattices was defined in [8] but without a concept negation; the concept negation was defined only in concept lattices for symmetric contexts (i.e. in contexts where sets of objects and attributes are equal and the binary relation is symmetric). It implies that if we would like to define concept lattice semantics for the DL concept term above, we have to symmetrize contexts F, S and T in some manner. In this position paper we present some preliminary results of our studies of ways of context symmetrization, formulate and discuss some topics that need more research.

Modal and Description Logic are closely related but different research paradigms: they have different syntax and pragmatic, but very closely related semantics (in spite of different terminology). Lattice-valued modal logics were introduced in [3,2] by M.C. Fitting. They were studied in the cited papers from a prooftheoretic point of view. Later several authors attempted study of these logics from algebraic perspective [5,6,9]. Basic definitions related to modal logics on lattices and completeness theorems can be found in [5].

Description Logic (DL) is a logic for reasoning about concepts. But there is also an algebraic formalism developed around concepts in terms of concept lattices, namely Formal Concept Analysis (FCA). In this section we recall in brief definition of description logic ALC on concept lattices of (symmetric) contexts and some properties that follow from this definition, please refer [8] for full details. We use notation and definitions for Description Logics from [1] 1 . For the basics and notation of Formal Concept Analysis, please, refer to [4].

Semantics of description logics on concept lattices comes from lattice-theoretic characterization of 'positive' (i.e. without negation) concept constructs (for close world semantics) that is given in the following proposition [8]. Semantics of ALC positive concept constructs , ⊥, , , ∀, and ∃ as well as semantics of negative construct ¬ are defined in [8] as follows. The following proposition [8] states that for any conceptual interpretation every positive ALC concept term is an element of concept lattice; in addition, if an interpretation is symmetric then this fact holds for all ALC concept terms.

Proposition 2. For any conceptual interpretation (G, M, I, Υ ), for every positive ALC concept term X, semantics Υ (X) is an element of B(G, M, I). For any symmetric conceptual interpretation (D, D, I, Υ ), for every ALC concept term X, semantics Υ (X) is an element of B(D, D, I).

The above proposition 2 leads to the following idea: to define semantics of ALC with values in an arbitrary concept lattice by isomorphic embedding of the background context into a symmetric one in such a way that for the positive fragment of ALC the original semantics and the induced semantics equal each other. Below we examine some opportunities how to "symmetrize" a given context, i.e. to build a symmetric context from an arbitrary given background context. Below we are going to study how to build a symmetric context from a given one by set-theoretic and algebraic manipulations with a binary relation of the context. Without loss of generality we may assume that the background context is reduced [4] and has disjoint sets of objects and attributes. In [5] the definition for modal logics with values in a given finite distributive lattice L is presented. This definition is easy to expand on polymodal logics. In section 2 we represented the definition for description logic ALC (that can be considered as a polymodal version of K) with values in concept lattices of symmetric contexts. Assume that K is a finite symmetric context; then B(K) is a finite lattice, but it may not be a distributive lattice. Question: Assuming that B(K) is a finite distributive lattice, whether ALC with values in B(K) is a polymodal B(K)-ML?

In section 2 we represented the definition for description logic ALC with values in concept lattices of symmetric contexts and for positive fragment of ALC with values in arbitrary concept lattices. Questions: (1) Is decidable or axiomatizable the positive fragment of ALC with values in concept lattices? (2) Is decidable or axiomatizable ALC with values in concept lattices of symmetric contexts?

In the section 3 we examine 9 of 16 variants of context symmetrization. Topics for further research are following: (1) to study the remaining 7 cases of context symmetrization and isomorphic embedding with E c in one or two free quadrants; (2) to examine under which embedding from these in these 16 the induced semantics of the positive fragment of ALC is equal to the original semantics.

In [6] we present a method to compute all the closed sets and its minimal generators from a context. This information allows us to built a set of implications whose left had side is a minimal generator and with its closed set in the right hand side. We propose in this paper a definition of basis with the good minimality property of Duquenne-Guigues basis and the characteristics of the above implications: minimal information in the left had side and a fast computation of attributes closures from them.

We also introduce an automated method to calculate from a set of implications a left-minimal direct basis. The new method is based on the Simplification Logic for Funcional Dependency SL FD [?], a sound and complete inference system for implications. The main characteristics of SL FD is that its inference system is not built around the transitivity rule, like other well known Armstrong-like axiomatic systems for implications.

The work is organized as follows. In Section 2 we summarize preliminary concepts and results on FCA concerning implications, basis, etc. In Section 3 we outline the automated method that we have proposed in [6] for the computation of minimal generators and we introduce a new method to calculate the leftminimal direct basis from the original set of implications. The paper ends with a Conclusion Section.

We will use the well-kwon notation used on Formal Concept Analysis (FCA) [8].

For the analysis of the information contained in the context K = (G, M, I), a direction is the study of the pair (closed sets -minimal generators). The set of attributes A is said to be a minimal generator (mingen) if, for all set of attributes X ⊆ A if X = A then X = A.

A relevant notion in the framework of Formal Concept Analysis is the concept of attribute implication [8]. This area is devoted to obtain knowledge from a context that is a table in which attributes and objects are related. An attribute implication is an expression A → B where A and B are sets of attributes. A context satisfies A → B if every object that has all the attributes in A has also all the attributes in B. It is well known that the sets of attribute implications that are valid in a context satisfies the Armstrong's Axioms. Although the two interpretations of formulas (functional dependency and attribute implication) are different, they have the same concept of semantic entailment. [2] Alternatively, attribute implications allow us to capture all the information which can be deduced from a context. The set of all valid implications in a context may be syntactically managed by means of the following inference system known as Armstrong's axioms. An implication basis of K is defined as a set L of implications of K from which any valid implication for K can be deduced by using Armstrong rules.

The goal is to obtain an implication basis with minimal size. This condition is satisfied by the so-called Duquenne-Guigues (or stem) basis [9]. However, the definition of the Duquenne-Guigues basis refers to minimality only in the cardinality of the set of formulas, but as we have showed in [6] with an illustrative example, redundant attributes use to appear in this kind of minimal basis.

In the following, a summary of some interesting result of this survey are showed. More specifically we present the definitions of some characteristics studied in the survey that will be used to identify the kind of basis we introduce in this paper. In the practice, it is interesting considering some properties [5] related with minimality of them, in order to achieve efficiency. And finally the two characteristics that constitutes the center of our basis are introduced: Definition 2. Let Γ = {X 0 → Y 0 , . . . X n → Y n } be a set of implications, it is said a left-minimal basis if there does not exist a X i → Y i and a subset

A set of implications Γ and is said direct if for all implication A → B the set A ∪ B is a closed set w.r.t. Γ .

Some methods to obtain generators of closed sets have been studied in [7,12,13]. Moreover, minimal generators [10,11] appear in the literature under different names in various fields, for instance they are the minimal keys of the tables in relational databases. In [13], the authors emphasize the importance of studying minimal generators although "they have been paid little attention so far in the FCA literature".

We agree with these authors about the importance of the study of closed sets and minimal generators. They constitute a source of essential information to analyze a formal context. As we mention in the introduction, in [6] we illustrated the use of the Simplification paradigm to guide the search of all minimal generator sets. Thus, we introduce a method named MinGen [6] which computes a list of all pairs Φ =<closed set, minimal generators> from an arbitrary set of implications The goal of this paper can be considered as the reserve direction of the way we presented there. We will introduce a method to transform these set of pairs into a basis, preserving two good properties (fast computation of attribute closure and minimal left hand side in the implications) and providing minimality in the number of implications.Thus, our goal is to achieve from the minimal generators and closed sets a basis of implications fulfilling left-minimality and directness.

In the literature, the most cited algorithm to compute Duquenne-Guigues basis is the Ganter Algorithm [8]. Algorithm 1 is an adaptation of the algorithm showed in [3] to compute a Duquenne-Guigues basis from a set of LSI (labelled set of items) [6], and we obtain a Duquenne-Guigues basis. In the following example, we show how to link the above algorithm with the work presented in [6].

Example 1. For the input T = {ab → c, ac → bd, b → d, d → c}, Algorithm MinGen 0 (see [6]) returns Φ = {< abcd, {ab, ac, ad} >, < bcd, {b} >, < cd, {d} > } and from here Algorithm 1 renders Γ = {d → cd, b → bcd, ac → abcd}, which corresponds to a Duquenne-Guigues basis.

The following theorem ensures the minimality (w.r.t. the cardinality) of the Duquenne-Guigues basis.

Theorem 1. Any Duquenne-Guigues basis is a minimum basis.

In the following, we describe the algorihtm 2 to calculate a Left-Minimal Direct Basis based on Algorithm 1. The algorithm is polynomial and it is described searching a good understanding. Of course, an implementation using lectic order would improve considerably its efficiency.

First, we consider the following equivalence rules. direct basis. The study about the soundness, completeness, and complexity of the algorithms proposed are left to a extended paper. The new method uses some equivalences deduced in the SL FD Logic and follows the Lectic order to traverse the list of minimal generators and implications associated and return a set of implications but with good properties.

As future work we propose to extend the Duquenne-Guigues basis definition to consider a generalized fuzzy extension of implications. We propose the definition introduced in [2] that has been shown to be the most general one. In [4] a non trivial extension of the SL FD Logic for the generalized definition of fuzzy functional dependency was introduced. The generalized version of the SL FD Logic will be used to develop a method to get basis for the generalized fuzzy implications.

Algorithms on Real Data Lenka Pisková, Tomáš Horváth

University of Pavol Jozef Šafárik, Košice, Slovakia lenka.piskova@student.upjs.sk, tomas.horvath@upjs.sk Abstract. In this paper, an experimental comparison of publicly available algorithms for computing intents of all formal concepts and mining frequent closed itemsets is provided. Experiments are performed on real data sets from UCI Machine Learning Repository and FIMI Repository. Results of experiments are discussed at the end of the paper.

Formal Concept Analysis (FCA) [9] is a method for analysing data in the form of a table with applications in many disciplines.A formal concept is a formalization of the concept of a "concept" which consists of two parts, a set of objects which forms its extension and a set of attributes which forms its intension [25]. Formal concepts can be ordered according to the subconcept-superconcept relation resulting in a concept lattice.

Frequent itemset mining (FIM) introduced in [1] was proposed as a method for market basket analysis. The identification of sets of items (itemsets) which often occur together in a database (the frequency is not less than a user defined minimum support threshold) is one of the basic tasks in Data Mining. When the minimum support is set low, a huge number of itemsets is generated. To overcome this problem, closed and maximal frequent itemsets were proposed.

FCA and FIM are two research fields that are closely related to each other [20]. Naturally, they address similar problems, e.g. selecting important concepts versus finding interesting patterns in data. Moreover, they inspire each other (Iceberg concept lattice which is the set of all frequent concepts connected with the subconcept-superconcept relation [23]).

Finding the set of all intents (of formal concepts) is equivalent to finding the set of all closed frequent itemsets using a minimum support equal to zero [20]. Nonetheless, there is no experimental comparison between algorithms for computing formal concepts and algorithms for mining frequent closed itemsets. The aim of this paper is to provide such comparison on real-world data.

The problem of generating formal concepts and/or a concept lattice has been well studied and many algorithms have been proposed [8], [15], [17], [21], [22] comparative performance study of algorithms for building concept lattices can be found in [10] and [16]. In this paper we will focus only on those algorithms which compute the set of all formal concepts (frequent closed itemsets) only. Therefore, we do not compare our results with [10] and [16].

The fastest algorithms for computing formal concepts are FCbO [14] and In-Close [2] which are based on the CbO algorithm [15]. In the competition between FCA algorithms at ICCS 20091 FCbO took the first place and the runner-up was In-Close. The improvement of In-Close algorithm [3] was developed in response to the competition to outperform FCbO, but our results show that FCbO still performs better. A parallel variant of FCbO was also proposed [14], however, we consider only the serial version in this paper.

Implementations of algorithms for mining closed frequent itemsets were experimentally compared2 and presented at FIMI'03 and FIMI'04 workshops [12]. The best of the tested algorithms ( [5], [13], [18], [19], [24], [26]) was FP-Close [13] although it gave a segmentation fault for 4 out of 14 data sets.

In this paper, we provide an experimental comparison of 10 algorithms on real-world data sets whose implementations are publicly available, two of them compute formal concepts (FCbO and In-Close2) and the remaining 8 generate closed frequent itemsets ( [5], [6], [7], [13], [18], [19], [24]).

We have carried out a number of experiments for several real-world data sets to compare FCA and FIM algorithms that are publicly available. The characteristics of selected data sets [4], [11] are shown in the table 1. The experiments were conducted on the computing node with 16 cores equipped with 24 GB RAM memory running GNU/Linux openSUSE 12.1.

The measured times are CPU times. Each algorithm was run three times for each data set and the given minimum support threshold value to get the most accurate results. All reported times are the average times of the three runs. The output was turned off, i.e. the results of algorithms (intents of formal concepts/frequent closed itemsets) were neither written to a file nor to the screen. Some of the algorithms were originally developed to mine closed frequent itemsets. For Apriori, Carpenter and Eclat we have set the flag -tc to mine closed frequent itemsets. Similarly, we have used the flag -fci for Mafia.

The input file of In-Close2 is in the cxt (formal context) format while the input of other algorithms is in the standard FIMI format -each line represents a list of attributes of an object/a list of items in a transaction. The disadvantage of In-Close2 is that unlike other algorithms it also computes extents of formal concepts (in addition to their intents).

Some algorithms had problems on certain data sets. For mushroom, Apriori gets killed, Carpenter outputs an incorrect number of closed frequent itemsets (238827), DCI Closed does not calculate the result in a reasonable time (we have stopped the computation after a few hours). In-Close2 gives an incorrect number of formal concepts (59343) for tic-tac-toe.

For kosarak, FPClose is either aborted due to the invalid pointer or gives segmentation fault for the support 0.8% and supports less than or equal to 0.6%. For retail with minsup = 0, Apriori gets killed, Carpenter gives an incorrect number of closed frequent itemsets (2186693) and DCI Closed is aborted. In-Close2 gives segmentation fault for the supports lower or equal to 60% on accidents and for all supports except for 90% on connect. We have compared the performance of the algorithms for mining intents of all formal concepts, i.e. closed frequent itemsets using minsup = 0 (typical task in FCA) on small data sets. The results are depicted in the table 2. Arguably, FCbO is the best algorithm for the given task, it is the fastest algorithm for car and mushroom and the third fastest for tic-tac-toe. LCM and Eclat perform well on these data sets, too. Considering also the results on retail with minsup = 0, LCM is the fastest algorithm and the runner-up are Eclat and FPClose. Other tests were performed on big data sets and the performance of algorithms was tested for various values of support. Figures 1 and 2 show the timings for the algorithms on the accidents, connect, kosarak and retail data sets. The performance of the FCbO algorithm is average on big data sets except for kosarak. Eclat, DCI Closed and FPClose are good choice in the case of dense data sets (accidents, connect). However, the runtime of most algorithms increases dramatically with decreasing minimum support on these data sets. Afopt, DCI Closed and LCM are suitable for sparse data sets (kosarak, retail) although the Afopt algorithm is not able to handle the retail data set for minsup = 0. The timings for In-Close2 on kosarak are not included, because the computation took several hours just for high values of support .

For kosarak, in our experimental testing FPClose failed while FPClose was the fastest algorithm for low as well as high values of support in [12]. Our results on other data sets correspond to some extent to the results in [12].

We have experimentally compared algorithms for computing intents of formal concepts and algorithms for mining closed frequent itemsets on real-world data. Our experimental testing has no clear winner for different data sets and minimum support threshold setting. In our opinion, DCI Closed behaves well although it had some problems on the mushroom data set and the retail data set with minsup = 0. On small data sets, the fastest algorithm is FCbO.