BDD-Constrained Search: A Unified Approach to Constrained Shortest Path Problems

This paper shows how genetic programming (GP) can help in nding generalizing Boolean functions when only a small part of the function values are given. The selection pressure favours functions having as few subfunctions as possible while only using essential variables, so the resulting functions should have good generalization properties. For e ciency no S-expressions are used for representation, but a special case of directed acyclic graphs known as ordered binary decision diagrams (OBDDs), making it possible to learn the 20-multiplexer.

Binary decision diagrams representing complex logic circuits require a large number of nodes. This paper shows a new method to represent logic circuits using multiple decision diagrams. First, a given logic circuit is converted into a direct acyclic graph~(DAG). Then, the DAG is decomposed into clusters. Next, clusters are represented by multi-terminal binary decision diagrams for characteristic function~(decomposed MTBDDs for CF). It represents a logic circuit more compactly than the conventional MTBDD for CF. Finally, the decomposed MTBDDs for CF are converted into the multi-terminal multi-valued decision diagrams for CF~(decomposed MTMDDs for CF) to be stored in the given memory size. Also, the decomposed MTMDDs for CF is faster to evaluate than the conventional MTMDD for CF using the same memory size on a BDD machine.

Contributors

To improve machine translation system's translation quality and accurate rate, a case-based reasoning translation strategy was presented. Laying emphasis on the case reasoning part, a structure and semantic similarity algorithm was designed to calculate the sentence similarity. First, a dynamic filter is used to select the translation pattern roughly. Then, based on dynamic programming (DP) algorithm, the structure similarity was decided by the calculation of edit distance. In the process of path recall, an optimization function was defined to select the best matching path. Last, to match the pattern more exactly, the semantic similarity is calculated by the semantic tree structure. The experiment shows that the score of translation quality is 70.11 and the accurate rate can reach 89.4%

We investigate the design of dynamic programming algorithms in unreliable memories, i.e., in the presence of faults that may arbitrarily corrupt memory locations during the algorithm execution. As a main result, we devise a general resilient framework that can be applied to all local dependency dynamic programming problems, where updates to entries in the auxiliary table are determined by the contents of neighboring cells. Consider, as an example, the computation of the edit distance between two strings of length n and m. We prove that, for any arbitrarily small constant " 2 (0, 1] and n m, this problem can be solved correctly with high probability in O nm + 1+" worst-case time and O(nm + n ) space, when up to memory faults can be inserted by an adversary with unbounded computational power and is the actual number of faults occurring during the computation. We also show that an optimal edit sequence can be constructed in additional time O n + 1+" . It follows that our resilient algorithms match the running time and space usage of the standard non-resilient implementations while tolerating almost linearly-many faults. 1998 ACM Subject Classification B.8 [Performance and reliability]; F.2 [Analysis of algorithms and problem complexity]; I.2.8 [Dynamic programming].

The ordering of variables can have a significant effect on the size of the reduced binary decision diagram (BDD) that represents the set of solutions to a combinatorial optimization problem. It also influences the quality of the objective function bound provided by a limited-width relaxation of the BDD. We investigate these effects for the maximum independent set problem. By identifying variable orderings for the BDD, we show that the width of an exact BDD can be given a theoretical upper bound for certain classes of graphs. In addition, we draw an interesting connection between the Fibonacci numbers and the width of exact BDDs for general graphs. We propose variable ordering heuristics inspired by these results, as well as a k-layer look-ahead heuristic applicable to any problem domain. We find experimentally that orderings that result in smaller exact BDDs have a strong tendency to produce tighter bounds in relaxation BDDs.

Dynamic programming (DP) on tree decompositions is a well studied approach for solving hard problems efficiently. Usually, implementations rely on tables for storing information, and algorithms specify how tuples are manipulated during traversal of the decomposition. However, a bottleneck of such table-based algorithms is relatively high memory consumption. Binary Decision Diagrams (BDDs) and related concepts have been shown to be very well suited to store information efficiently. While several techniques have been proposed that combine DP with efficient BDD-based storage for some particular problems, in this work we present a general approach where DP algorithms are specified on a logical level in form of set-based formula manipulation operations that are executed directly on the BDD data structure. In the paper, we provide several case studies in order to illustrate the method at work, and report on preliminary experiments. These show promising results, both with respect to memory and run-time.

Skeleton estimation of directed acyclic graphs using partial least squares from correlated data

This paper presents an optimization model for identifying limited-width relaxed binary decision diagrams (BDDs) with tightest possible relaxation bounds. The model developed is a network design model and is used to identify which nodes and arcs should be in a relaxed BDD so that the objective function bound is as close to the optimal value as possible. The model is presented specifically for the 0–1 knapsack problem, but can be extended to other problem classes that have been investigated in the stream of research on using decision diagrams for combinatorial optimization problems. Preliminary experimental results indicate that the bounds provided by the relaxed BDDs are far superior to the bounds achieved by relaxed BDDs constructed via previously published compilation algorithms.

We present DAGSENS, a new theory for parametric transient sensitivity analysis of Differential Algebraic Equation systems (DAEs), such as SPICE-level circuits. The key ideas behind DAGSENS are, (1) to represent the entire sequence of computations, starting from DAE parameters, all the way up to the objective function whose sensitivity is needed, as a Directed Acyclic Graph (DAG) called the "sensitivity DAG", and (2) to compute the required sensitivities efficiently (with time complexity linear in the size of the sensitivity DAG) by leveraging dynamic programming techniques to traverse the DAG. DAGSENS is simple, elegant, and easy-to-understand compared to existing sensitivity analysis approaches; for example, in DAGSENS, one can switch between direct and adjoint transient sensitivities just by changing the direction of DAG traversal (i.e., topological order vs. reverse topological order). Also, DAGSENS is significantly more powerful than existing sensitivity analysis approaches because it allows one to compute the sensitivities of a much more general class of objective functions, including those defined based on "events" that occur during a transient simulation (e.g., a node voltage crossing a particular threshold, a phase-locked loop (PLL) achieving lock, a signal reaching its maximum/minimum value during a transient run, etc.). In this paper, we apply DAGSENS to compute the sensitivities of important event-driven performance metrics in several real-world electronic and biological applications, including high-speed communication (featuring sub-systems such as I/0 links and PLLs), statistical cell library characterization, and gene expression in Drosophila embryos.

This paper delves into the specific application of dynamic programming algorithms in solving the shortest path problem in multi-stage graphs. Faced with a given multi-stage graph structure, we are committed to finding an optimal path from vertex 0 to vertex 9, with the aim of minimizing the total length of the pipeline laid, which represents a classic optimization problem. To efficiently and accurately address this challenge, we have chosen dynamic programming as our core tool. This algorithm constructs solutions step-by-step and leverages the results of already solved sub problems to avoid redundant calculations, thereby significantly enhancing computational efficiency. The paper not only elaborates on the fundamental principles of dynamic programming and its application in the shortest path problem within multi-stage graphs, but also provides specific algorithm implementation code in C++ programming language. Our goal is to offer readers a comprehensive and in-depth guide, enabling them to understand and apply dynamic programming algorithms to successfully solve similar optimization problems related to the shortest path in multi-stage graphs.

Genomic variations in a reference collection are naturally represented as genome variation graphs. Such graphs encode common subsequences as vertices and the variations are captured using additional vertices and directed edges. The resulting graphs are directed graphs possibly with cycles. Existing algorithms for aligning sequences on such graphs make use of partial order alignment (POA) techniques that work on directed acyclic graphs (DAGs). To achieve this, acyclic extensions of the input graphs are first constructed through expensive loop unrolling steps (DAGification). Furthermore, such graph extensions could have considerable blowup in their size and in the worst case the blow-up factor is proportional to the input sequence length. We provide a novel alignment algorithm V-ALIGN that aligns the input sequence directly on the input graph while avoiding such expensive DAGification steps. V-ALIGN is based on a novel dynamic programming (DP) formulation that allows gapped alignment directly on the input graph. It supports affine and linear gaps. We also propose refinements to V-ALIGN for better performance in practice. With the proposed refinements, the time to fill the DP table has linear dependence on the sizes of the sequence, the graph, and its feedback vertex set. We conducted experiments to compare the proposed algorithm against the existing POA-based techniques. We also performed alignment experiments on the genome variation graphs constructed from the 1000 Genomes data. For aligning short sequences, standard approaches restrict the expensive gapped alignment to small filtered subgraphs having high similarity to the input sequence. In such cases, the performance of V-ALIGN for gapped alignment on the filtered subgraph depends on the subgraph sizes.

Randomized search heuristics, among them evolutionary algorithms, are applied to problems whose structure is not well understood, as well as to hard problems in combinatorial optimization to get near-optimal solutions. We present a new approach implementing simple parallel evolutionary algorithms by relational methods. Populations are represented as relations which are implicitly encoded by (reduced, ordered) binary decision diagrams. Thereby, the creation and evaluation is done in parallel, which increases efficiency considerably.KeywordsEvolutionary AlgorithmVertex CoverRelational AlgebraPresent SolutionBinary Decision DiagramThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

We present a novel multiple testing method for testing null hypotheses that are structured in a directed acyclic graph (DAG). The method is a top-down method that strongly controls the familywise error rate and can be seen as a generalization of Meinshausen's procedure for tree-structured hypotheses. Just as Meinshausen's procedure, our proposed method can be used to test for variable importance, only the corresponding variable clusters can be chosen more freely, because the method allows for multiple parent nodes and partially overlapping hypotheses. An important application of our method is in gene set analysis, in which one often wants to test multiple gene sets as well as individual genes for their association with a clinical outcome. By considering the genes and gene sets as nodes in a DAG, our method enables us to test both for significant gene sets as well as for significant individual genes within the same multiple testing procedure. The method will be illustrated by testing Gene Ontology terms for evidence of differential expression in a survival setting and is implemented in the R package cherry.

Algorithms proposed in this article aim to find all edges on any smallest route connecting two nodes of a directed acyclic graph (DAG). However, for a DAG with N nodes, the number of routes possible connecting any two nodes can be exponential. Hence, it is unfeasible to compute all the routes to attain the smallest ones in the polynomial-time and eventually produce a set of all edges that contribute or make any of the smallest routes. This article presents all the existing approaches to solve the problem, and we propose a new technique to compute the required edges by taking advantage of parallel computing using the C++ OpenMP API by parallelizing one of the existing approaches. We present a step-by-step procedure to convert a sequential algorithm into a parallel algorithm by identifying the parallelizable tasks. We also took advantage of parallel Dijkstra’s by using the nested parallelism feature of OpenMP and presented a technique for deciding the optimal number of threads to run the tasks that involve unbounded parallelism. Using parallel computing, we could achieve a speedup of over 13% for a complete graph. The techniques proposed here are not confined only to this particular use case. However, these have a more extensive scope in dynamic programming (DP), graph theory, and counting problems pf.KeywordsAlgorithmParallel-computingParallel-dijkstraNested-parallelismAll-edges-on-any-smallest-routeC++Directed-acyclic-graphOpenMP APIAll-possible-smallest-routes