Arnab Ganguly

Jump-Diffusion Approximation of Stochastic Reaction Dynamics

Biochemical processes in living cells are comprised of reactions with vastly varying speeds and molecular counts of the reactant species. Classical deterministic or stochastic approaches to modeling often fail to exploit this multiscale nature of the reaction systems. In this paper, we propose a jump-diffusion approximation to these types of multiscale systems that couples the two traditional modeling approaches. An error bound of the proposed approximation is derived and used to partition the reactions into two sets, where one set is modeled by continuous stochastic differential equations and the other by discrete state processes. The methodology leads to a very efficient dynamic partitioning algorithm which has been implemented for several multiscale reaction systems. The gain in computational efficiency is evident in all these examples, which include a realistically sized model of a signal transduction cascade coupled to a gene expression dynamics.

Restricted Shortest Path in Temporal Graphs

The restricted shortest path RSP problem on directed networks is a well-studied problem, and has a large number of applications such as in Quality of Service routing. The problem is known to be NP-hard. In certain cases, however, the network is not static i.e., edge parameters vary over time. In light of this, we extend the RSP problem for general networks to that for temporal networks. We present several exact algorithms for this problem, one of which uses heuristics, and is similar to the

Forbidden Extension Queries

A^*

A Linear-Space Data Structure for Range-LCP Queries in Poly-Logarithmic Time

algorithm. We experimentally evaluate these algorithms by simulating them on both existing temporal networks, and synthetic ones. Furthermore, based on one of the pseudo-polynomial exact algorithms, we derive a fully polynomial time approximation scheme.

Ranked document retrieval for multiple patterns

The fields of succinct data structures and compressed text indexing have seen quite a bit of progress over the last two decades. An important achievement, primarily using techniques based on the Burrows-Wheeler Transform (BWT), was obtaining the full functionality of the suffix tree in the optimal number of bits. A crucial property that allows the use of BWT for designing compressed indexes is order-preserving suffix links. Specifically the relative order between two suffixes in the subtree of an internal node is same as that of the suffixes obtained by truncating the first character of the two suffixes. Unfortunately, in many variants of the text-indexing problem, for e.g., parameterized pattern matching, 2D pattern matching, and order-isomorphic pattern matching, this property does not hold. Consequently, the compressed indexes based on BWT do not directly apply. Furthermore, a compressed index for any of these variants has been elusive throughout the advancement of the field of succinct data structures. We achieve a positive breakthrough on one such problem, namely the Parameterized Pattern Matching problem. Let T be a text that contains n characters from an alphabet Σ, which is the union of two disjoint sets: Σs containing static characters (s-characters) and Σp containing parameterized characters (p-characters). A pattern P (also over Σ) matches an equal-length substring S of T iff the s-characters match exactly, and there exists a one-to-one function that renames the p-characters in S to that in P. The task is to find the starting positions (occurrences) of all such substrings S. Previous index [Baker, STOC 1993], known as Parameterized Suffix Tree, requires Θ(n log n) bits of space, and can find all occ occurrences in time O(|P|log σ+occ), where σ = |Σ|. We introduce an n log σ + O(n)-bit index with O(|Plog σ+occ·log n log σ) query time. At the core, lies a new BWT-like transform, which we call the Parameterized Burrows-Wheeler Transform (pBWT). The techniques are extended to obtain a succinct index for the Parameterized Dictionary Matching problem of Idury and Schaffer [CPM, 1994].

A Large-Scale Network with Moving Servers

Document retrieval is one of the most fundamental problem in information retrieval. The objective is to retrieve all documents from a document collection that are relevant to an input pattern. Several variations of this problem such as ranked document retrieval, document listing with two patterns and forbidden patterns have been studied. We introduce the problem of document retrieval with forbidden extensions. Let D={T_1,T_2,...,T_D} be a collection of D string documents of n characters in total, and P^+ and P^- be two query patterns, where P^+ is a proper prefix of P^-. We call P^- as the forbidden extension of the included pattern P^+. A forbidden extension query asks to report all occ documents in D that contains P^+ as a substring, but does not contain P^- as one. A top-k forbidden extension query asks to report those k documents among the occ documents that are most relevant to P^+. We present a linear index (in words) with an O(|P^-| + occ) query time for the document listing problem. For the top-k version of the problem, we achieve the following results, when the relevance of a document is based on PageRank: - an O(n) space (in words) index with O(|P^-|log sigma+ k) query time, where sigma is the size of the alphabet from which characters in D are chosen. For constant alphabets, this yields an optimal query time of O(|P^-|+ k). - for any constant epsilon > 0, a |CSA| + |CSA^*| + Dlog frac{n}{D} + O(n) bits index with O(search(P)+ k cdot tsa cdot log ^{2+epsilon} n) query time, where search(P) is the time to find the suffix range of a pattern P, tsa is the time to find suffix (or inverse suffix) array value, and |CSA^*| denotes the maximum of the space needed to store the compressed suffix array CSA of the concatenated text of all documents, or the total space needed to store the individual CSA of each document.

Structural Pattern Matching - Succinctly

Given a text \(\mathsf {T}\) having \(n\) characters, we consider the non-overlapping indexing problem defined as follows: pre-process \(\mathsf {T}\) into a data-structure, such that whenever a pattern \(P\) comes as input, we can report a maximal set of non-overlapping occurrences of \(P\) in \(\mathsf {T}\). The best known solution for this problem takes linear space, in which a suffix tree of \(\mathsf {T}\) is augmented with \(O(n)\)-word data structures. A query \(P\) can be answered in optimal \(O(|P|+\mathsf {nocc})\) time, where \(\mathsf {nocc}\) is the output size [Cohen and Porat, ISAAC 2009]. We present the following new result: let \(\mathsf {CSA}\) (not necessarily a compressed suffix array) be an index of \(\mathsf {T}\) that can compute (i) the suffix range of \(P\) in \(\mathsf {search}(P)\) time, and (ii) a suffix array or an inverse suffix array value in \(\mathsf {t_{SA}}\) time; then by using \(\mathsf {CSA}\) alone, we can answer a query \(P\) in \(O(\mathsf {search}(P)+ \mathsf {nocc}\cdot \mathsf {t_{SA}})\) time. Additionally, we present an improved result for a generalized version of this problem called range non-overlapping indexing.

Stabbing Colors in One Dimension

Let \(\mathsf {T}[1,n]\) be a text of length n and \(\mathsf {T}[i,n]\) be the suffix starting at position i. Also, for any two strings X and Y, let \(\mathsf {LCP}(X, Y)\) denote their longest common prefix. The range-LCP of \(\mathsf {T}\) w.r.t. a range \([\alpha ,\beta ]\), where \(1\le \alpha < \beta \le n\) is Open image in new window Amir et al. [ISAAC 2011] introduced the indexing version of this problem, where the task is to build a data structure over \(\mathsf {T}\), so that \(\mathsf {rlcp}(\alpha ,\beta )\) for any query range \([\alpha ,\beta ]\) can be reported efficiently. They proposed an \(O(n\log ^{1+\epsilon } n)\) space structure with query time \(O(\log \log n)\), and a linear space (i.e., O(n) words) structure with query time \(O(\delta \log \log n)\), where \(\delta = \beta -\alpha +1\) is the length of the input range and \(\epsilon > 0\) is an arbitrarily small constant. Later, Patil et al. [SPIRE 2013] proposed another linear space structure with an improved query time of \(O(\sqrt{\delta }\log ^{\epsilon } \delta )\). This poses an interesting question, whether it is possible to answer \(\mathsf {rlcp}(\cdot ,\cdot )\) queries in poly-logarithmic time using a linear space data structure. In this paper, we settle this question by presenting an O(n) space data structure with query time \(O(\log ^{1+\epsilon } n)\) and construction time \(O(n\log n)\).