Proposing and solving olympiad geometry with guided tree search

The growing cost gap between DRAM and storage together with increasing database sizes means that database management systems (DBMSs) now operate with a lower memory to storage size ratio than before. On the other hand, modern DBMSs rely on in-memory search trees (e.g., indexes and filters) to achieve high throughput and low latency. These search trees, however, consume a large portion of the total memory available to the DBMS. Existing compression techniques for search trees often rely on general-purpose block compression algorithms such as Snappy and LZ4. These algorithms, however, impose too much computational overhead for in-memory search trees because the DBMS is unable to operate directly on the index data without having to decompress it first. Simply getting rid of all or part of the search trees is also suboptimal because they are crucial to query performance. This dissertation seeks to address the challenge of building compact yet fast in-memory search trees to allow more efficient use of memory in data processing systems. We first present techniques to obtain maximum compression on fast static (i.e., read-optimized) search trees. We identified sources of memory waste in existing trees and designed new succinct data structures to show that we can push the memory consumption of a search tree to the theoretical limit without compromising its query performance. Next, we introduce the hybrid index architecture as a way to efficiently modifying the aforementioned static data structures with bounded and amortized cost in performance and space. Finally, instead of structural compression, we approach the problem from an orthogonal direction by compressing the actual keys. We built a fast string compressor that can encode arbitrary input keys while preserving their order so that search trees can serve range queries directly based on compressed keys. Together, these three pieces form a practical recipe for achieving memory-efficiency in search trees and in DBMSs.

Concurrent search trees are crucial data abstractions widely used in many important systems such as databases, file systems and data storage. Like other fundamental abstractions for energy-efficient computing, concurrent search trees should support both high concurrency and fine-grained data locality in a platform-independent manner. However, existing portable fine-grained locality-aware search trees such as ones based on the van Emde Boas layout (vEB-based trees) poorly support concurrent update operations while existing highly-concurrent search trees such as non-blocking search trees do not consider fine-grained data locality. In this paper, we first present a novel methodology to achieve both portable fine-grained data locality and high concurrency for search trees. Based on the methodology, we devise a novel locality-aware concurrent search tree called GreenBST. To the best of our knowledge, GreenBST is the first practical search tree that achieves both portable fine-grained data locality and high concurrency. We analyze and compare GreenBST energy efficiency (in operations/Joule) and performance (in operations/second) with seven prominent concurrent search trees on a high performance computing (HPC) platform (Intel Xeon), an embedded platform (ARM), and an accelerator platform (Intel Xeon Phi) using parallel micro- benchmarks (Synchrobench). Our experimental results show that GreenBST achieves the best energy efficiency and performance on all the different platforms. GreenBST achieves up to 50 percent more energy efficiency and 60 percent higher throughput than the best competitor in the parallel benchmarks. These results confirm the viability of our new methodology to achieve both portable fine-grained data locality and high concurrency for search trees.

Sample-based tree search (SBTS) is an approach to solving Markov decision problems based on constructing a lookahead search tree using random samples from a generative model of the MDP. It encompasses Monte Carlo tree search (MCTS) algorithms like UCT as well as algorithms such as sparse sampling. SBTS is well-suited to solving MDPs with large state spaces due to the relative insensitivity of SBTS algorithms to the size of the state space. The limiting factor in the performance of SBTS tends to be the exponential dependence of sample complexity on the depth of the search tree. The number of samples required to build a search tree is O((|A|B)^d), where |A| is the number of available actions, B is the number of possible random outcomes of taking an action, and d is the depth of the tree. State abstraction can be used to reduce B by aggregating random outcomes together into abstract states. Recent work has shown that abstract tree search often performs substantially better than tree search conducted in the ground state space. This paper presents a theoretical and empirical evaluation of tree search with both fixed and adaptive state abstractions. We derive a bound on regret due to state abstraction in tree search that decomposes abstraction error into three components arising from properties of the abstraction and the search algorithm. We describe versions of popular SBTS algorithms that use fixed state abstractions, and we introduce the Progressive Abstraction Refinement in Sparse Sampling (PARSS) algorithm, which adapts its abstraction during search. We evaluate PARSS as well as sparse sampling with fixed abstractions on 12 experimental problems, and find that PARSS outperforms search with a fixed abstraction and that search with even highly inaccurate fixed abstractions outperforms search without abstraction. These results establish progressive abstraction refinement as a promising basis for new tree search algorithms, and we propose directions for future work within the progressive refinement framework.

ly speaking, what have we done in the previous section? After applying a number of rules in polynomial time to an instance of Vertex Cover, we arrived at a reduced instance whose size can solely be expressed in terms of the parameter k. Since this can be easily done in O(n) time, we have found a data reduction for Vertex Cover with guarantees concerning its running time as well as its effectiveness. These properties are formalized in the concepts of a problem kernel and the corresponding kernelization. Definition 1.2. Let L be a parameterized problem, that is, L consists of input pairs (I, k), where I is the problem instance and k is the parameter. A reduction to a problem kernel (or kernelization) means to replace an instance (I, k) by a reduced instance (I , k) called problem kernel in polynomial time such that (1) k ≤ k, (2) I ′ is smaller than g(k) for some function g only depending on k, and (3) (I, k) has a solution if and only if (I , k) has one. While this definition does not formally require that it is possible to reconstruct a solution for the original instance from a solution for the problem kernel, all kernelizations we are aware of easily allow for this. The methodological approach of kernelization, including various techniques of data reduction, is best learned by the concrete examples that we discuss in Section 1.3; there, we will also discuss kernelizations for Vertex Cover that even yield a kernel with a linear number of vertices in k. To conclude this section, we state some useful general observations and remarks concerning Definition 1.2 and its connections to fixed-parameter tractability. Most notably, there is a close connection between fixedparameter tractable problems and those problems that have a problem kernel—they are exactly the same. Theorem 1.3 (Cai et al.). Every fixed-parameter tractable problem is kernelizable and vice-versa. April 3, 2007 16:42 World Scientific Review Volume 9in x 6in fptcluster 8 F. Huffner, R. Niedermeier & S. Wernicke Unfortunately, the practical use of this theorem is limited: the running times of a fixed-parameter algorithm directly obtained from a kernelization is usually not practical; and, in the other direction, the theorem does not constructively provide us with a data reduction scheme for a fixedparameter tractable problem. Hence, the main use of Theorem 1.3 is to establish the fixed-parameter tractability or amenability to kernelization of a problem—or show that we need not search any further (e.g., if a problem is known to be fixed-parameter intractable, we do not need to look for a kernelization). Rule VC3 explicitly needed the value of the parameter k. We call this a parameter-dependent rule as opposed to the parameter-independent rules VC1 and VC2, which are oblivious to k. Of course, one typically does not know the actual value of k in advance and then has to get around this by iteratively trying different values of k. While, in practice, one would naturally prefer to avoid this extra outer loop, assuming explicit knowledge of the parameter clearly adds some leverage to finding data reduction rules and is hence frequently encountered in kernelizations. 1.2.2. Depth-Bounded Search Trees After preprocessing the given input data of a problem by a kernelization and cutting away its “easy parts,” we are left with the “really hard” problem kernel to be solved. A standard way to explore the huge search space of a computationally hard problem is to perform a systematic exhaustive search. This can be organized in a tree-like fashion, which is the main subject of this section. Certainly, search trees are no new idea and have been extensively used in the design of exact algorithms (e.g., see Ref. 37–41). The main contribution of fixed-parameter theory to search tree approaches is the consideration of search trees whose depth is bounded by the parameter, usually leading to search trees that are much smaller than those of naive brute-force searches. Additionally, the speed of search tree exploration can (provably) be improved by exploiting kernelizations. An extremely simple search tree approach for solving Vertex Cover is to just take one vertex and branch into two cases: either this vertex is in the vertex cover or not. This leads to a search tree of size O(2). As we outline In general, the constraint k < n is easily established. As Dehne et al. point out in their studies of Cluster Editing, it depends on the concrete problem which search strategy for the “optimum” value of k is most efficient to employ in practice. April 3, 2007 16:42 World Scientific Review Volume 9in x 6in fptcluster Fixed-Parameter Algorithms for Graph-Modeled Data Clustering 9

A new distributed algorithm is presented for constructing breadth first search (BFS) trees. A BFS tree is a tree of shortest paths from a given root node to all other nodes of a network under the assumption of unit edge weights; such trees provide useful building blocks for a number of routing and control functions in communication networks. The order of communication complexity for the new algorithm is O(V^{1.6} + E) where V is the number of nodes and E the number of edges. For dense networks with E \geq V^{1.6} this order of complexity is optimum.

Considering complex training images with search tree partitioning

In this paper, we propose a new tree search algorithm for performing vector quantization (VQ), and a processor and area efficient architecture for implementing it. The proposed algorithm consists of two phases: in the first phase, we perform a fast approximate search without using multiplication. In the second phase, we employ a known tree search algorithm on the neighborhood of the codevector found in the first phase. The size of the search space in the second phase depends on the desired image quality. For obtaining image quality comparable to the known tree (full) search based VQ, the proposed algorithm takes O(klogloglogN) (O(kloglogN)) time units, where N is the number of codevectors and k is the number of dimensions. In the proposed architecture, O(logloglogN) and O(loglogN) processing elements are used to obtain image quality which is comparable to those produced by the known tree search and full search based VQ, respectively. These implementations support real time operations. >

While volunteer computing, as a restricted model of parallel computing, has proved itself to be a successful paradigm of scientific computing with excellent benefit on cost efficiency and public outreach, many problems it solves are intrinsically highly parallel. However, many efficient algorithms, including backtracking search, take the form of a tree search on an extremely uneven tree that cannot be easily parallelized efficiently in the volunteer computing paradigm. We explore in this article how to perform such searches efficiently on volunteer computing projects. We propose a parallel tree search scheme, and we describe two examples of its real-world implementation, Harmonious Tree and Odd Weird Search, both carried out at the volunteer computing project yoyo@home. To confirm the observed efficiency of our scheme, we perform a mathematical analysis, which proves that, under reasonable assumption that agrees with experimental observation, our scheme is only a constant multiplicative factor away from perfect parallelism. Details on improving the overall performance are also discussed.

A problem in POY tree searches (and its work-around) when some sequences are observed to be absent in some terminals.

Maximum likelihood (ML) phylogenetic inference is widely used in phylogenomics. As heuristic searches most likely find suboptimal trees, it is recommended to conduct multiple (e.g., 10) tree searches in phylogenetic analyses. However, beyond its positive role, how and to what extent multiple tree searches aid ML phylogenetic inference remains poorly explored. Here, we found that a random starting tree was not as effective as the BioNJ and parsimony starting trees in inferring the ML gene tree and that RAxML-NG and PhyML were less sensitive to different starting trees than IQ-TREE. We then examined the effect of the number of tree searches on ML tree inference with IQ-TREE and RAxML-NG, by running 100 tree searches on 19,414 gene alignments from 15 animal, plant, and fungal phylogenomic datasets. We found that the number of tree searches substantially impacted the recovery of the best-of-100 ML gene tree topology among 100 searches for a given ML program. In addition, all of the concatenation-based trees were topologically identical if the number of tree searches was ≥10. Quartet-based ASTRAL trees inferred from 1 to 80 tree searches differed topologically from those inferred from 100 tree searches for 6/15 phylogenomic datasets. Finally, our simulations showed that gene alignments with lower difficulty scores had a higher chance of finding the best-of-100 gene tree topology and were more likely to yield the correct trees.

We introduce and study the problem of planning a trajectory for an agent to carry out a reconnaissance mission while avoiding being detected by an adversarial guard. This introduces a multi-objective version of classical visibility-based target search and pursuit-evasion problem. In our formulation, the agent receives a positive reward for increasing its visibility (by exploring new regions) and a negative penalty every time it is detected by the guard. The objective is to find a finite-horizon path for the agent that balances the trade off between maximizing visibility and minimizing detectability.We model this problem as a discrete, sequential, two-player, zero-sum game. We use two types of game tree search algorithms to solve this problem: minimax search tree and Monte-Carlo search tree. Both search trees can yield the optimal policy but may require possibly exponential computational time and space. We propose several pruning techniques to reduce the computational cost while still preserving optimality guarantees. Simulation results show that the proposed strategy prunes approximately three orders of magnitude nodes as compared to the brute-force strategy. We also find that the Monte-Carlo search tree saves approximately one order of computational time as compared to the minimax search tree.

Monte-Carlo Tree Search (MCTS) has achieved great success in combinatorial game, which has the characteristics of finite action state space, deterministic state transition and sparse reward. AlphaGo Zero combined MCTS and deep neural networks defeated the world champion Lee Sedol in the Go game, proving the advantages of tree search in combinatorial game with enormous search space. However, when the search space is continuous and even with chance factors, tree search methods like UCT failed. Because each state will be visited repeatedly with probability zero and the information in tree will never be used, that is to say UCT algorithm degrades to Monte Carlo rollouts. Meanwhile, the previous exploration experiences cannot be used to correct the next tree search process, and makes a huge increase in the demand for computing resources. To solve this kind of problem, this paper proposes a step-by-step Reverse Curriculum Learning with Truncated Tree Search method (RevCuT Tree Search). In order to retain the previous exploration experiences, we use the deep neural network to learn the state-action values at explored states and then guide the next tree search process. Besides, taking the computing resources into consideration, we establish a truncated search tree focusing on continuous state space rather than the whole trajectory. This method can effectively reduce the number of explorations and achieve the effect beyond the human level in our well designed single-player game with continuous state space and probabilistic state transition.

Like other fundamental abstractions for energy-efficient computing, search trees need to support both high concurrency and fine-grained data locality. However, existing locality-aware search trees such as ones based on the van Emde Boas layout vEB-based trees, poorly support concurrent update operations while existing highly-concurrent search trees such as the non-blocking binary search trees do not consider data locality. We present GreenBST, a practical energy-efficient concurrent search tree that supports fine-grained data locality as vEB-based trees do, but unlike vEB-based trees, GreenBST supports high concurrency. GreenBST is a k-ary leaf-oriented tree of GNodes where each GNode is a fixed size tree-container with the van Emde Boas layout. As a result, GreenBST minimizes data transfer between memory levels while supporting highly concurrent update operations. Our experimental evaluation using the recent implementation of non-blocking binary search trees, highly concurrent B-trees, conventional vEB trees, as well as the portably scalable concurrent trees shows that GreenBST is efficient: its energy efficiency in operations/Joule and throughput in operations/second are upi¾źto 65i¾ź% and 69i¾ź% higher, respectively, than the other trees on a high performance computing HPC platform Intel Xeon, an embedded platform ARM, and an accelerator platform Intel Xeon Phi. The results also provide insights into how to develop energy-efficient data structures in general.

In this paper, we propose a method for predicting a user's location based on their past movement patterns. There is no restriction on the length of past movement patterns when using this method to predict the current location. For this purpose, a modified search tree has been devised. The search tree is constructed in an effective manner while it additionally learns the movement patterns of a user one by one. In fact, the time complexity of the learning process for a movement pattern is linear. In this process, the search tree expands to take into consideration more details about the movement patterns when a pattern that conflicts with an existing trained pattern is found. In this manner, the search tree is trained to make an exact matching, as needed, for location prediction. In the experiments, the results showed that this method is highly accurate in comparison with more complex and sophisticated methods. Also, the accuracy deviation of users of this method is significantly lower than for any other methods. This means that this method is highly stable for the variations of behavioral patterns as compared to any other method. Finally, 1.47 locations were considered on average for making a prediction with this method. This shows that the prediction process is very efficient.

Search trees are a set of paths with branches or choices that enable a system to carry out the most sensible search approach at each stage of a search. A new design for subject access to online catalogs enlists search trees to identify the characteristics of end‐user queries for subjects, control system responses, and determine appropriate subject‐searching approaches in response to the subject queries users entered. The purpose of this article is to identify characteristics of the most difficult user queries and recommend enhancements to the new subject‐searching design to enable it to produce useful retrievals in response to the wide variety of queries users pose to online catalogs. Online catalogs governed by search trees are more effective than the users themselves in selecting subject‐searching approaches that would produce useful information for the subjects users seek. The enhanced search trees presented and tested in this article enlist subject‐searching approaches that are not typical of the functionality of operational online catalogs. Design and development is required to upgrade existing online catalogs with search trees and new subject‐searching functionality to be successful in responding with useful retrievals to the most difficult user queries.