Generating a smallest binary tree by proper selection of the longest edges to bisect in a unit simplex refinement
 979 Downloads
 2 Citations
Abstract
In several areas like global optimization using branchandbound methods for mixture design, the unit nsimplex is refined by longest edge bisection (LEB). This process provides a binary search tree. For \(n>2\), simplices appearing during the refinement process can have more than one longest edge (LE). The size of the resulting binary tree depends on the specific sequence of bisected longest edges. The questions are how to calculate the size of one of the smallest binary trees generated by LEB and how to find the corresponding sequence of LEs to bisect, which can be represented by a set of LE indices. Algorithms answering these questions are presented here. We focus on sets of LE indices that are repeated at a level of the binary tree. A set of LEs was presented in Aparicio et al. (Informatica 26(1):17–32, 2015), for \(n=3\). An additional question is whether this set is the best one under the socalled \(m_k\)valid condition.
Keywords
Regular simplex Longest edge bisection Branchandbound Bisection sequence Combinatorial optimization1 Introduction
Calculation of distances between vertices to determine the longest edges is a computationally intensive operation in the partition process. This computation can be avoided by precomputing a set of LE indices to be bisected. Each LE is stored as a pair of vertex indices for a simplex in the BT. It is desirable to find sets with an appropriate repetition of LE indices, because their computational management is more efficient than distance calculation. We look for sets of LEs with a high repetition of longest edge indices per level of any of the smallest BTs.
A set of LE indices generating the minimum number of classes of simplices (Aparicio et al. 2013), was presented in Aparicio et al. (2015). Another research question in this study is whether that set also provides one of the smallest trees, given a value of the stopping criterion on the size of the subsimplices. Additionally, we investigate whether such set is the best under the \(m_k\)valid condition presented in Sect. 4.
The paper is organized as follows. Section 2 introduces the simplex refinement by LEB. An algorithm to determine the smallest possible size of the binary tree is studied in Sect. 3. Section 4 introduces the concept of \(m_k\)validity. Section 5 shows an algorithm to generate a tree containing all possible smallest binary trees. Section 7 develops an algorithm to search \(m_k\)valid sequences in the output of the algorithm of Section 5. Section 8 shows the results of the developed algorithms applied to a 3simplex. Finally, conclusions and future research are discussed in Sect. 9.
2 Simplex refinement using longest edge bisection
Figure 2 shows the bisection of a regular 3simplex. It does not matter which edge is selected first, because all generated subsimplices differ only in orientation. Notice that after the first subdivision, the generated subsimplices are irregular and have three (out of six) edges with the longest length. Therefore, we need to make a decision on which longest edge should be bisected.
The number of simplices in the finite BT generated by Algorithm 1 depends on how fast the simplex size decreases when we go deeper into the tree. We are interested in the combinatorial optimization problem of choosing vertices j, k in SelectLE() to obtain one of the smallest size binary trees.
3 An algorithm to determine the size of a smallest tree
Algorithm 3 determines the size of the smallest subtree from a subsimplex when it is bisected by one of its longest edges \(E_h\), with vertices \(\{j,k\}\) (see line 4). It recursively calls itself to get the smallest subtree size for the two generated subsimplices (see lines 5, 6). When the recursive algorithm is back at the initial simplex, the size of the smallest trees is known and the algorithm ends. The algorithm does not provide information about which longest edges have been bisected to generate one of the smallest trees.
Figure 3 illustrates running Algorithm 3 on a 2simplex for \(\epsilon =0.5\). The BT has 10 subsimplices. Although the 2simplex is not a very interesting case because irregular simplices have just one longest edge, the illustration facilitates discussing several details not included in Algorithm 3 for the sake of simplicity:
Remark 1
In Algorithm 3, if \(S_l\) and \(S_r\) are symmetric, only one of them is processed and the algorithm returns twice the size of the evaluated subtree. In the example of Fig. 3, siblings \(S_2\) and \(S_3\) and also \(S_{10}\), \(S_{11}\) and \(S_{12},S_{13}\) are symmetric.
Remark 2
Algorithm 3 only has to process one of the longest edges for a regular simplex, because any edge division will return the same subtree size. Simplices \(S_1\), \(S_4\) and \(S_7\) are regular in Fig. 3.
Remark 3
For an irregular simplex with several longest edges, it is of interest to determine those edges producing similar pairs of siblings. Therefore, Algorithm 3 only has to process one of the pairs. This will be studied in a future work.
4 The \(m_k\)valid condition
For \(n>2\), many different Smallest Binary Trees (SBTs) can be generated by iteratively applying LEB. Given a SBT, a vector or sequence of longest edges, SQLE, can be determined beforehand in order to be used in Algorithm 1. The element SQLE\(_i\) specifies one of the longest edges of \(S_i\). The number of elements of the SQLE vector is the same as the number of (nonleaf) nodes of the corresponding SBT. This number increases as the dimension n increases and the value of \(\epsilon \) decreases. So, it can be very large.
Given the numbering of simplices in Algorithm 1, the level where the simplex \(S_i\) is located in a BT is determined by \(\ell =\lceil 1+\log _2 i \rceil \). We focus on the idea that the longest edge index to be bisected is the same in various simplices at the same level of the tree. We derive several conditions that the set of longest edge indices must fulfil.
Definition 1
Two simplices have a longest edge index h in common when the edge \(E_h = \{j,k\}=\{k,j\}\) is a longest edge in both simplices. The longest edges in both simplices sharing an index may be the same or different.
Definition 2
Let \(m\in {\mathbb {N}}^+\). Simplex i at level \(\ell \) is in subset \(M_j\), \(j=0,\ \ldots ,\ m1\), if \(j=i\!\!\mod m\).
Definition 3
Subset \(M_j\) at level \(\ell \) (see Definition 2) is called valid if there exists an edge index h such that \(E_h\) is a longest edge for all simplices in \(M_j\).
Notice that \(M_j\) can be valid due to several LE indices.
Definition 4
Level \(\ell \) in a BT is called mvalid if all subsets \(M_j,\ j=0,\ldots ,m1\) at level \(\ell \) are valid (see Definition 3).
Notice that an edge index h validating subset \(M_j\) can be different from edge index g validating subset \(M_k,\ j\ne k\).
Remark 4
An mvalid level may have less than m simplices.
Definition 5
A binary tree with \(L+1\) levels is mvalid when all its first L levels are mvalid (see Definition 4).
Notice that the set of LE indices validating a level of the BT can be different to the set of LE indices validating another level of the BT.
Definition 6
Given a mvalid SBT with \(L+1\) levels, let \(L\times m\) matrix A be defined by elements \(a_{\ell ,j}\) that denote an index h of a LE validating subset \(M_j\) at level \(\ell \).
Notice that not all elements of matrix A may have a number due to the absence of the corresponding nodes in the binary tree.
Property 1
A BT generated by LEB, with \(L+1\) levels and maximum \(2^{L1}\) elements at level L, is always mvalid for \(m=2^{L1}\).
Property 2
Given \(k\in {\mathbb {N}}\), a \(2^k\)valid binary tree is also \(2^{k+1}\)valid.
Property 2 and the number of nodes (\(2^{\ell 1}\)) at level \(\ell \) of a BT suggest to use \(m=2^k\).
An SQLE vector has less memory requirements than a matrix A\(_{(L\times m)}\) with \(m=2^{L1}\). Therefore, we are interested in values of \(k < L1\).
Definition 7
A binary tree is \(m_k\)valid if it is mvalid (see Definition 5) with \(m=2^k\), \(k\in {\mathbb {N}},\ k<L1\).
3simplex instance. Indices of longest edges bisected for each simplex in each level of the BT with the minimum number of classes of simplices (see Algorithm 1) (Aparicio et al. 2015)

Definition 8
A binary tree which is not \(m_k\)valid is called \(m_k\)invalid.
Property 3
Any binary tree generated from an \(m_k\)invalid binary tree by increasing its number of levels, is \(m_k\)invalid.
The existence of an \(m_k\)valid SBT depends on the combinations of longest edge indices making a level of the SBT \(m_k\)valid, which also depends on the selected combinations at previous levels.
To find all \(m_k\)valid SBTs, we need an algorithm generating all possible SBTs and an algorithm to discard those trees that are \(m_k\)invalid. The following sections describe these algorithms.
5 ASBT algorithm (all smallest binary trees)

\(S=conv(V)\): The current simplex.
 The set of longest edges of S, with the following information for each longest edge \(E_h=\{j,k\}\):

\(R_h\): the total size of the two generated subtrees.

\(N_{lh}\): left node.

\(N_{rh}\): right node.

The results of Algorithm 4 are the SBT size generated by LEB and the root node of the GT, i.e., N containing \(S_1\). Following the simplex enumeration of Algorithm 1, where a LEB of simplex \(S_i\) generates subsimplices \(S_{2i}\) and \(S_{2i+1}\), there exist many instances of \(S_i\) in the GT. Each instance depends on the longest edges bisected at higher levels in the GT tree. In Algorithm 4, line 12, those longest edges, and subtrees generated from them, that do not result in a SBT are removed from the GT.
6 NSBTGT algorithm (number of SBTs in GT)
Table 3 in Sect. 8 shows the number of SBTs in the GT for different values of \(\epsilon \).
7 M\(_K\)SBT algorithm (\(m_k\)valid smallest binary trees)
Algorithm 6 follows the general structure of a B&B algorithm, iterating over partial matrices stored in \(\Lambda \). The first partial matrix A\(_{\ell \times m}\) stores the index of the first longest edge, but it can be any of the edges of the initial regular simplex. In line 10, new \(m_k\)valid partial matrices at \(\ell +1\) level are produced from the selected A\(_{\ell \times m}\) partial matrix (see Definition 7). For instance, for a 3simplex and \(k=0\), Algorithm 6 generates in line 10 partial matrices \({1\atopwithdelims ()1}\), \({1\atopwithdelims ()2}\), and \({1\atopwithdelims ()4}\) from the initial partial matrix A\(_{1\times 1}\)=(1) (see Fig. 4). Those partial matrices that are not rejected and can not progress on GT are stored in \(\Omega \) (see line 8).
8 Results for a 3simplex
Algorithms have been coded in C/C++ and they have been executed in a BullXUAL node, under Ubuntu 12.04.3 LTS. A node consists of two processors Intel^{®} Xeon^{®} E52650 with 8 cores at 2,00 GHz and 64GB of RAM.
Table 1 shows the indices \(\{i,j\}\) of the longest edges bisected at every level of the binary tree for a 3simplex. This set of indices generates binary trees with the minimum number of eight classes of simplices (Aparicio et al. 2015). Two simplices belong to the same class if one can be obtained by scaling, translation and rotation/flip of the other, see Aparicio et al. (2015). The set in Table 1 can be used in Algorithm 1, line 6, to generate such trees. For different \(\epsilon \) values the algorithm obtains different trees.
A matrix generating the smallest number of simplex classes for a 3simplex, denoted by A3SNC, can be derived from Table 1. The set of LEs in A3SNC is 2valid. Levels 13,5 and 6 are 1valid and levels 4 and 7 are 2valid. A3SNC can be applied to generate a BT with more than 7 levels because levels 810 use the same longest edge indices as at levels 57, and those repeat for all further levels.
Size of a smallest binary tree (MinTree()) and the size of the binary tree generated by SR() with the A3SNC matrix for a 3simplex varying the accuracy \(\epsilon \)
\(\epsilon \)  MinTree()  A3SNC_in_SR() 

0.8  31  31 
1 / 2  47  47 
0.35  335  351 
\(1/2^2\)  351  351 
0.2  1,727  1,727 
\(1/2^3\)  2,751  2,751 
0.1  13,695  13,695 
\(1/2^4\)  21,887  21,887 
0.05  108,799  109,311 
\(1/2^5\)  174,847  174,847 
0.02  1,354,495  1,398,271 
\(1/2^6\)  1,398,271  1,398,271 
0.01  10,835,455  11,185,151 
\(1/2^7\)  11,185,151  11,185,151 
0.005  86,682,623  89,479,167 
\(1/2^8\)  89,479,167  89,479,167 
0.002  715,829,247  715,829,247 
\(1/2^9\)  715,829,247  715,829,247 
0.001  1,431,658,495  1,431,658,495 
\(1/2^{10}\)  1,431,658,495  1,431,658,495 
\(\epsilon \)  GT  SBTs  npm  nfm  A3SNC 

0.8  9  1  5  1  \(\checkmark \) 
1 / 2  11  1  5  1  \(\checkmark \) 
0.35  111  16  17  0  
\(1/2^2\)  41  1  8  1  \(\checkmark \) 
0.2  137  9  10  1  \(\checkmark \) 
\(1/2^3\)  173  9  11  1  \(\checkmark \) 
0.1  617  59,049  13  1  \(\checkmark \) 
\(1/2^4\)  785  59,049  14  1  \(\checkmark \) 
0.05  180,708  \(1.6 \times 10^{186}\)  10  0  
\(1/2^5\)  3,665  \(1.4 \times 10^{18}\)  17  1  \(\checkmark \) 
0.02  34,913  \(4.1 \times 10^{203}\)  17  0  
\(1/2^6\)  17,273  \(8.6 \times 10^{63}\)  20  1  \(\checkmark \) 
Algorithm 6 returns only one possible 4valid matrix for the check marked instances in Table 3 equal to A3SNC. Those instances without a check mark do not present a 4valid matrix. A3SNC matrix is actually 2valid but it is also \(2^k\)valid for a 3simplex and \(k\ge 1\) (see Property 2).
The smallest possible matrix is 1valid with the same longest edge index for every level. As A3SNC is the only 2valid set, such a matrix does not exist with the reordering of vertices in Algorithm 2. Therefore, A3SNC is the \(m_k\)valid matrix with the smallest k value.
The use of A3SNC needs the same method of reindexing of vertices at each simplex, according to Algorithm 2. The computational cost of this reindexing is much lower than the calculation of distances between vertices. The computation cost difference increases with n.
The analogous problem to the one tackled here is to find the smallest number of reindexes of vertices at simplices such that the same longest edge index is bisected for any simplex in a SBT. This approach seems to be as difficult as the one tackled here. In the worst case, it is necessary to provide a reindexing for each simplex. Nevertheless, it could be an interesting approach to address in a future work.
The investigation and application of the algorithms for the 4simplex requires the use of parallel computing due to the memory and computational requirements to generate a 4valid matrix for a small accuracy \(\epsilon \) to allow every initial edge be bisected several times.
9 Conclusions and future research
This work studies how to obtain matrices showing the indices of the longest edges to bisect a regular nsimplex generating a smallest binary tree in its iterative refinement. We focus on matrices with high occurrence of the longest edge indices to divide per level of the binary tree. We conclude that the sequence presented in Aparicio et al. (2015) is the unique 2valid and 4valid (see Definition 7 and Property 2) for some termination criteria. The combinatorial complexity of the problem allows us to show results only for \(n=3\) and \(\epsilon \) \(\ge \) \(1/2^6\). Higher n and smaller \(\epsilon \) values will require the improvement of the sequential algorithms and to develop parallel versions of them.
Notes
Acknowledgments
This work has been funded by Grants from the Spanish Ministry (TIN201237483 and TIN201566680) and Junta de Andalucía (P11TIC7176), in part financed by the European Regional Development Fund (ERDF), and also by the Project ICT COST Action TD1207 (EU). J. M. G. Salmerón is a fellow of the Spanish FPU program.
References
 Adler A (1983) On the bisection method for triangles. Math Comput 40(162):571–574. doi: 10.1090/S00255718198306894735
 Aparicio G, Casado LG, Hendrix EMT, García I, GTóth B (2013) On computational aspects of a regular nsimplex bisection. In: Proceedings of the 8th International conference on P2P, parallel, grid, cloud and internet computing, IEEE Computer Society, Compiegne, France, pp. 513–518. doi: 10.1109/3PGCIC.2013.88
 Aparicio G, Casado LG, GTóth B, Hendrix EMT, García I (2014) Heuristics to reduce the number of simplices in longest edge bisection refinement of a regular nsimplex. Computational science and its applications ICCSA 2014. Lecture notes in computer science, vol 8580. Springer International Publishing, Cham, pp 115–125. doi: 10.1007/9783319091297_9
 Aparicio G, Casado LG, GTóth B, Hendrix EMT, García I (2015) On the minimim number of simplex shapes in longest edge bisection refinement of a regular nsimplex. Informatica 26(1):17–32. doi: 10.15388/Informatica.2015.36 MathSciNetCrossRefGoogle Scholar
 Hannukainen A, Korotov S, Křížek M (2014) On numerical regularity of the facetoface longestedge bisection algorithm for tetrahedral partitions. Sci Comput Program 90:34–41. doi: 10.1016/j.scico.2013.05.002 CrossRefGoogle Scholar
 Hendrix EMT, Casado LG, Amaral P (2012) Global optimization simplex bisection revisited based on considerations by Reiner Horst. In: Computational science and its applications ICCSA 2012. Lecture notes in computer science, vol 7335, Springer, Berlin, pp 159–173. doi: 10.1007/9783642311376_12
 Herrera JFR, Casado LG, Hendrix EMT, García I (2014) On simplicial longest edge bisection in Lipschitz global optimization. In: Computational science and its applications ICCSA 2014. Lecture notes in computer science, vol 8580, Springer International Publishing, Cham, pp 104–114. doi: 10.1007/9783319091297_8
 Horst R (1997) On generalized bisection of \(n\)simplices. Math Comput 66(218):691–698. doi: 10.1090/S0025571897008090 MathSciNetCrossRefzbMATHGoogle Scholar
 Mitchell WF (1989) A comparison of adaptive refinement techniques for elliptic problems. ACM Trans Math Softw 15(4):326–347. doi: 10.1145/76909.76912
Copyright information
Open AccessThis article is distributed under the terms of the Creative Commons Attribution 4.0 International License (http://creativecommons.org/licenses/by/4.0/), which permits unrestricted use, distribution, and reproduction in any medium, provided you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons license, and indicate if changes were made.