Orthogonal Block Change & Block Building Using Ordered Lists of Ternary Vectors

Transcription

1 Orthogonal Block Change & Block Building Using Ordered Lists of Ternary Vectors Christina Dorotska, Bernd Steinbach Freiberg University of Mining and Technology, Institute of Computer Science, D Freiberg, Germany, {dorotsk, Abstract. In this paper we investigate the possibility of efficient minimization of number of vectors in lists representing Boolean functions. We use the representation of a function as an ordered list of ternary or Boolean vectors and propose a faster algorithm that is based on ordering of vectors. We sort the vectors in lists using the number of ones and dashes to create classes and subclasses. This model is used to speed up the optimization of orthogonal vector lists, an algorithm known as block change & block building. Unlike the algorithm used in XBOOLE system this algorithm uses additional knowledge from the ordered model and changes only blocks, that lead to new possibilities of block building. Our new algorithm is compared with algorithm, used in XBOOLE system, and finally it is shown by means of experimental results that our algorithm with ordering of vectors requires fewer comparisons to find a new block building possibility. 1. Introduction As representation of Boolean function this paper uses Ternary Vector List (TVL), TVLs are based on the data structure called Binary Vector List (BVL) [1]. A binary vector consists of elements ZERO and OE. The BVL data structure represents a Boolean function including all this vectors in the list, for which the function has the value OE. In the most unfavorable case 2 n vectors may be also necessary to represent a Boolean function with BVL. Using of Ternary Vector Lists make it possible, to reduce this number of vectors, because a TVL may represent all Boolean vectors of a BVL by a smaller number of vectors. It may be achieved thanks to using the third element DASH (in previous papers [2, 3, 6-8] mark as a STROKE) in ternary vectors. The DASH is able to present a OE or a ZERO [2]. The minimization of the number of vectors in the Ternary Vector List is based on building blocks of ternary vector [4]. Every two vectors that differ in one place only are combined into a single ternary vector that contains DASH in the place of difference. If a TVL does not include a pair of vectors that can build a block, the Block Change operation can be used. Its main objective is to find all pairs of ternary vectors that can be converted to other pairs of ternary vectors, that may be later applicable to build a block. Block Change operation can be also extend with Block Building operation. There exists an very simple algorithm to process Block Change & Block Building, which is a part of the system XBOOLE. All pairs of ternary vectors taken from the two special lists have to be compared. In the case that these vectors can be convert to other ternary vectors, the Block Changing is executed. After all pairs of vectors were checked, a Block Building algorithm [2, 3, 7] reduces the number of vectors in the list through combining the matching vectors to vectors with more dashes. The disadvantage of this simple algorithm is the time consuming large number of comparisons between vectors. The aim of this paper is speed up the process of the minimization of the number of vectors in the list. We have created an ordered data structure called Ordered Ternary Vector List (OTVL) to represent a Boolean function. Owing to the ordering of ternary vectors into classes and subclasses the number of necessary comparisons during block building [7] and block change & block building procedures can be reduced. The rest of the paper is organized as follows. Section 2 gives the basic knowledge of block building and block change algorithms. Section 3 introduces improvements of the data structure Ordered List of Ternary vectors (OTVL). In section 4 the block change and the block building algorithms are represented at first separately and after that two as complete orthogonal block change & block building (OBCBB) algorithms. In section 5 we compare the results of employing of this two OBCBBalgorithms. Finally, in section 6, we summarize our paper.

2 2. Preliminaries A TVL may represent all Boolean vectors of a BVL by a smaller number of ternary vectors. One single ternary vector, which contains only dash elements, describes all 2 k Boolean vectors of the Boolean space. The set of Boolean vectors collected in one ternary vector can be reconstructed, if the dashes in the ternary vector are substituted by all possible patterns of zero and one elements. Two different Boolean vectors of the same length are called orthogonal. Two ternary vectors have the property of orthogonality, that means they are disjoint, if there exists no Boolean vector included in both ternary vectors. This property is satisfied, if these ternary vectors have a 0/1 combination in at least one column. The ternary vectors t 1 = 01- and t 2 = 11- for example, have a 0/1 combination in the first column. Vector t 1 includes the binary vectors { 010, 011 } and t 2 includes { 110, 111 }. There is no Boolean vector included in both sets. Therefore, t 1 is orthogonal with respect to t 2. An TVL is orthogonal if each pair of ternary vectors in the TVL is orthogonal (disjoint). Definition 1. If two ternary vectors (two lines) of a orthogonal TVL differ in exactly one column, in which the combination 0/1 is present, both TV s can be combined into one TV. This operation is called orthogonal block building (OBB), because the new ternary vector is orthogonal to other ternary vectors in this TVL. Example 1. Ternary vectors 0-0 and 1-0 have the 0/1 combination in the first column and can be merged into the ternary vector The reader can learn more about Orthogonal Block Building in [7]. To speed up the processing of many Boolean operation and to minimize the necessary memory space to store a TVL the number of vectors in the TVL can be reduced further, even no more block buildings are possible. Definition 2. If two ternary vectors are different in two positions, when the first one is a 0/1 combination, and the second is a 0/- or 1/- pattern, the Boolean vectors, included in this two ternary vectors can be combined to two other ternary vectors. This operation is called orthogonal block changing. Example 2. Two ternary vectors 0-1- and 010- can t build a block, because they are different in two positions. But they can be transformed to two other ternary vectors. If we decompose the first ternary vector relating to the position two, the vectors 001- and 011- will be obtained. ow we combine the second obtained vector 011- with ternary vector 010- and have therefore the following resulting ternary vectors: 001- and They cover the same Boolean vectors and are orthogonal to each other. Example 3. The function in the Figure 1 is represented as the Kmap (see Figure 1, a) ) and as the BVL (see Figure 1, b) ). After orthogonal Block Building (see Figure 2, a) ) the TVL representation of this function consist of four vectors (see Figure 2, b) ). There are no more Block Buildings possible. But the applying of Block Changing to this function is possible: the first and the second ternary vector c d b a c d b a a) b) a) b) Figure 1. The considered in Example 3 function Figure 2. Considered function after OBB a) b) c) d) e) f) Figure 3. Considered function after Block Change ( a) e) ) and Block Building ( f) )

3 from the list are different in two position, when the first one is a -/0 combination, and the second is a 1/0 difference (see Figure 3, a) ). During the Block Changing two new ternary vectors will be created (the first and the second vectors on the Figure 3, c) ). ow a next Block Changing between the second and the third vector on the Figure 3, c) will be performed. The result is shown on the Figure 3, e). For a better understanding of Block Changings it is additionally explained on the Figure 3, b) and d). After two Block Changings one new Block Building can be realized. The resulting TVL is shown on the Figure 3, f) and consists of only three vectors. Each ternary element t ij is encoded by two bits a ij and b ij (see Table 1). Table 1. Encoding of ternary elements Ternary element t ij a ij b ij Each ternary vector t i = { t ij, j=1,, k}, consists also of two parts - A = { a ij, j=1,, k} and B = { b ij, j=1,, k}, where k is the number of variables. Both parts of ternary vector are stored in two machine words and placed in the memory one after another, if k is smaller than or equal to the width of a machine word of the computer (see Figure 4). If the number of Boolean variables is larger than width of the machine word in bits, we need an even number of machine words to store one ternary vector. This number is represented by the variable typ, therefore A and B parts will consist of typ/2 components A m and B m correspondingly, stored as shown in Figure 5. Width of a machine word a i0 a i1... a ij... a ik b i0 b i1 b ij b ik A-part Figure 4. Storage structure of a ternary vector Figure 5. Storage structure of a ternary vector... B-part A 1 B 1 A 2 B 2 A TP/2 B TP/2 MW 0 MW 1 MW 2 MW 3 MW TP-2 MW TP-1 Using this encoding of the ternary elements, the following Lemmas can be formulated: Lemma 1. (ecessary and sufficient condition for Block Building) Two ternary vectors can be merged into one block if their B-parts are equal and their A-parts are different only in one place. Proof. We consider two ternary vectors that are different in exactly one column, in which the combination 0/1 is present. Using the definition of block building, only such vectors can create a block. Assume their B-parts are not equal. It means that a combination 0/- or 1/- (see Table 1) must occur at least in one column. If A-parts are different in more than one place, then both vectors would have more than one difference. < Lemma 2. (ecessary condition for Block Change) The blocks may be changed only for such two ternary vectors, whose B-parts are different only in one place X. These ternary vectors are called block changing supposed (BCS) with position X. Proof. We consider two ternary vectors that have the difference on two places, where the first one is 0/1 combination, and the second one a -/0 or a -/1 combination. Using the definition of block changing, only such vectors can be transformed to other ternary vectors. Assume their B-parts are equal. That means, that only 0/1 combinations are permissible (see Table 1). If B-parts are different more than in one place there are more than one -/0 or -/1 differences between two ternary vectors. < Lemma 3. (Sufficient condition for Block Change) Assume two ternary vectors are BCS vectors with position X. The block changing will be possible only if their A-parts are different in the place, X, and may be different in the X-position too. Proof. Two ternary vectors are BCS vectors with position X, if they have only one difference on the X place in their B-parts. Thus, the vectors have a -/0 or -/1 combination in the position X. In the first

4 case A-parts don t have a difference. In the second case A -parts differ in the position X too. If A -parts are additionally different in a place, X, where the B-parts don t have a difference, that means ternary vectors have in the position a 0/1 combination. Using the definition of a block changing, only this two ternary vectors can be transformed to other ternary vectors. < Most of the operations needed to check whether two ternary vectors are suitable for a block changing can be calculated for n variables in parallel, if n is smaller than or equal to the width of a machine word. If the number of Boolean variables is larger than the length of a machine word, we have to repeat these operations at most typ/2 times (see Figure 5). 3. Ordered Lists of Ternary Vectors 3.1. Distribution of Ternary Vectors into Classes and Subclasses To order ternary vectors we can use their number of ones. All Ternary vectors with the same number of ones belong to the same class. Each class is labeled by the number of ones #o: C #o = { t t = (t 1, t 2,..., t k ) and t j1, t j2,..., t j#o = 1, all other t i {0, } } (1) Each ternary vector represents a set of Boolean vectors. If the ternary vector includes #d dashes, the number of ones #o b in the Boolean vectors of this set is defined by #o #o b (#o + #d). (2) Because the upper bound depends of the number of dashes #d, we can use this number to create (#d+1) subclasses SC #o#d. C #o = { SC #o#d, #d {0, 1, 2,..., k-#o} }, #o {0, 1, 2,..., k} (3) SC #o#d = { t t = ( t 1, t 2,..., t k ) and t j1, t j2,..., t j#o = 1, t m1, t m2,..., t m#d =, all other t i = 0 } (4) We decide on the order in two levels. On the first level we order from lower to higher number of ones #o into classes. On the second level we order the vectors of each class from the higher to the lower number of dashes #d into subclasses. More information on the TV-ordering can be found in [6-8]. As a result, we receive an ordered list of ternary vectors that can be represented as the series of classes and subclasses. The vectors, which belong to the same subclass, are stored as separate TVL's (Sub_TVL). This classification into classes and subclasses may be used to reduce the number of necessary comparisons to find all pairs of vectors that can be used to process a block changing Data Structure number of dashes For the fast access to the classes and subclasses we create a triangular matrix structure outside of the ordered TVL. The number of rows and columns of this matrix is bounded by k+1, where k is the number of ULL ULL ULL 1 ULL variables. The elements of this array are pointers on the Sub_TVL s. The index of a row corresponds to the 3 2 ULL ULL ULL number of ones in Sub_TVL of this row. Thus each ULL ULL row of the matrix corresponds to one class. The column index corresponds to the number of dashes in each Sub_TVL. If some Sub_TVL s does not exist, ULL is stored in the appropriate array item. For example, in Figure 6 is shown the whole matrix, where a TVL is represented as 12 subclasses Similarly, this structure can also represent a BVL ULL 7 10 ULL ULL ULL 9 The matrix for BVL will have pointers to Sub_BVL s only in the first column, because the Boolean vectors Figure 6. Matrix structure contain no dashes. More information about the presented matrix structure can be found in [7] Significant Subclasses for Block Changing As mentioned above, two ternary vectors that can not build a block can be transformed to new vectors if: they are different in exactly two positions; in the first position they consist of a 0/1 combination in the second position exist one of 0/- or 1/- pattern. number of ones 0 ULL ULL 1 ULL 6

5 These new ternary vectors may be useful in some other new block buildings. Suppose SC #o#d is a subclass from an ordered model of classes and subclasses of ternary vectors. #o is the number of ones of all ternary vectors belonging to this subclass, #d is their number of dashes. The following lemma can be formulated: Lemma 4. For a Subclass SC #o#d there exist only four such subclasses SC #o #d, that some vector pairs {tv 1 from SC #o#d, tv 2 from SC #o #d } may be transformed to other pairs of ternary vectors (see Figure 7). The number of ones #o and of dashes #d of these subclasses will be specified as follows: #d = #d + 1, #o-2 #o #o+1 Proof. We consider two different subclasses of ternary vectors: SC #o#d and SC #o #d. Each vector from the first subclass includes #o ones and #d dashes. To make the Block Changing possible each vector from the second subclass should contains one more dash. Only then a 0/- or 1/- umber of dashes #d #d+1 #o #o+1 #o+2 difference between two ternary vectors can be presented. The number of dashes #d of all subclasses, which ternary vectors may participate in the Block Changing is also equal to #d+1. The second necessary condition for a Block Changing is presence of the 0/1 difference. In other positions this ternary vectors should be equal (see Lemma 3). Let the first difference be a 1/- difference. If the second difference is a 1/0 combination, #o = #o-2 (see Figure 8, case 1). In the case of a 0/1 combination the number of ones is equal: #o = #o (see Figure 8, case 3). In the case if the first difference is a 0/- difference, and the second difference a 1/0 combination, #o = #o-1 (see Figure 8, case 2). If the second difference is equal to 0/1, the number of ones #o is equal to #o+1 (see Figure 8, case 4). The Blocks of the vectors from SC #o#d and SC #o #d subclasses can be changed consequently, only if #d = #d + 1, #o-2 #o #o+1. < According to described in chapter 2 block changing rules, if a block changing between vectors from SC #o#d and SC #o #d was possible, following new ternary vectors will be created: #o-2 #o Figure 7. Four Block Changing Significant subclasses SC #o #d for a SC #o#d subclass t 1 t 2 t i-1 1 t i+1 t j-1 1 t j+1 t n-1 t n p 1 p 2 p i-1 0 p i+1 p j-1 - p j+1 p n-1 p n t 1 t 2 t i-1 1 t i+1 t j-1 0 t j+1 t n-1 t n p 1 p 2 p i-1 0 p i+1 p j-1 - p j+1 p n-1 p n t 1 t 2 t i-1 0 t i+1 t j-1 1 t j+1 t n-1 t n p 1 p 2 p i-1 1 p i+1 p j-1 - p j+1 p n-1 p n t 1 t 2 t i-1 - t i+1 t j-1 1 t j+1 t n-1 t n p 1 p 2 p i-1 0 p i+1 p j-1 0 p j+1 p n-1 p n t 1 t 2 t i-1 - t i+1 t j-1 0 t j+1 t n-1 t n p 1 p 2 p i-1 0 p i+1 p j-1 1 p j+1 p n-1 p n t 1 t 2 t i-1 - t i+1 t j-1 1 t j+1 t n-1 t n p 1 p 2 p i-1 1 p i+1 p j-1 0 p j+1 p n-1 p n 4 t 1 t 2 t i-1 0 t i+1 t j-1 0 t j+1 t n-1 t n p 1 p 2 p i-1 1 p i+1 p j-1 - p j+1 p n-1 p n Figure 8. Four Block Changing possibilities. t 1 t 2 t i-1 - t i+1 t j-1 0 t j+1 t n-1 t n p 1 p 2 p i-1 1 p i+1 p j-1 1 p j+1 p n-1 p n Using described data structure of classes and subclasses new ternary vectors will be stored as shown in Figure 9. The dark subclasses are Block Change participated subclasses. The arrows show the subclass, where the new transformed vectors should be stored. umber of ones umber of dashes umber of dashes umber of dashes umber of dashes #d #d+1 #d #d+1 #d #d+1 #d #d+1 #o-2 #o-1 #o #o+1 #o-2 #o-1 #o #o+1 #o-2 #o-1 #o+2 #o+2 #o+2 #o Figure 9. Storing of ternary vectors received after block changing #o #o+1 #o-2 #o-1 #o #o+1

6 4. Algorithms 4.1. Orthogonal Block Changing (OBC) Algorithm We consider here two ternary vectors tv 1 and tv 2 to check if a block changing is possible. The first ternary vector tv 1 should be the vector with less dashes compared with tv 2. ote, that TD (tv 1, tv 2, part, machine word, position) i = 0; machine word = -1; part = = A the numbers of dashes is known from the column index of the subclasses. k = 0 k = 1 According to lemma 2 we should check at first condition = tv1[i + k] + tv2[i + k] if this vectors are amenable of a block condition!= 0 changing, that means their B-parts are different machine word!= -1 i = i + 2 only in one place. The difference testing function (TD) can be used for this purpose (see return FALSE machine word = i; i = i + 2 Figure 10). while ( i < number of mashine words ) The first two parameters of this function are position = FIRST_BIT the considered ternary vectors. The parameter condition = tv1[machine word +k] + tv2[machine word +k] part marks, which parts of ternary vectors while ( position AD condition = = 0 ) should be checked up for a difference: A or B. position = position >> 1 As results, the TD-algorithm (see Figure 10) condition + position!= 0 returns: the number of the machine word, that contains the difference, and position of the return FALSE return TRUE difference inside this word. If there are more than one differences between the defined Figure 10. Difference Testing algorithm vector parts - the function returns false. If tv 1 and tv 2 are BCS vectors with position 1, according to lemma 3 it should be next decided if the A- parts of the considered ternary vectors are different beside the found position 1, and the difference 0/1 is in only one position. In order to do this we remove the A-part difference in the position 1. The TD-function will be then used again. If its result is true and position 2 is found, the block changing will be performed and two new ternary vectors will be created: in the position 2 of word 2 of tv 1 a dash is created, and in the position 1 of word 1 of tv 2 an opposite element of tv 1 (word 1, position 1 ) is assign (see Figure 11). OBC(tv 1, tv 2 ) TD(tv1, tv2, B, mashine word1, position1) == TRUE temp_tv = tv1 return temp_tv[mashine word1] = tv1[mashine word1] AD ~position1 FALSE temp_tv[mashine word1+1] = tv1[mashine word1+ 1] AD ~position1 D(temp_tv,tv2,A,mashine word2,position2)==true tv1[mashine word2] = tv1[mashine word2] AD ~position2 return tv1[mashine word2+1] = tv1[mashine word2+1] AD ~position2 FALSE tv2[mashine word1+1] = tv2[mashine word1+1] + position1 ( tv1[mashine word1] AD position1) = = 0 tv2[mashine word1] = tv2[mashine word1] + position1 return TRUE Figure 11. Orthogonal Block Change algorithm 4.2. Orthogonal Block Building (OBB) algorithms To minimize the number of rows in a TVL the orthogonal Block Building is used: if two orthogonal ternary vectors (two lines) of a TVL differ in exactly one column, in which the combination 0/1 is present, both TV s can be combined into one TV. We check whether two ternary vectors tv 1 and tv 2 can build a block using the OBB (tv 1, tv 2 ) algorithm. As mentioned in Lemma 1, we compare at first B-parts of vectors that must be equal. If the B -parts are equal, the A -parts will be compared, and should be different only in one column. If both conditions are

7 fulfilled, the block building between tv 1 and tv 2 is possible and the new_vect will be composed. This vector contains a dash in the column, where tv 1 and tv 2 have the 0/1 combination. Figure 11 shows the block scheme of this algorithm. For a complete block building it is necessary to find all pairs of ternary vectors that can be used for block building. There are different algorithms to process a Block Building. Some of them are presented in detail in [5, 7]. At first we will briefly present an algorithm that is part of the XBOOLE system: It uses two lists of ternary vectors: original tvl and help_tvl, containing vectors that cannot create one more block. Each vector tv 1 from tvl is compared with all the next standing vectors tv 2. It is checked whether tv 1 and tv 2 can create a block using algorithm OBB(tv 1, tv 2 ). If block building was possible, new_vect is saved in the original list tvl. If vector tv 1 cannot be combined with any vectors tv 2 from tvl, it will be compared with all OBB (tv 1, tv 2 ) w1=0; w = -1; test=true ( tv1[w1+1] tv2[w1+1] == 0) var_bb = tv1[w1] tv2[w1] test = false var_bb! = 0 /\ w! = -1 test = false var_bb!= 0 w = w1 w1 = w1+2 w1<typ /\ test == true test == true new_vect = tv1 test = false pos=first_bit var_bb = tv1[w] tv2[w] ( var_bb /\ pos) == 0 pos =pos >> 1 var_bb=var_bb pos var_bb == 0 new_vect[w+1] = tv1[w+1] pos test = false new_vect[w] = tv1[w] /\ new_vect[w+1] new_vect = ULL Figure 12. Test of block building between two vectors tv 1 and tv 2 and building a new_vect algorithm vectors from help_tvl. If again no block building was possible, tv 1 is saved on the end of help_tvl. The algorithm is repeated, until tv 1 is not the last vector in tvl. At the end, help_tvl consist only vectors, which cannot build a block. 4.3 Orthogonal Block Change & Block Building (OBCBB) Algorithm A Block Change & Block Building algorithm consist of two parts: a Block Change part and a Block Building part. To process a Block Changing in a TVL it is necessary to find all pairs of ternary vectors, which have a property for a block changing. After that a Block Building algorithm will be realized. We consider in this paper two different ways to perform a Block Change & Block Building. Method 1. This algorithm was proposed in [2] OBCBB(TVL) and is part of the XBOOLE system. Each vector tv 1 from tvl is compared number = number of vectors in TVL with all next standing vectors tv 2. If tv1 = first vector from TVL for tv 1 and tv 2 a block changing is tv1! = last vector in TVL possible, the algorithm OBC (tv 1, tv 2 ) tv2 = next vector after tv1 transforms the incoming vectors and end = FALSE returns true. Changed vectors are OBC(tv1, tv2) stored on the places of original tv2! = last vector in TVL ternary vectors. Otherwise the algorithm returns false. tv2 =next vector of TVL end = TRUE After all pairs of ternary vectors from OT end tvl were checked for a block changing and all possible block changings were tv1 = next vector of TVL processed, the Orthogonal Block OBB(TVL) Building algorithm (OBB) (described new number = number of vectors in TVL in detail in [5]) is called. It search for new number < number all pairs of ternary vectors, which can build a block and merge each of such Figure 13. OBCBB algorithm used in XBOOLE system pairs to a single vector. If at least one new block was build during this cycle of algorithm, the OBCBB algorithm will be repeated. If no more block buildings after block changing is possible, the algorithm stops (see Figure 13).

8 Method 2. In Figure 15 we show the block schema of our new algorithm, which takes into account the ordered data structure, described in section 3. According to Lemma 3, only ternary vectors from Sub_TVLs belonging to the neighbor column with one more dash than the current Sub_TVL and having the numbers of ones #o, #o-2 #o #o+1 are useful for the block changing procedure. Our block change & block building algorithm starts with Sub_TVL(row, column) where row is the last row in matrix and column is the first column in this row. We check whether this Sub_TVL and the corresponding Sub_TVL(row+ step, column+1), -2 <= step <= 1 from the neighbor column are not equal ULL. If the subclasses are not ULL, the algorithm runs OBC(tv 1, tv 2 ) for each vector tv 1 from Sub_TVL(row, column) and each vector tv 2 from Sub_TVL(row +step, column+1). In case of a possibility for block changing, temporary new_vect 1 and new_vect 2 will be created and contain transformed ternary vectors. This temporary ternary vectors will be used to finding out, if this Block Changing will be successful, that means if it will lead to a new Block Building. We use for it the OBB(tv 1, tv 2 ) function that can find out, if one or both of the temporary vectors can build a block with the vectors from appropriate Sub_TVL. number of ones OBCBB(TVL) number of dashes ULL ULL ULL ULL ULL ULL 1 ULL ULL ULL ULL 2 ULL ULL 3 ULL ULL 4 5 ULL 6 ULL Figure 14. Direction of selection of subclasses by new method of block changing 6 store position_1 = {-1, -1, 0, 0} ; store position_2 = {0, 1, 0, 1} k = number of variables in tvl for (row = k; row >= 0; row = row - 1) for ( column = 0; column <= k - row; column = column + 1 ) Sub_TVL(row, column)!= ULL for ( step = -2; step <= 1; step = step + 1) Sub_TVL(row+step, column+1)!= ULL for all vectors v1 from Sub_TVL (row, column) for all vectors v2 from Sub_TVL (row + step, column+1) temp_v1 = v1; temp_v2 = v2; OBC( temp_v1, temp_v2 ) == true for all vectors tv from Sub_TVL(row+store position_1[step] - 1, column + 1) v2 = next OBB(temp_v1, tv) == TRUE vector from Sub_TVL result1 = TRUE result1 = FALSE (row + step, column+1) break tv = next vector from Sub_TVL (row+store position_1[step] - 1, column+1) for all vectors tv from Sub_TVL(row+step+store position_2[step] - 1, column - 1) OBB(temp_v2, tv) == TRUE result2 = TRUE result2 = FALSE break tv=next vector from Sub_TVL (row+step+store position_2[step] - 1, column-1) result1 result1 AD AD result2 result2 delete result1 v1,v2 break delete v1, v2 result2 result2 save temp_v2 in save temp_v2 in save Sub_TVL(row+step+ delete temp_v1 v1, v2 in v2 = next v2 vector = next from Sub_TVL(row+step + Sub_TVL(row+sto- Sub_TVL store position_2, column - 1) save temp_v1 in vector from store position_2[step], re position_1 [step], (row + step, breakcolumn 1) column Sub_TVL(row+store + 1) column + Sub_TVL 1) position_1, column + 1) (row + step, delete v1, v2 delete v1, v2 delete v1, v2 column+1) break break break break v1 = next vector from Sub_TVL (row, column) Figure 15. Block change - Block building using new algorithm

9 The appropriate Sub_TVL consist of the same number of dashes like transformed vector and of one less 1 than transformed vector (See Figure 14). The variable store position means how different is the storing class of transformed vector from the storing class of original vector (see Figure 9, 15). Using this variable for the Block Building, the appropriate class can de described as row + store position 1. Founded block building is processed immediately, and it s result vector contains one less one or zero and one more dash, compared to transformed temporary ternary vector, and has to be added to corresponding Sub_TVL. If such Sub_TVL does not exist, it will be created. The result vector includes the information from the original ternary vectors too, and thus if both transformed temporary ternary vectors lead to a block building, we must only delete the original ternary vectors. If just one of both transformed temporary ternary vectors can build a block, the second transformed temporary ternary vector must be stored in the corresponding Sub_TVL. If such Sub_TVL does not exist, it will be created. The original ternary vectors must be deleted. In the case if no block building after performed block change is possible, the original ternary vectors does not changed. The algorithm iterates through the internal loop over Sub_TVL(i, j) by increasing the column number j and through the external loop over Sub_TVL by decreasing the row number i (see Figure 14). According to Figures 8, 13, it is easy to see that if 2 step 0 all the new vectors will be considered in the next loop of the OBBC building algorithm. Only when step 1 new vectors will be stored in Sub_TVL that have bean already processed. The algorithm terminates when it reaches the first row and the column before last in matrix (see Figure 14). Example 4. Subclass (5, 0) is compared with subclass (3, 1). If a block changing was possible, the transformed vector, belonged in original to subclass (5, 0) will consist of 4 ones and 1 dash. Another transformed ternary vector that in original belonged to subclass (3, 1) will consist of 3 ones and 0 dashes. Therefore during the block building part of OBCBB algorithm first new vector will be compared with the vectors from subclass (3, 1), second new vector will be compared with vectors from subclass (2,0) to process a block building. In the next iteration of the internal loop, vectors from the subclass (5,0) will be compared with vectors from subclass (4, 1). 5. Results To compare the efficiency of two different versions of block change & block building algorithms, we have run each of them for a TVL of 15 Boolean variables with 8796 ternary vectors and 0.97% of dashes. The vectors from this TVL could not build some blocks more, therefore we have calculated the numbers of necessary comparisons between pairs of vectors to perform block change & block building. The results are shown in Figure umber of comparisons per one founded block during different loops of two OBCBB algorithms OBCBB XBOOLE new OBCBB Loop of algorithm Figure 16. umber of comparisons per one founded block during different loops on two OBCBB algorithms

10 Each method perform block change & block building in more loops of corresponding algorithm. In one loop of the algorithm all vectors from TVL should be checked and all founded blocks should be built. It is easy to see, that with each next loop less new blocks can be built and more comparisons to find a new block are needed. umber of vectors in TVL after different loops of two OBCBB algorithms new OBCBB OBCBB XBOOLE Loop of algorithm Figure 17. umber of vectors in TVL after different loops of two OBCBB algorithms umber of comparisons needed to reach a certain number of vectors in the TVL OBCBB XBOOLE new OBCBB Reached number of vectors Figure 18. umber of necessary comparisons to reach a certain number of vectors in the TVL for two OBCBB algorithms Because during one loop of an algorithm different numbers of blocks may be built, we have calculated at next the number of loops of each algorithm to reduce number of ternary vectors in TVL to rough 1000, and how many comparisons are necessary to find one new block building possibility. This results are summarized in Table 2.

11 Table 2. The performance of two block change & block building algorithms #1 umber of ternary vectors #2 Percentage of dashes 0,97% 0,6% 0,04% #2 umber of OBCBB XBOOLE algorithm loops #3 umber of vectors after OBCBB XBOOLE algorithm #4 umber of comparisons per one founded block with , , ,2 OBCBB XBOOLE algorithm #5 umber of loops of new OBCBB algorithm #6 umber of vectors after new OBCBB algorithm #7 umber of comparisons per one founded block building 23502, , ,1 with new OBCBB algorithm #8 Percentage (#7 / #4) 100% 14,27% 13,05% 9,81% 6. Conclusion and Future Work We have developed a faster algorithm for block change & block building in orthogonal TVLs using ordering of ternary vectors into classes and subclasses. Classes are defined by the numbers of ones in a vector and subclasses by the number of dashes. There are two practical results. First, our experimental results show that the approach that is based on sorting TV s into classes and subclasses needs significantly less comparisons than approaches without sorting. Second, new algorithm reduce performing time, because only block changings leaded to a new block building will be realized. XBOOLE algorithm will be stopped if no blocks was built after last block changing. In reality it can be run endless, because after more block changings exist almost always a possibility to find some new blocks. On the one hand the new OBCBB algorithm guarantee the end of block change & block building process, because only blocks will be changed that lead direct to new block buildings. But on the other hand exactly this restriction is a disadvantage of new algorithm. OBCBB can find more new blocks if some block changes will be permitted, which create such new blocks not immediately usable to built a new block. ote, the example 3 show such a case, where the block building is only possible after the second change of blocks. Therefore, in the future work, we will test following ideas: Improvement of described new algorithm with more tests for transformed vectors Use the method of simulated annealing in the algorithm that permit with a decreasing probability the performing of block changes that don t lead to new block building Besides we will adapt the new approach based on the orthogonal ordered lists of ternary vectors to other Boolean operations. 7. References [1] Bochmann, D.; Posthoff, C.: Binäre dynamische Systeme. Akademie-Verlag, Berlin, 1981 [2] Bochmann, D.; Steinbach, B.: Logikentwurf mit XBOOLE. Verlag Technik Berlin, [3] Posthoff, Ch.; Steinbach, B.: Binäre Gleichungen - Algorithmen und Programme. Wissenschaftliche Schriftenreihe der Technischen Hochschule, 1/1979, Karl-Marx-Stadt, 1979 [4] McCluskey, E. J.: Minimisation of Boolean Functions. Bell System technical Journal, 1956, pp [5] Steinbach, B.: XBOOLE - A Toolbox for Modelling, Simulation, and Analysis of Large Digital Systems. System Analysis and Modelling Simulation, Gordon & Breach Science Publishers, 9(1992), umber 4, pp [6] Steinbach B., Dorotska K. Fast Boolean calculations using ordered lists of ternary vectors // Proceedings of the Third International Conference on Computer-Aided Design of Discrete Devices (CAD DD'99), Volume 1, pp , ovember 1999, Minsk, Belarus [7] Steinbach, B.; Dorotska, Chr.: Orthogonal Blockbuilding Using Ordered Lists of Ternary Vectors. in: Steinbach, B. (Hrsg.): Boolean Problems, Proceedings of the 4th International Workshops on Boolean Problems, September 2000, Freiberg University of Mining and Technology, Freiberg, 2000, pp [8] Steinbach B., Dorotska Ch. Calculation of SET Operations using Ordered Lists of Ternary Vectors // Proceedings of the Fourth International Conference on Computer-Aided Design of Discrete Devices (CAD DD'2001), Volume 1, pp , ovember 14-16, 2001, Minsk, Belarus