A Fast Implementation for the Typical Testor Property Identiﬁcation Based on an Accumulative Binary Tuple

In this paper, we introduce a fast implementation of the CT EXT algorithm for testor property identiﬁcation, that is based on an accumulative binary tuple. The fast implementation of the CT EXT algorithm (one of the fastest algorithms reported), is designed to generate all the typical testors from a training matrix, requiring a reduced number of operations. Experimental results using this fast implementation and the comparison with other state-of-the-art algorithms that generate typical testors are presented.


Introduction
Feature selection is a significant task in supervised classification and other pattern recognition areas.This task consists of identifying those features that provide relevant information for the classification process.In Logical Combinatorial Pattern Recognition (Ref. 1,2), feature selection is solved by using Testor Theory (Ref. 3 ).Yu. I. Zhuravlev introduced the concept of testor to pattern recognition problems (Ref. 4).He defined a testor as a set of features that does not confuse objects descriptions belonging to different classes.This concept has been extended and generalized in several ways (Ref. 3).
The compute of all typical testors is a procedure which have exponential complexity (Ref. 10).Different approaches have been developed, including: genetic algorithms (Ref. 11), and distributed computing (Ref. 12).Recently, implementations for feature-selection algorithms over FPGA-based embedded systems have been developed (Ref. 13,14).
Typical testors have been widely used to evaluate the feature relevance (Ref. 15) and as support sets in classification algorithms (Ref. 16).In text mining, they have also been used for text categorization (Ref. 17) and document summarization (Ref. 18).
Unlike other methods for feature selection, typical testors have no confusion errors, due to they do not confuse objects of different classes.
But even though the application of these techniques, the running time of existing algorithms continues to be unacceptable owing to several problems which are dependent mainly, of the number of features of training matrix.
The present paper introduces a fast implementation of the CT EXT algorithm, using a binary accumulative tuple, which simplify the search of feature combinations which fulfill the testors property.
The algorithm CT EXT was selected for incorporating the accumulative tuple, because it is one of the fastest algorithms reported in the state of the art (Ref. 19,20).
The classic concept of testor, in which classes are assumed to be both hard and disjointed, is used.The comparison criteria used for all features are Boolean, regardless of the feature type (qualitative or quantitative).The similarity function used for comparing objects demands similarity in all features.These concepts are formalized in the following section.
Preliminary results of this algorithm were presented in (Ref. 21), but this version incorporates the following: a) explains in detail the work from V. Valev and collaborators who have made important contributions to the field of typical testors.b) the article published in (Ref. 21) introduces Typical Testors quiet briefly.This new version incorporates an entire 3-page section (Section 2), with the formalization of Typical Testors by means of: two tables, ten definitions, five remarks, one example, three matrices, three theorems, and two proofs.c) the article introduced in (Ref. 21) required barely a couple of paragraphs to introduce state-of-the-art algorithms useful to find all the typical testors.This version incorporates an entire section (Section 3) to talk about these algorithms, including its limitations.d) this version includes a proposition and its proof, in Section 4. e) section 4 dedicates three pages to a detailed example that compares three kinds of algorithms useful to find typical testors.f) some parts of section 5 was rewritten.g) section 6 (Experiments) was entirely rewritten, and finally, h) a key idea to extend the proposed algorithm in a near future was added in Conclusions Section.

Typical testors
where U is the universe set of objects), be a training matrix containing m objects, described in terms of n features Each object O ∈ T M has associated a c-tuple of membership, which describes the belonging of the object O to the classes 22 ).Table 1 shows the general scheme of a training matrix.
Some of the following definitions were taken from: (Ref. 3,23,22,6,7) Definition 1.If some feature subset T ⊆ R does not confuse any two descriptions of objects belonging to different classes of training matrix, then T is called testor (descriptor).Definition 2. If in a certain testor T , after removing any attribute x i ⊂ R, T confuses some two de-scriptions of objects belonging to different classes of training matrix, then T is called typical testor (nonreducible descriptor (NRD)), and denoted by TT.
That means that each TT cannot be reduced any more (Ref. 23,6).Thus each TT is of minimal length.Besides, each TT may distinguish any object description from the descriptions of the objects belonging to the remaining classes (Ref. 24,23).In order to ilustrate the above definitions, we present the follow example, which was taken from (Ref. 9 ) Example 1. Patients are characterized as suffering from strep throat or flu depending on the presence or absence of a combination of the following symptoms: sore throat (x 1 ), cough (x 2 ), cold (x 3 ), and fever (x 4 ).Let K 1 denote the class of patients suffering from strep-throat, and K 2 , the class of patients suffering from flu.The training matrix (shown in table 2) consist of information pertaining to seven patients, the first two in K 1 , and the last five in K 2 .The information pertaining to each patient is represented as a row in the training matrix.A 1 in a particular column represents the presence of the corresponding symptom, and a 0 represents the absence of that symptom.Note that In the training matrix of patients, the set of features {x 1 , x 2 , x 4 } is a testor.Also, the set {x 1 , x 4 } is a typical testor of this training matrix.
We can observe that if we handle only the features of the typical testor {x 1 , x 4 }, the descriptions of patients belonging to different classes are not confused on the training matrix.
This would mean that, based on the symptoms and diagnosis of the patients, only with the information about sore throat and fever is sufficient to diagnose a patient with strep throat or with flu.For this particular training matrix, the presence of sore throat and the absence of fever are sufficient to diagnose a patient with strep throat.
Let us consider the problem of obtained the TT set of a TM.Definition 3. The dissimilarity matrix (denoted by DM) of the objects O i ∈ T M, is a Boolean matrix, where their rows are obtained by feature comparison (using dissimilarity comparison criteria D) of every pair of objects from TM belonging to different classes.
Remark 2. If the objects under comparison are not similar in terms of a feature, a value of 1 is assigned in the corresponding row and column of DM.If this is not the case, a value 0 is assigned.
The DM of the objects of the training matrix of patients was obtained for all the features (e.g.s = 1, 2, 3, 4), using the comparison criterion D s shown in (2).The DM built is the follow: The first row of the DM above was obtained from comparing O 1 and O 3 .In the same way, the second row was obtained comparing O 1 and O 4 , the third row by the comparison of O 1 and O 5 , and so on.Finally, last row was obtained by the comparison of O 2 and O 7 .
Remark 3. It is computationally faster to work with the DM instead their belonging TM.Because, in order to create the DM, the comparison between two arbitrary objects of TM is performed only once, and the DM is a Boolean matrix.
Remark 4. Notice that the number of rows in DM is where card(K i ) denotes the number of objects in the class K i .
Let p and q be two rows of DM.

Definition 4.
The row p is a subrow of q if: ∀ j [q j = 0 ⇒ p j = 0] and ∃ i [p i = 0 ⇒ q i = 1] Definition 5. A row p of DM is called basic if no row in DM is a subrow of p Definition 6.A matrix containing all the basic rows of DM (without repetitions) is called a basic matrix, and denoted by BM.
The BM obtained of the DM (1) is the following: Only rows 7 and 8 of DM (1) are basic, and then BM (4) is composed only by these rows.
Remark 5.The typical testor set of a TM can be obtained by using DM or BM.A theorem showed in (Ref. 23) proves that the set of all typical testors generated from the use of DM or BM is the same.And it is shown as follows: Let τ(DM) be the set of all typical testors of a training matrix TM that uses its belonging dissimilarity matrix DM.And let τ(BM) be the set of all typical testors of the same the training matrix TM that uses its corresponding basic matric BM.
Commonly, algorithms used for computing typical testors make use of BM instead of DM, due to the substantial reduction of rows (see remark 4) Now, the characterization of a typical testor working with the basic matrix is presented.
Definition 7 means that a subset of columns of a matrix form a covering, if in this subset of columns, no row has only zeros.
Let matrix Z be created from a subset of columns of the basic matrix BM, generated from TM.
Proof.As the columns j 1 , • • • , j d form a covering of BM, by definition 7, any row of the matrix Z contains only zeros.Then, every row of Z has at least a 1.By definitions 3 and 6, and remark 2 all the objects compared are not similar.Therefore, no object of TM described by the feature set Theorem 2 means that a testor is a subset of features T = {x i 1 , • • • , x i s } of TM for which a whole row of zeros does not appear in the remaining submatrix of BM, after eliminating all the columns corresponding to the features in R\T .
belonging to the basic matrix BM are called compatible elements, if:

Published by Atlantis Press
Copyright: the authors 1028 Example 2. The matrix Z formed by the rows 1 and 2, and columns 1 and 4 belonging to BM (4), which form a SCE 2 is the following: Then, TT no longer meets the ownership of testor.Therefore, the testor TT cannot be reduced, and by definition 2, TT is a typical testor.
Theorem 3 means that TT is a typical testor if there is no proper subset of TT that meets the testor condition.
Columns j 1 , j 3 , j 4 of BM (4) form a covering of this matrix, and then, the feature set T = {x 1 , x 3 , x 4 } is a testor of TM of patients.However, T is not a typical testor, because it cannot be formed in DM a SCE d , with d = 2.But columns j 1 , j 4 form a covering of DM, and there are elements a [1, 4], a[2, 1] which form a SCE d , with d = 2. Therefore, the feature set T = {x 1 , x 4 } is a typical testor of TM of patients.

Algorithms for computing typical testors
In general, finding all typical testors of a training matrix is the equivalent of conducting an exhaustive search of all feature subsets.As the number of rows, columns or classes increases, the runtime required by this procedure increases too until it becomes impossible to compute.Clearly, this is a very inefficient procedure for cases in which the number of features is not too large (Ref. 25,26).
Internal-type algorithms are based in the combinatorial construction of sequence of compatible elements (SCE) in Basic Matrix, subsequently to verify if the corresponding columns of previous combination satisfies covering property.Or these same steps in reverse order.Some examples of these algorithms are: CC (Ref. 28) and CT (Ref. 27).
These algorithms have the disadvantage of generating many repetitions of feature combinations.
External-type algorithms directly construct feature combinations to analyze from an empty subset of features.New attributes are then added to the same combination in order to verify if: a) they form a SCE d , and b) the columns satisfies the covering property.Whereas internal-type algorithms start with the entire set of features, and generates several subsets as a result of removing some features subsequently, to verify the properties listed above.
Besides, external-type algorithms do not generate all possible feature combinations as the exhaustive-search algorithms.Instead, these algorithms employ the idea of jumping over possible feature combinations using different properties of testors because these feature combinations cannot be typical testors.Examples of this kind of algorithms include the following: BT and TB (Ref. 24), LEX (Ref. 29), Asaithambi (Ref. 8), CT EXT (Ref. 19) and BR (Ref. 20).
In both kind of algorithms, the calculation of all typical testors takes exponential time (Ref. 22).
In addition with above facts about external algorithms, LEX, CT EXT and BR incorporate into

Published by Atlantis Press
Copyright: the authors 1029 the feature set under construction only those features that allow the construction of sequence of compatible elements (SCE) in Basic Matrix (LEX and BR), to verify subsequently if the columns of this combination satisfy the covering property.On the other hand, they incorporate only those features that can satisfy the covering property (CT EXT), to verify subsequently if a sequence of compatible elements (SCE) exists in the combination constructed.
As alternative approaches, embedded systems based on a FPGA architecture were developed (Ref. 13,14).These architectures are able to evaluate if a feature combination fulfills the testor or typical testor property in a single clock cycle, using an exhaustive algorithm, or the external-type algorithm BT.In each step, this architecture needs the same time to process a matrix of N columns, independently of the number of rows.
The fast implementation of CT EXT simplifies the search and construction of a feature combination which satisfies the typical testor property.

Definitions and propositions of fast implementation of CT EXT algorithm
The bases of the fast implementation of the CT EXT algorithm are presented below.Follow the notation used in (Ref. 20), let V = (a 1 , a 2 , • • • , a u ) be a binary u-tuple of elements, a i ∈ {0, 1}, i = 1, • • • , u.The column corresponding to a feature x i ∈ BM is a binary u-tuple, denoted by V x i , whose cardinality is the number of rows in BM.
x i s ∈ R is used to represent an ordered list of features.A list L that does not contain features is denoted as [ ] (empty list).
We call the length of a list L, denoted as len(L), to the number of features in the list.All basic operations of the set theory (difference, intersection, subset or sublist) can be defined on ordered lists of features in a similar way.
We denote the concatenation between ordered lists of features with the + symbol.
We call accumulative mask of L, denoted as am L , to the binary tuple in which the i th element is 1 if the i th row in BM has at least a 1 in the columns corresponding to the features of L, and it is 0 otherwise.
We call contribution mask of L in feature x i q ∈ L, denoted as cm L,x iq , to the binary tuple in which the i th element is 1 if the i th row in BM has only a 1 in the column corresponding to the feature x i q , and none in the columns belonging to the remaining features, and it is 0, otherwise.
Notice that the cardinal of both am L and cm L,x ip is the number of rows in BM.
The accumulative and contribution masks in the features x 2 , x 4 , x 5 , x 4 are the following: be a feature list and x i q ∈ R, x i q ∈ L. The accumulative mask of the list L + [x i q ] is calculated as follows: am L+[x iq ] = am L ∨V x iq (10)   Published by Atlantis Press Copyright: the authors 1030 where V x iq denotes the column corresponding to feature x i q ∈ BM Proof.We have two cases.a) the binary u-tuple am L in the i th element has a 0, and V x iq in its same i th element has a 1.To perform the operation am L ∨V x iq , this u-tuple in its i th element will now have a 1. b) both the binary u-tuple am L and V x iq in its i th element has a 0. In this case, to perform the operation am L ∨ V x iq , this u-tuple in its i th element maintains the value of 0.
For the case in which u-tuple am L in the i th element has a 1, the value of V x iq in its i th element is irrelevant, because when performing the operation am L ∨ V x iq , this u-tuple in its i th element retains the value of 1.
be a feature list and x i q ∈ R, x i q ∈ L. The contribution mask of the list L + [x i q ] in the feature x i q is calculated as follows: Proof.If the i th element of tuples am L and V x iq are 0 and 1, respectively, this will be the only case in which the operation ¬am L ∧V x iq sets the i th element of the binary tuple am L as 1, according to table 3.
For the remaining cases, to perform the operation ¬am L ∧V x iq , this u-tuple in its i th element will has a 0. Thus, the u-tuple cm L+[x iq ],x iq meets definition 12.
Notice that propositions 4 and 5 allow the updating of accumulative and contribution masks, respectively, when a new feature is added to a feature list.
is a testor, thus by definition 1, the feature set {x i 1 , • • • , x i s } does not confuse any two descriptions of objects belonging to different classes of training matrix.In terms of a DM derived of their belonging TM, by remark 3, when two objects are not similar in terms of a feature, a value of 1 is assigned in the corresponding row and column of DM.This means that for a testor, there are not row has only zeros in columns i 1 , • • • , i s of DM.
(⇐) As each element of the u-tuple am L has a 1, by definition 11, each row of BM has at least a 1 in the columns corresponding to the features of L. This means that columns i 1 , • • • , i s form a covering of BM.
Thus, by theorem 2, the set of features be a feature list and x i q ∈ L. A row p in BM is a typical row of x i q as regards of L, if it has a 1 in the column corresponding to x i q and zero in all the columns corresponding to the features in L\ is a typical testor if and only if L is a testor and for every feature x i q ∈ L there is at least a typical row of x i q with respect to L.

Proof.
(⇒) is a typical testor thus, by definition 2, L is a testor which can not be removed any attribute x i q , q = 1, ..., s.
Once again, in terms of a DM derived of their belonging TM, by remark 3, when two objects are not similar in terms of a feature, a value of 1 is assigned in the corresponding row and column of DM.
This means that for a typical testor, for each x i q ∈ L, exists at least one row in DM such that it has a 1 in the column corresponding to x i q and zero in all the columns belonging to remaining features of L.
By definition 13, for each x i q ∈ L there is at least a typical row of x i q with respect to L, applied over DM.
(⇐) As every feature x i q ∈ L has at least a typical row of x i q with respect to L, then a sequence of compatible elements SCE d , can be constructed over BM with d = len(L).
Since L is a testor, and there is a SCE d , d = len(L), thus, by theorem 3, the set of features The CT-EXT algorithm (Ref. 19) has the following theoretical bases.
We say that row p in BM, is a zero-row of L, denoted by p 0 , if it has a 0 in all the columns corresponding to the features of L.
be a feature list and x i q ∈ R, x i q ∈ L. We denote the number of zero rows of L by ∑ L p 0 .We say that x i q contributes with L if and only if ∑ L+[x iq ] p 0 < ∑ L p 0 Proposition 8. Let T ⊆ R and x j ∈ R, x j ∈ T .If x j does not contribute to T, then T ∪ {x j } cannot generate any typical testor.
If T is a testor, then T ∪ Z is a testor as well, but is not a typical testor.Now, for the fast implementation of the CT EXT algorithm we have the follow propositions and theorems.
Proposition 10.The feature x i q ∈ R, x i q ∈ L contributes with L if and only if Proof.By definition 15, a feature x i q contributes with L, if the number of zero rows decreases considering L + [x i q ] instead of only L. By proposition 5, equation ( 12) has a value of 1, if and only if, at least a 1 appears in contribution mask of L + [x i q ].And this occurs only if the number of rows of zeros decreases when the contribution mask of this list is calculated.Therefore, feature x i q contributes with L, if and only if equation ( 12) takes a non-zero value.
Propositions 8 and 9, are re-writen in terms of Propositions 10, 6 and 7, in the following way.
be a feature list and x i q ∈ R, x i q ∈ L. If x i q does not contribute with L, then L + [x i q ] cannot generate any typical testor.
Proof.As x i q does not contribute with L, this means that: a) there is not typical row of x i q with respect to L+[x i q ].Thus, L+[x i q ] does not satisfy proposition 7; b) it exists the i th element in the accumulative mask of L+[x i q ] which has a 0. And then, the i th row in BM has only zeros in the columns belonging to the features of L + [x i q ].Thus, L + [x i q ] does not satisfy propositions 6 and 7.
Therefore, L + [x i q ] cannot generate any typical testor.
0 be a feature lists.If L is a testor, then L +W is a testor too, but it is not a typical testor.
Proof.As L is a testor, then am L = (1, • • • , 1).Then, no feature of W contributes with L. Thus, by Theorem 11, L +W is not a typical testor.
And, by proposition 4, the accumulative mask of L + W is the same as that of L.Then, L + W is a testor too.
Example 4. In this example, we present a comparison between the procedures of three algorithms that finds typical testors, to determine whether a subset of features is a typical-testor: a) BT (Ref. 24,30), b) CT EXT (Ref. 19), and c) the proposed fast implementation (Ref. 21).The first one finds typical testors in a defined search space.The second, incorporates the contribution of an feature in a previous combination of attributes, to verify if it fulfills the typical-testor property.Finally, the last uses the accumulative binary tuple, to verify the same property in a feature combination.This example takes the BM (9), and two combinations of features: {x 1 , x 2 , x 3 } and {x 1 , x 4 , x 5 }, checking if any of them satisfy the property of being typical-testor.
The space search with five features of algorithm BT is as follows: It starts at [0, 0, 0, 0, 1] which represents [x 5 ], and ends at
If this feature combination does not comply with Theorem 2, then it is not a testor, and a jump in space search is made.Now, the feature combination to analyze is [1, 0, 0, 0, 1] ([x 1 , x 5 ]).
Following this procedure, it leads us to analyze the following combination of attributes: [1, 0, 0, 1, 1] ([x 1 , x 4 , x 5 ]), and to check whether columns 1, 4 and 5 form a covering of MB.For this particular case, this combination does not comply with Theorem 2, therefore, it is not a testor.
After analyzing the above combination, the BT algorithm considers the following combinations of attributes in the search space: reaching the following combination of features: ]), and checking whether columns 1, 2 and 3 form a covering of MB.This combination of features complies with Theorem 2 and then, verifies if rows of BM forms a sequence of compatible elements (see Theorem 3).As this combination of features complies with Theorem 3, then it is a typical-testor.
The algorithm BT continues until reaching and verifying the combination ), finishing at this point.

Algorithm CT EXT
Starting at [x 1 ], the feature list L = [x 1 ] is generated.Then, the number of zero rows in BM, considering L = [x 1 ], is counted; for this case, it results ∑ L p 0 = 3 (see definition 14).
Following the order of search for the next feature that will contribute with L, the algorithm now considers L + [x 2 ].Likewise, it counts the number of zero rows with L + [x 2 ], resulting the following: As ∑ L p 0 = 0, columns 1 and 2 do not form a covering of BM (see Theorem 2), so the algorithm continues the search of next feature that will contribute with L, now considering the feature list as L + [x 3 ].Then, it counts the number of zero rows with L + [x 3 ], resulting: ∑ L+[x 3 ] p 0 = 0.As ∑ L+[x 3 ] p 0 < ∑ L p 0 feature x 3 contributes with L, then it is updated: L = [x 1 , x 2 , x 3 ].As ∑ L p 0 = 0 columns 1,2 and 3 form a covering of BM, thus {x 1 , x 2 , x 3 } is a testor of BM.Since the rows of BM

Published by Atlantis Press
Copyright: the authors 1033 considering this combination of features, form a sequence of compatible elements, then it is a typical testor.
Following this procedure, it lead us to search the next features that will contribute with L, to generate the lists: As ∑ L p 0 = 0 then columns 1 and 4 do not form a covering of BM; so, the algorithm continues the search of the next feature that will contribute with L, now considering the feature list as L + [x 5 ].Then, it counts the number of zero rows with L + [x 5 ], resulting: ∑ L+[x 5 ] p 0 = 1.As ∑ L+[x 5 ] p 0 < ∑ L p 0 feature x 5 contributes with L, which is updated as L = [x 1 , x 4 , x 5 ].But ∑ L p 0 = 0, so columns 1, 4 and 5 do not form a covering of BM; however, there are not more features that may contribute to the list L. In this case, L is not a testor.
The algorithm CT EXT continues until reach and verifies the list L = [x 1 , x 5 ], finishing on this point.

Fast implementation proposed
Like the CT EXT algorithm, the fast implementation of CT EXT starts at [x 1 ], so the feature list L = [x 1 ].Then, the accumulative mask of L is generated as follows (see definition 11): am L = (1, 0, 0, 0).But am L = (1, 1, 1, 1), therefore L is not a testor (see Proposition 6).Remark 6. Illustratively in this example, the accumulative mask of L is shown as a binary tuple.However, it was implemented bitwise in the algorithm by means of 32-bit unsigned integers.For example, in the case of am L = (1, 0, 0, 0), the implementation in hexadecimal format is amL = 8000h, which is equivalent to decimal format amL = 2 31 = 2147483648.This is because the operations OR, AND and NEG are performed bitwise among unsigned integers variables.
Following the order of search for the next feature that will contribute with L, the algorithm now con-siderates L + [x 2 ].Then, the contribution mask of L + [x 2 ] is generated as follows: (see Proposition 5) cm L+[x 2 ],x 2 = (0, 0, 1, 1).
The procedure of searching the next feature that will contribute with L is continues; for this case, this feature is x 3 .Then, the contribution mask of L + [x 3 ] is: cm L+[x 3 ],x 3 = (0, 1, 0, 0).
As cm L+[x 3 ],x 3 = 0, feature x 3 contributes with L, and the accumulative mask of L Since am L = (1, 1, 1, 1) then L is a testor.After that, it is verified whether for each feature x 1 , x 2 , x 3 ∈ L, there is at least one typical row in BM (see proposition 7).For this case, L = [x 1 , x 2 , x 3 ] is a typical testor.
Just like the algorithm CT EXT, the fast implementation leads us to search the next features that will contribute with L, producing the lists: ], and L = [x 1 , x 3 , x 5 ], reaching list L = [x 1 ], and considering x 4 as the next feature to analyze.The accumulative mask of L is generated am L = (1, 0, 0, 0).Then, the contribution mask of L + [x 4 ] is generated cm L+[x 4 ],x 4 = (0, 0, 1, 0).
The procedure of seraching the next feature that will contribute with L is continues; for this case, this feature is x 5 .Then, the contribution mask of L + [x 5 ] is: cm L+[x 5 ],x 5 = (0, 1, 0, 0).
As cm L+[x 5 ],x 5 = 0, feature x 5 contributes with L, and the accumulative mask of L However, there are not more features that may contribute to the list L. In this case, L is not a testor.The fast implementation continues until reaching and verifying list L = [x 1 , x 5 ], finishing at this point.
The above example shows the procedure capable to determine whether a subset of features is or not a testor.The algorithms that do not use accumulative tuples (BT and CT EXT), always verify whether • Step 7: Select a new feature to analyze.-Select the next feature that was not concatened in the current combination.If j < n then j = j + 1, and go to step 4. Otherwise, go to step 6.

Experiments
In order to evaluate the performance of the fast implementation of CT EXT algorithm using the binary accumulative structure, a comparison with four algorithms reported in the literature (BT, CT, LEX and CT EXT) was made.The first algorithm selected is a classical external type algorithm, which uses the last reported algorithm that incorporates several improvements in performance (Ref. 30).The second algorithm is a classical internal type algorithm (Ref. 31).The third algorithm, LEX, is reported with a very well runtime among classical algorithms (Ref. 29).Finally the algorithm CT EXT, which is one of the fastest algorithms, is reported too (Ref. 19).
Please notice that comparisons with BR algorithm (Ref. 20) are not shown.This is because we were not endowed with the source code of the BR implementation as we kindly requested to the authors, but only with an application which is unable to read previously-defined DM and BM; instead, it works with randomly-generated ones.
We have employed several BM with different dimensions to compare the runtimes of the algorithms, Two of them were taken from real medical diagnosis problems.In table 4, the experimental results obtained with the algorithms are shown.
In the table, the size of the basic matrix is denoted as rows × columns; AL denotes the algorithm; LX denotes the algorithm LEX; CX represents the algorithm CT EXT; FI denotes the fast implementation of the CT EXT; and finally, TT denotes the number of typical testors found by each algorithm.The experiments were conducted in a Pentium IV, with 2Ghz, and 1 Mbyte of RAM.The runtime are measured in seconds.In addition, we evaluate the performance of the algorithm CT EXT and the fast implementation proposed.We handled four real databases, obtained from UCI Machine Learning Repository (Ref. 32).These databases are the following: Zoo database; Mushroom database; Chess (King-Rook vs. King-Pawn), denoted by Kr vs Kp; and Molecular Biology (Promoter Gene Sequences), denoted by Promoters.In table 5, experimental results obtained from these databases are shown.
In the case of Promoters database, several basic sub-matrices were calculated from the original basic matrix because of its large size: 2761 rows x 57 columns.The third and fourth columns contain, respectively, the runtime of algorithm CT EXT and the runtime of the fast implementation.For table 5, the notation used is the following: M rows×columns which denotes the data base in use and its dimensions; BM-S denotes the size (rows x columns) of the basic matrix obtained from its belonging training matrix; CX-T and FI-T represent, respectively, the runtime of algorithm CT EXT and the fast implementation; finally, TT denotes the number of typical testors found.In table 5, we can observe that the fast implementation proposed achieves important reductions in runtime: among 80% and 98% regarding the al-

Published by Atlantis Press
Copyright: the authors 1036 gorithm CT EXT.
In order to have a clear idea about the behavior of the algorithm CT EXT and its fast implementation, we have shown: a) the runtimes (in seconds) using a 57-column Basic Matrix, varying the number of rows from 100 to 1000, in Figure 1, and b) the runtime using a 50-row Basic Matrix, varying the number of columns from 25 to 100, in Figure 2.

Conclusions
In this paper, a fast implementation of the algorithm CT EXT that facilitates the identification of all typical testors from a training matrix was suggested.
The fast implementation -developed in this work over the algorithm CT EXT algorithm-is feasible to be adapted to other algorithms which calculated the typical-testor set from a training matrix.
The main contribution of the fast implementation is to keep the information of each new feature to be processed, which allows to quickly verify whether a feature combination fulfills the testor property, this is due to the fact that the algorithm proposed uses simple logical operations, implemented bitwise.
Based on experimental results, we can conclude that the fast implementation proposed improves the performance of the CT EXT algorithm.
The fast implementation proposed, does not contemplate the inclusion of noise in BM, because a sensitivity analysis (as is presented in (Ref. 33)) must be performed, which is beyond the scope of the paper.
Finally, our work will continue in adapting the fast implementation to a Field Programmable Gate Array (FPGA) to perform the calculation of all the typical testors.

Remark 1 .
Both Ruiz-Shulcloper and Valev define typical testors (NRD) as properties of objects.However, for Valev, each object of the training matrix has associated a set of TT (NRD).On the other hand, for Ruiz-Shulcloper, all objects in each class of the training matrix have associated a set of TT (NRD) too.

(
ii) for d > 1, each pair of elements is a pair of compatible elements.Definition 9 means that the matrix Z formed by the rows i 1 , • • • , i d and columns j 1 , • • • , j d comprises only one unit in each row and each column.Definition 10.The number of compatible elements d of a SCE is called a rank of this SCE and it is denoted by SCE d 4 ], and L = [x 1 , x 3 , x 5 ], and to reach the list: L = [x 1 ], considering x 4 as the next feature to analyze.Likewise, it counts the number of zero rows with L+[x 4 ], resulting: ∑ L+[x 4 ] p 0 = 2.As ∑ L+[x 4 ] p 0 < ∑ L p 0 feature x 4 contributes with L, and it is updated L = [x 1 , x 4 ].

Fig. 1 .
Fig. 1.Runtime in seconds of CT EXT algorithm and the fast implementation, as the number of rows increases

Table 1 .
General scheme of Training Matrix

Table 3 .
Value table for contribution mask

Table 4 .
Run time execution in seconds of several algorithms

Table 5 .
Execution time in seconds of the algorithm CT EXT and their fast implementation, handling several real databases