A Unified Strategy for Formal Derivation and Proof of Binary Tree Nonrecursive Algorithms

Multilevel Marketing (MLM) business visualizes a business network into a hierarchical tree consisting of relationships between nodes. In its application, a branch is generated from each node which when visualized becomes a tree with a height that continues to increase and will consume space which will have an impact in terms of less than optimal data access. In order for the tree structure to be formed from relationships between nodes with hierarchically ordered data, and to streamline time in the search and data access process, an MLM business process information system was built by applying the Binary Tree algorithm. The concept in the Binary tree itself is a hierarchical organization of several nodes, where each node has no more than 2. Nodes that are under a node are called children of the node. A node above a node is called the parent of that node. A binary search tree is a search in a binary tree by tracing nodes that are placed in the left branch if the information content sent is smaller than the information at the root, or tracing the right branch if the information content is stated to be greater than the root. The goal is to implement sorted data into the information system in accordance with the hierarchy of the MLM system and in this way data retrieval can be done quickly and easily.

In this paper we consider the class of binary trees and present the results of a comprehensive experimental study on the four most representative algorithms for drawing trees, one for each of the following treedrawing approaches: Separation-Based, Path-based, Level-based, and Ringed Circular Layout. We establish a simpler, more intuitive format for storing binary trees in files and create a large suite of randomlygenerated, unbalanced, complete, AVL, Fibonacci, and molecular combinatory binary trees of various sizes. Our study is therefore conducted on randomly-generated, unbalanced, and AVL binary trees with between 100 and 50, 000 nodes, on Fibonacci trees Tn for n = 1, 2, ..., 45, 46 (143 to 46, 367 nodes), on complete binary trees of size 2−1 for n = 7, 8, ..., 15, 16 (127 to 65, 535 nodes), and on molecular combinatory binary trees with between 133 and 50, 005 nodes. Our study yields 70 charts comparing the performance of the drawing algorithms with respect to ten quality measures, namely Area, Aspect Ratio, Size, Total Edge Length, Average Edge Length, Maximum Edge Length, Uniform Edge Length, Angular Resolution, Closest Leaf, and Farthest Leaf. None of the algorithms has been found to be the best in all categories. This observation leads us to create an adaptive system that determines the type of a binary tree and then selects an algorithm to draw the tree depending upon the specified quality measures. Currently, our adaptive tree drawing system recognizes all six types of binary trees and all ten measures included in our experimental study. Under our settings, our adaptive tree drawing system outperforms any system using a single binary tree drawing algorithm. Submitted: April 2007 Reviewed: June 2007 Revised: August 2007 Accepted: October 2007 Final: November 2007 Published: June 2008 Article type: Regular Paper Communicated by: S. Kobourov E-mail addresses: rusu@rowan.edu (Adrian Rusu) santia09@students.rowan.edu (Confesor Santiago) 132 Rusu & Santiago Grid Drawings of Binary Trees

Th is paper presents a new random mu ltiple access control protocol -1-persistent CSMA control protocol based on improved binary tree conflict resolution algorithm.First, the paper gives an outline of 1-persistent CSMA and the binary tree conflict-resolving algorith m by build ing a mathematical model and using the average cycle method, and then respectively obtains the throughput and the number of time -slots of the protocol and the algorith m.The simulation results are g iven, and agree well with theoretical values.But, in a shared channel, each user independently sends information packets randomly, and it is prone to conflict and resulting in the failure.Especially to the 1-persistent CSMA control protocol, when the load is larger, it has a lower throughput and greatly increasing the probability of channel conflict.Therefore, bringing in the binary tree conflict-resolving algorith m is a good method to imp rove the throughput, especially the improved binary tree conflict resolution algorith m.So at last, the paper introduces the random mu ltip le access protocol comb ined improved binary tree conflict resolution algorith m and 1-persistent CSMA protocol, obtains the throughput and gives the simulations of the joint protocol.Theoretical calculations and experimental results show that 1-persistent CSMA protocol with conflict-resolving has a better performance.

Addition of two binary numbers is a fundamental operation in electronic circuits. Several integer adder architectures have been proposed. Their formal properties are well known, but the proofs are either incomplete or difficult to find. In this paper, we present a formal proof for the correctness of prefix adders. Both sequential and parallel algorithms are formalized and proved. In contrast to previous proofs using higher order functions and rewriting systems, our work is based on first order recursive equations, which are familiar to the computer arithmetic community and are therefore understandable by people working on VLSI circuit design. This study sets up a basis for further work on formal proofs of computer arithmetic algorithms.

Binary metaheuristic algorithms for 0–1 knapsack problems: Performance analysis, hybrid variants, and real-world application

This paper examines the use of binary trees in the design of efficient parallel algorithms. Using binary trees, we develop efficient algorithms for several scheduling problems. The shared memory model for parallel computation is used. Our success in using binary trees for parallel computations, indicates that the binary tree is an important and useful design tool for parallel algorithms.

With a view to reducing the distance between company and consumer, an enterprise should be able to offer enough differentiation in products to meet the consumer's needs and requirements regarding production process and cost. This is referred to as a ‘mass customization production environment’. In such an environment, the variety of product configurations causes many problems pertaining to information processing and management. In this study, the authors attempted to propose a binary-tree-based algorithm to coordinate the sale and R&D departments. Based upon the binary tree concept, the system not only offers the data structure and graph representation for product information, but also searches for feasible configuration solutions that meet the customer's needs. Furthermore, a profit analysis is proposed to serve as a criterion for marketing staff 's strategy. A screwdriver and a PC are used as practical examples to illustrate the application of the binary-tree-based algorithm in this study. Finally, the C++ programming language is used to simulate and verify the proposed method.

The coding gain that can be achieved by improving the coding order of B frames in the H.264/AVC standard is investigated in this work. We first represent the coding order of B frames and their reference frames with a binary tree. We then formulate a recursive equation to find out the binary tree that provides a suboptimal, but very efficient, coding order. The recursive equation is efficiently solved using a dynamic programming method. Furthermore, we extend the coding order improvement technique to the case of multiview video sequences, in which the quadtree representation is used instead of the binary tree representation. Simulation results demonstrate that the proposed algorithm provides significantly better R-D performance than conventional prediction structures.

Many classification techniques are originally designed to solve a binary problem, but practically many classification problems involve more than two classes. A multiclass problem can be decomposed into binary sub-problems, each solved by a binary classifier. Aside from using one-against-one (OAO) or one-against-all (OAA) decomposition scheme, an ensemble of binary classifiers can be constructed hierarchically. In this study, we focus in multiclass classification with a binary classification tree and propose a new approach in splitting a top-down tree by grouping observations into two clusters with k-mean clustering. Unlike a traditional class-clustering approach, this observation-based algorithm allows one class to appear in two meta-classes so it can be examined in both sub-trees. A data cleaning process is also performed to avoid insignificant tree splits. The experiment shows how our proposed algorithm (BCTOB) performed on different data sets, compared with other binary classification tree algorithms. Then advantages and disadvantages of the algorithm are discussed.

This paper presents natural synthesis, which generalizes the proof-theoretic synthesis technique to support very expressive logic theories. This approach leverages the natural proof methodology and reduces an intractable, unbounded-size synthesis problem to a tractable, bounded-size synthesis problem, which is amenable to be handled by modern inductive synthesis engines. The synthesized program admits a natural proof and is a provably-correct solution to the original synthesis problem. We explore the natural synthesis approach in the domain of imperative data-structure manipulations and present a novel syntax-guided synthesizer based on natural synthesis. The input to our system is a program template together with a rich functional specification that the synthesized program must meet. Our system automatically produces a program implementation along with necessary proof artifacts, namely loop invariants and ranking functions, and guarantees the total correctness with a natural proof. Experiments show that our natural synthesizer can efficiently produce provably-correct implementations for sorted lists and binary search trees. To our knowledge, this is the first system that can automatically synthesize these programs, their functional correctness and their termination in tandem from bare-bones control flow skeletons.

On Rotations and the Generation of Binary Trees

A representation of the partitions of an integer as a binary tree is presented, and the structure of this tree is related to the lexicographic ordering of the set of partitions. The appropriate recursive traversal algorithm for this binary tree immediately yields a recursive algorithm for generating the set of partitions in lexicographic order. Further consideration of the structure of the tree enables us to transform this version of the algorithm into a non-recursive loop-free version. Similar consideration of another recursive traversal algorithm yields corresponding algorithms for generating the set of partitions in a different order.

The logic of Owicki and Gries is a well-known logic for verifying safety properties of concurrent programs. Using this logic, Feijen and van Gasteren describe a method for deriving concurrent programs based on safety. In this work, we explore derivation techniques of concurrent programs using progress-based reasoning. We use a framework that combines the safety logic of Owicki and Gries, and the progress logic of UNITY. Our contributions improve the applicability of our earlier techniques by reducing the calculational overhead in the formal proofs and derivations. To demonstrate the effectiveness of our techniques, a derivation of Dekker’s mutual exclusion algorithm is presented. This derivation leads to the discovery of some new and simpler variants of this famous algorithm.

Binary Search Tree (BST) is an important data structure for managing ordered data. Many algorithms have been proposed for concurrent manipulation of a binary search tree in an asynchronous shared memory system that supports search, insert and delete operations based on both external and internal representations of a search tree. An important step in executing an operation on a tree is to traverse the tree from top-to-down in order to locate the operation's window. A process may need to perform this traversal several times to handle failures occurring due to other processes performing concurrent updates on the tree. Most concurrent algorithms that have been proposed so far use a naive approach and simply restart the traversal from the root of the tree. In this work, we present a new approach to recover from such failures more efficiently for certain types of concurrent binary search tree algorithms using local recovery by restarting the traversal from the middle of the tree in order to locate an operation's window (tree section of interest). Our approach is sufficiently general in the sense that it can be applied to most of the existing concurrent binary search trees using internal representation based on both blocking as well as non-blocking approaches. Using experimental evaluation, we demonstrate that our local recovery approach can significantly improve the performance of a concurrent internal BST by up to 124.7% when the contention is high.

When verifying software properties by using automatic formal verification methods, loop structures require manually provided loop invariants to enable automatic verification. To solve the difficulty of manually writing loop invariants in automated verification, we propose a novel approach to abstract the behavior of the loop structure. Through this abstraction method, the trends and ranges of variables in loop structures can be obtained. The verifier utilizes the abstracted information to automatically verify whether integer overflow vulnerabilities exist in the program. We implemented an automated formal verification tool, VeriOover, based on this method for detecting integer overflow in C language programs. The tool parses input programs into abstract syntax trees, converts the nondeterministic values into symbolic variables, and leverages symbolic execution and loop abstraction for program state analysis. VeriOover generates program assertions based on each program state to determine if an integer overflow exists in the program at that time. VeriOover is implemented and publicly available as an open-source project at https://github.com/Rw1nd/VeriOover.