We present the first data structures that maintain near optimal maximum cardinality and maximum weighted matchings on sparse graphs in sub linear time per update. Our main result is a data structure that maintains a (1+ϵ) approximation of maximum matching under edge insertions/deletions in worst case O(√mϵ-2) time per update. This improves the 3/2 approximation given by Neiman and Solomon [20] which runs in similar time. The result is based on two ideas. The first is to re-run a static algorithm after a chosen number of updates to ensure approximation guarantees. The second is to judiciously trim the graph to a smaller equivalent one whenever possible. We also study extensions of our approach to the weighted setting, and combine it with known frameworks to obtain arbitrary approximation ratios. For a constant ϵ and for graphs with edge weights between 1 and N, we design an algorithm that maintains an (1+ϵ) approximate maximum weighted matching in O(√m log N) time per update. The only previous result for maintaining weighted matchings on dynamic graphs has an approximation ratio of 4.9108, and was shown by An and et al. [2], [3].

Fully Dynamic (1+ e)-Approximate Matchings

We present a Las Vegas algorithm for dynamically maintaining a minimum spanning forest of an n-node graph undergoing edge insertions and deletions. Our algorithm guarantees an O(n^{o(1)})} worst-case} update time with high probability. This significantly improves the two recent Las Vegas algorithms by Wulff-Nilsen \cite{Wulff-Nilsen16a} with update time O(n^{0.5-&#x2265;ilon}) for some constant &#x2265;ilon 0 and, independently, by Nanongkai and Saranurak \cite{NanongkaiS16} with update time O(n^{0.494}) (the latter works only for maintaining a spanning forest).Our result is obtained by identifying the common framework that both two previous algorithms rely on, and then improve and combine the ideas from both works. There are two main algorithmic components of the framework that are newly improved and critical for obtaining our result. First, we improve the update time from O(n^{0.5-&#x2265;ilon}) in \cite{Wulff-Nilsen16a} to O(n^{o(1)}) for decrementally removing all low-conductance cuts in an expander undergoing edge deletions. Second, by revisiting the contraction technique by Henzinger and King \cite{HenzingerK97b} and Holm et al. \cite{HolmLT01, we show a new approach for maintaining a minimum spanning forest in connected graphs with very few (at most (1+o(1))n) edges. This significantly improves the previous approach in \cite{Wulff-Nilsen16a, NanongkaiS16} which is based on Fredericksons 2-dimensional topology tree \cite{Frederickson85} and illustrates a new application to this old technique.

Dynamic Minimum Spanning Forest with Subpolynomial Worst-Case Update Time

We present a streaming algorithm for constructing sparse spanners and show that our algorithm significantly outperforms the state-of-the-art algorithm for this task (due to Feigenbaum et al.). Specifically, the processing time per edge of our algorithm is O(1), and it is drastically smaller than that of the algorithm of Feigenbaum et al., and all other efficiency parameters of our algorithm are no greater (and some of them are strictly smaller) than the respective parameters of the state-of-the-art algorithm. We also devise a fully dynamic centralized algorithm maintaining sparse spanners. This algorithm has incremental update time of O(1), and a nontrivial decremental update time. To our knowledge, this is the first fully dynamic centralized algorithm for maintaining sparse spanners that provides nontrivial bounds on both incremental and decremental update time for a wide range of stretch parameter t.

/pdf/streaming-and-fully-dynamic-centralized-algorithms-for-52f7v4y0cm.pdf

Streaming and fully dynamic centralized algorithms for constructing and maintaining sparse spanners

The paper concerns graph spanners that are resistant to vertex or edge failures. Given a weighted undirected n-vertex graph G=(V,E) and an integer k ≥ 1, the subgraph H=(V,E'), E'⊆ E, is a spanner of stretch k (or, a k-spanner) of G if δH(u,v) ≤ k· δG(u,v) for every u,v ∈ V, where δG'(u,v) denotes the distance between u and v in G'. Graph spanners were extensively studied since their introduction over two decades ago. It is known how to efficiently construct a (2k-1)-spanner of size O(n1+1/k), and this size-stretch tradeoff is conjectured to be tight.The notion of fault tolerant spanners was introduced a decade ago in the geometric setting [Levcopoulos et al., STOC'98]. A subgraph H is an f-vertex fault tolerant k-spanner of the graph G if for any set F⊆ V of size at most f and any pair of vertices u,v ∈ V \ F, the distances in H satisfy δH \ F(u,v) ≤ k· δG \ F(u,v). Levcopoulos et al. presented an efficient algorithm that given a set S of n points in Rd, constructs an f-vertex fault tolerant geometric (1+e)-spanner for S, that is, a sparse graph H such that for every set F⊆ S of size f and any pair of points u,v ∈ S \ F, δH \ F(u,v) ≤ (1+e) |uv|, where |uv| is the Euclidean distance between u and v. A fault tolerant geometric spanner with optimal maximum degree and total weight was presented in [Czumaj & Zhao, SoCG'03]. This paper also raised as an open problem the question whether it is possible to obtain a fault tolerant spanner for an arbitrary undirected weighted graph.The current paper answers this question in the affirmative, presenting an f-vertex fault tolerant (2k-1)-spanner of size O(f2 kf+1 · n1+1/klog1-1/kn). Interestingly, the stretch of the spanner remains unchanged while the size of the spanner only increases by a factor that depends on the stretch k, on the number of potential faults f, and on logarithmic terms in n. In addition, we consider the simpler setting of f-edge fault tolerant spanners (defined analogously). We present an f-edge fault tolerant 2k-1 spanner with edge set of size O(f· n1+1/k) (only f times larger than standard spanners). For both edge and vertex faults, our results are shown to hold when the given graph G is weighted.

/pdf/fault-tolerant-spanners-for-general-graphs-1oupcaqejl.pdf

Fault-tolerant spanners for general graphs

In this paper we consider the decremental single-source shortest paths (SSSP) problem, where given a graph G and a source node s the goal is to maintain shortest paths between s and all other nodes in G under a sequence of online adversarial edge deletions. In their seminal work, Even and Shiloach [JACM 1981] presented an exact solution to the problem with only O(mn) total update time over all edge deletions. Their classic algorithm was the best known result for the decremental SSSP problem for three decades, even when approximate shortest paths are allowed. The first improvement over the Even-Shiloach algorithm was given by Bernstein and Roditty [SODA 2011], who for the case of an unweighted and undirected graph presented an approximate (1+) algorithm with constant query time and a total update time of O(n2+O(1/√logn)). This work triggered a series of new results, culminating in a recent breakthrough of Henzinger, Krinninger and Nanongkai [FOCS 14], who presented a -approximate algorithm whose total update time is near linear O(m1+ O(1/√logn)). In this paper they posed as a major open problem the question of derandomizing their result. In fact, all known improvements over the Even-Shiloach algorithm are randomized. All these algorithms maintain some truncated shortest path trees from a small subset of nodes. While in the randomized setting it is possible to “hide” these nodes from the adversary, in the deterministic setting this is impossible: the adversary can delete all edges touching these nodes, thus forcing the algorithm to choose a new set of nodes and incur a new computation of shortest paths. In this paper we present the first deterministic decremental SSSP algorithm that breaks the Even-Shiloach bound of O(mn) total update time, for unweighted and undirected graphs. Our algorithm is (1 + є) approximate and achieves a total update time of O(n2). Our algorithm can also achieve the same bounds in the incremental setting. It is worth mentioning that for dense instances where m = Ω(n2 − 1/√log(n)), our algorithm is also faster than all existing randomized algorithms.

Deterministic decremental single source shortest paths: beyond the o(mn) bound

Spanner of an undirected graph G = (V,E) is a subgraph that is sparse and yet preserves all-pairs distances approximately. More formally, a spanner with stretcht ∈ N is a subgraph (V,ES), ES ⊆ E such that the distance between any two vertices in the subgraph is at most t times their distance in G. Though G is trivially a t-spanner of itself, the research as well as applications of spanners invariably deal with a t-spanner that has as small number of edges as possible.We present fully dynamic algorithms for maintaining spanners in centralized as well as synchronized distributed environments. These algorithms are designed for undirected unweighted graphs and use randomization in a crucial manner.Our algorithms significantly improve the existing fully dynamic algorithms for graph spanners. The expected size (number of edges) of a t-spanner maintained at each stage by our algorithms matches, up to a polylogarithmic factor, the worst case optimal size of a t-spanner. The expected amortized time (or messages communicated in distributed environment) to process a single insertion/deletion of an edge by our algorithms is close to optimal.

/pdf/fully-dynamic-randomized-algorithms-for-graph-spanners-1offvml987.pdf

Fully dynamic randomized algorithms for graph spanners

https://cs.uwaterloo.ca/~astorjoh/xhermite.pdf

Triangular x-basis decompositions and derandomization of linear algebra algorithms over K[x]

This paper gives gives a deterministic algorithm to transform a row reduced matrix to canonical Popov form. Given as input a row reduced matrix R over K[x], K a field, our algorithm computes the Popov form in about the same time as required to multiply together over K[x] two matrices of the same dimension and degree as R. We also show that the problem of transforming a row reduced matrix to Popov form is at least as hard as polynomial matrix multiplication.

/pdf/normalization-of-row-reduced-matrices-m01xikbop9.pdf

Normalization of row reduced matrices

This paper presents a Genetic algorithm (GA) based solution to co-optimize test scheduling and wrapper design under power constraints for core based System-On-Chips (SOCs). Core testing solutions are generated as a set of wrapper configurations, represented as rectangles with width equal to the number of TAM (Test Access Mechanism) channels and height equal to the corresponding testing time. A locally optimal best-fit heuristic based bin packing algorithm has been used to determine placement of rectangles minimizing the overall test times, whereas, GA has been utilized to generate the sequence of rectangles to be considered for placement. Experimental result on ITC’02 benchmark SOCs shows that the proposed method provides better test time results compared to the recent works reported in the literature.

A genetic algorithm based heuristic technique for power constrained test scheduling in core-based SOCs

Spanner of an undirected graph G = (V, E) is a sub graph which is sparse and yet preserves all-pairs distances approximately. More precisely, a spanner with stretch t ∈ IN is a subgraph (V, ES), ES ⊆ E such that the distance between any two vertices in the subgraph is at most t times their distance in G. We present two fully dynamic algorithms for maintaining a sparse t-spanner of an unweighted graph. Our first algorithm achieves expected O(7 t/4) time per update independent of the size of the graph. This algorithm is particularly of interest for maintaining small stretch spanners. Our second algorithm achieves expected O(polylog |V|) time per update irrespective of the stretch.

Soumojit Sarkar

Papers

Fully dynamic randomized algorithms for graph spanners

Triangular x-basis decompositions and derandomization of linear algebra algorithms over K[x]

Normalization of row reduced matrices

A genetic algorithm based heuristic technique for power constrained test scheduling in core-based SOCs

Fully dynamic algorithm for graph spanners with poly-logarithmic update time