A practical fpt algorithm for Flow Decomposition and transcript assembly

The Flow Decomposition problem, which asks for the smallest set of weighted paths that "covers" a flow on a DAG, has recently been used as an important computational step in transcript assembly. We prove the problem is in FPT when parameterized by the number of paths by giving a practical linear fpt algorithm. Further, we implement and engineer a Flow Decomposition solver based on this algorithm, and evaluate its performance on RNA-sequence data. Crucially, our solver finds exact solutions while achieving runtimes competitive with a state-of-the-art heuristic. Finally, we contextualize our design choices with two hardness results related to preprocessing and weight recovery. Specifically, $k$-Flow Decomposition does not admit polynomial kernels under standard complexity assumptions, and the related problem of assigning (known) weights to a given set of paths is NP-hard.Comment: Introduces software package Toboggan: Version 1.0. http://dx.doi.org/10.5281/zenodo.82163

Improving RNA Assembly via Safety and Completeness in Flow Decompositions

Extended version of RECOMB 2022 paperDecomposing a network flow into weighted paths is a problem with numerous applications, ranging from networking, transportation planning, to bioinformatics. In some applications we look for a decomposition that is optimal with respect to some property, such as the number of paths used, robustness to edge deletion, or length of the longest path. However, in many bioinformatic applications, we seek a specific decomposition where the paths correspond to some underlying data that generated the flow. In these cases, no optimization criteria guarantee the identification of the correct decomposition. Therefore, we propose to instead report the safe paths, which are subpaths of at least one path in every flow decomposition. In this work, we give the first local characterization of safe paths for flow decompositions in directed acyclic graphs, leading to a practical algorithm for finding the complete set of safe paths. In addition, we evaluate our algorithm on RNA transcript data sets against a trivial safe algorithm (extended unitigs), the recently proposed safe paths for path covers (TCBB 2021) and the popular heuristic greedy-width. On the one hand, we found that besides maintaining perfect precision, our safe and complete algorithm reports a significantly higher coverage (≈50 compared with the other safe algorithms. On the other hand, the greedy-width algorithm although reporting a better coverage, it also reports a significantly lower precision on complex graphs (for genes expressing a large number of transcripts). Overall, our safe and complete algorithm outperforms (by ≈20 greedy-width on a unified metric (F-score) considering both coverage and precision when the evaluated data set has a significant number of complex graphs. Moreover, it also has a superior time (4−5×) and space performance (1.2−2.2×), resulting in a better and more practical approach for bioinformatic applications of flow decomposition.Peer reviewe

Efficient Minimum Flow Decomposition via Integer Linear Programming

Extended version of RECOMB 2022 paperMinimum flow decomposition (MFD) is an NP-hard problem asking to decompose a network flow into a minimum set of paths (together with associated weights). Variants of it are powerful models in multiassembly problems in Bioinformatics, such as RNA assembly. Owing to its hardness, practical multiassembly tools either use heuristics or solve simpler, polynomial time-solvable versions of the problem, which may yield solutions that are not minimal or do not perfectly decompose the flow. Here, we provide the first fast and exact solver for MFD on acyclic flow networks, based on Integer Linear Programming (ILP). Key to our approach is an encoding of all the exponentially many solution paths using only a quadratic number of variables. We also extend our ILP formulation to many practical variants, such as incorporating longer or paired-end reads, or minimizing flow errors. On both simulated and real-flow splicing graphs, our approach solves any instance inPeer reviewe

Flow Decomposition With Subpath Constraints

Flow network decomposition is a natural model for problems where we are given a flow network arising from superimposing a set of weighted paths and would like to recover the underlying data, i.e., decompose the flow into the original paths and their weights. Thus, variations on flow decomposition are often used as subroutines in multiassembly problems such as RNA transcript assembly. In practice, we frequently have access to information beyond flow values in the form of subpaths, and many tools incorporate these heuristically. But despite acknowledging their utility in practice, previous work has not formally addressed the effect of subpath constraints on the accuracy of flow network decomposition approaches. We formalize the flow decomposition with subpath constraints problem, give the first algorithms for it, and study its usefulness for recovering ground truth decompositions. For finding a minimum decomposition, we propose both a heuristic and an FPTalgorithm. Experiments on RNA transcript datasets show that for instances with larger solution path sets, the addition of subpath constraints finds 13% more ground truth solutions when minimal decompositions are found exactly, and 30% more ground truth solutions when minimal decompositions are found heuristically.Peer reviewe

Survey of Consistent Network Updates

Computer networks have become a critical infrastructure. Designing dependable computer networks however is challenging, as such networks should not only meet strict requirements in terms of correctness, availability, and performance, but they should also be flexible enough to support fast updates, e.g., due to a change in the security policy, an increasing traffic demand, or a failure. The advent of Software-Defined Networks (SDNs) promises to provide such flexiblities, allowing to update networks in a fine-grained manner, also enabling a more online traffic engineering. In this paper, we present a structured survey of mechanisms and protocols to update computer networks in a fast and consistent manner. In particular, we identify and discuss the different desirable update consistency properties a network should provide, the algorithmic techniques which are needed to meet these consistency properties, their implications on the speed and costs at which updates can be performed. We also discuss the relationship of consistent network update problems to classic algorithmic optimization problems. While our survey is mainly motivated by the advent of Software-Defined Networks (SDNs), the fundamental underlying problems are not new, and we also provide a historical perspective of the subject

Queues, Planes and Games: Algorithms for Scheduling Passengers, and Decision Making in Stackelberg Games

In this dissertation, I present three theoretical results with real-world applications related to scheduling and distributionally-robust games, important fields in discrete optimization, and computer science. The first chapter provides simple, technology-free interventions to manage elevator queues in high-rise buildings when passenger demand far exceeds the capacity of the elevator system. The problem was motivated by the need to manage passengers safely in light of reduced elevator capacities during the COVID-19 pandemic. We use mathematical modeling, epidemiological expertise, and simulation to design and evaluate our algorithmic solutions. The key idea is to explicitly or implicitly group passengers that are going to the same floor into the same elevator as much as possible, substantiated theoretically using a technique from queuing theory known as stability analysis. This chapter is joint work with Charles Branas, Adam Elmachtoub, Clifford Stein, and Yeqing Zhou, directly in collaboration with the New York City Mayor’s Office of the Chief Technology Officer and the Department of Citywide Administrative Services. The second chapter proposes new algorithms for recomputing passenger itineraries for airlines during major disruptions when carefully planned schedules are thrown into disarray. An airline network is a massive temporal graph, often with tight regulatory and operational constraints. When disruptions propagate through an airline network, the objective is to \textit{recover} within a given time frame from a disruption, meaning we replan schedules affected by the disruption such that the new schedules have to match the originally planned schedules after the time frame. We aim to solve the large-scale airline recovery problem with quick, user-independent, consistent, and near-optimal algorithms. We provide new algorithms to solve the passenger recovery problem, given recovered flight and crew solutions. We build a preprocessing step and construct an Integer Program as well as a network-based approach based on solving multiple-label shortest path problems. Experiments show the tractability of our proposed algorithms on airline data sets with heavy flight disruptions. This chapter is joint work with Clifford Stein, stemming from an internship and collaboration with the Machine Learning team (Artificial Intelligence organization) of GE Global Research, Niskayuna, New York. The third chapter is about computing distributionally-robust strategies for a popular game theory model called Stackelberg games, where one player, called the leader, is able to commit to a strategy first, assuming the other player(s), called follower(s) would best respond to the strategy. In many of the real-world applications of Stackelberg games, parameters such as payoffs of the follower(s) are not known with certainty. Distributionally-robust optimization allows a distribution over possible model parameters, where this distribution comes from a set of possible distributions. The goal for the leader is to maximize their expected utility with respect to the worst-case distribution from the set. We initiate the study of distributionally-robust models for Stackelberg games, show that a distributionally-robust Stackelberg equilibrium always exists across a wide array of uncertainty models, and provide tractable algorithms for some general settings with experimental results. This chapter is joint work with Christian Kroer