arXiv subjects

Debajyoti Mondal

Publications and source records attributed to Debajyoti Mondal.

At least 37 records · Page 2Linked to original sources

arXiv2022

StreamTable: An Area Proportional Visualization for Tables with Flowing Streams

Let $M$ be a two-dimensional table with each cell weighted by a nonzero positive number. A StreamTable visualization of $M$ represents the columns as non-overlapping vertical streams and the rows as horizontal stripes such that the intersection between a stream and a stripe is a rectangle with area equal to the weight of the corresponding cell. To avoid large wiggle of the streams, it is desirable to keep the consecutive cells in a stream to be adjacent. Let $B$ be the smallest axis-aligned bounding box containing the StreamTable. Then the difference between the area of $B$ and the sum of the weights is referred to as the excess area. We attempt to optimize various StreamTable aesthetics (e.g., minimizing excess area, or maximizing cell adjacencies in streams). (A) If the row permutation is fixed and the row heights are given, then we give an $O(rc)$-time algorithm to optimize these aesthetics, where $r$ and $c$ are the number of rows and columns, respectively. (B) If the row permutation is fixed but the row heights can be chosen, then we discuss a technique to compute an aesthetic (but not necessarily optimal) StreamTable by solving a quadratically-constrained quadratic program, followed by iterative improvements. If the row heights are restricted to be integers, then we prove the problem to be NP-hard. (C) If the row permutations can be chosen, then we show that it is NP-hard to find a row permutation that optimizes the area or adjacency aesthetics.

cs.CG↗

arXiv2022

Oriented Diameter of Planar Triangulations

The diameter of an undirected or a directed graph is defined to be the maximum shortest path distance over all pairs of vertices in the graph. Given an undirected graph $G$, we examine the problem of assigning directions to each edge of $G$ such that the diameter of the resulting oriented graph is minimized. The minimum diameter over all strongly connected orientations is called the oriented diameter of $G$. The problem of determining the oriented diameter of a graph is known to be NP-hard, but the time-complexity question is open for planar graphs. In this paper we compute the exact value of the oriented diameter for triangular grid graphs. We then prove an $n/3$ lower bound and an $n/2+O(\sqrt{n})$ upper bound on the oriented diameter of planar triangulations. It is known that given a planar graph $G$ with bounded treewidth and a fixed positive integer $k$, one can determine in linear time whether the oriented diameter of $G$ is at most $k$. In contrast, we consider a weighted version of the oriented diameter problem and show it to be is weakly NP-complete for planar graphs with bounded pathwidth.

cs.DS↗

arXiv2022

Leveraging Structural Properties of Source Code Graphs for Just-In-Time Bug Prediction

The most common use of data visualization is to minimize the complexity for proper understanding. A graph is one of the most commonly used representations for understanding relational data. It produces a simplified representation of data that is challenging to comprehend if kept in a textual format. In this study, we propose a methodology to utilize the relational properties of source code in the form of a graph to identify Just-in-Time (JIT) bug prediction in software systems during different revisions of software evolution and maintenance. We presented a method to convert the source codes of commit patches to equivalent graph representations and named it Source Code Graph (SCG). To understand and compare multiple source code graphs, we extracted several structural properties of these graphs, such as the density, number of cycles, nodes, edges, etc. We then utilized the attribute values of those SCGs to visualize and detect buggy software commits. We process more than 246K software commits from 12 subject systems in this investigation. Our investigation on these 12 open-source software projects written in C++ and Java programming languages shows that if we combine the features from SCG with conventional features used in similar studies, we will get the increased performance of Machine Learning (ML) based buggy commit detection models. We also find the increase of F1~Scores in predicting buggy and non-buggy commits statistically significant using the Wilcoxon Signed Rank Test. Since SCG-based feature values represent the style or structural properties of source code updates or changes in the software system, it suggests the importance of careful maintenance of source code style or structure for keeping a software system bug-free.

cs.SE↗

arXiv2021

On the Evolution of Neuron Communities in a Deep Learning Architecture

Deep learning techniques are increasingly being adopted for classification tasks over the past decade, yet explaining how deep learning architectures can achieve state-of-the-art performance is still an elusive goal. While all the training information is embedded deeply in a trained model, we still do not understand much about its performance by only analyzing the model. This paper examines the neuron activation patterns of deep learning-based classification models and explores whether the models' performances can be explained through neurons' activation behavior. We propose two approaches: one that models neurons' activation behavior as a graph and examines whether the neurons form meaningful communities, and the other examines the predictability of neurons' behavior using entropy. Our comprehensive experimental study reveals that both the community quality and entropy can provide new insights into the deep learning models' performances, thus paves a novel way of explaining deep learning models directly from the neurons' activation pattern.

cs.LG↗

arXiv2021

Bottleneck Convex Subsets: Finding $k$ Large Convex Sets in a Point Set

Chvátal and Klincsek (1980) gave an $O(n^3)$-time algorithm for the problem of finding a maximum-cardinality convex subset of an arbitrary given set $P$ of $n$ points in the plane. This paper examines a generalization of the problem, the Bottleneck Convex Subsets problem: given a set $P$ of $n$ points in the plane and a positive integer $k$, select $k$ pairwise disjoint convex subsets of $P$ such that the cardinality of the smallest subset is maximized. Equivalently, a solution maximizes the cardinality of $k$ mutually disjoint convex subsets of $P$ of equal cardinality. We show the problem is NP-hard when $k$ is an arbitrary input parameter, we give an algorithm that solves the problem exactly, with running time polynomial in $n$ when $k$ is fixed, and we give a fixed-parameter tractable algorithm parameterized in terms of the number of points strictly interior to the convex hull.

cs.CG↗

arXiv2021

Positive Planar Satisfiability Problems under 3-Connectivity Constraints

A 3-SAT problem is called positive and planar if all the literals are positive and the clause-variable incidence graph (i.e., SAT graph) is planar. The NAE 3-SAT and 1-in-3-SAT are two variants of 3-SAT that remain NP-complete even when they are positive. The positive 1-in-3-SAT problem remains NP-complete under planarity constraint, but planar NAE 3-SAT is solvable in $O(n^{1.5}\log n)$ time. In this paper we prove that a positive planar NAE 3-SAT is always satisfiable when the underlying SAT graph is 3-connected, and a satisfiable assignment can be obtained in linear time. We also show that without 3-connectivity constraint, existence of a linear-time algorithm for positive planar NAE 3-SAT problem is unlikely as it would imply a linear-time algorithm for finding a spanning 2-matching in a planar subcubic graph. We then prove that positive planar 1-in-3-SAT remains NP-complete under the 3-connectivity constraint, even when each variable appears in at most 4 clauses. However, we show that the 3-connected planar 1-in-3-SAT is always satisfiable when each variable appears in an even number of clauses.

cs.CC↗

arXiv2021

Computing Maximum Independent Set on Outerstring Graphs and Their Relatives

A graph $G$ with $n$ vertices is called an outerstring graph if it has an intersection representation of a set of $n$ curves inside a disk such that one endpoint of every curve is attached to the boundary of the disk. Given an outerstring graph representation, the Maximum Independent Set (MIS) problem of the underlying graph can be computed in $O(s^3)$ time, where $s$ is the number of segments in the representation (Keil et al., Comput. Geom., 60:19--25, 2017). If the strings are of constant size (e.g., line segments, L-shapes, etc.), then the algorithm takes $O(n^3)$ time. In this paper, we examine the fine-grained complexity of the MIS problem on some well-known outerstring representations. We show that solving the MIS problem on grounded segment and grounded square-L representations is at least as hard as solving MIS on circle graph representations. Note that no $O(n^{2-δ})$-time algorithm, $δ>0$, is known for the MIS problem on circle graphs. For the grounded string representations where the strings are $y$-monotone simple polygonal paths of constant length with segments at integral coordinates, we solve MIS in $O(n^2)$ time and show this to be the best possible under the strong exponential time hypothesis (SETH). For the intersection graph of $n$ L-shapes in the plane, we give a $(4\cdot \log OPT)$-approximation algorithm for MIS (where $OPT$ denotes the size of an optimal solution), improving the previously best-known $(4\cdot \log n)$-approximation algorithm of Biedl and Derka (WADS 2017).

cs.CG↗

arXiv2021

BigGraphVis: Leveraging Streaming Algorithms and GPU Acceleration for Visualizing Big Graphs

Graph layouts are key to exploring massive graphs. An enormous number of nodes and edges do not allow network analysis software to produce meaningful visualization of the pervasive networks. Long computation time, memory and display limitations encircle the software's ability to explore massive graphs. This paper introduces BigGraphVis, a new parallel graph visualization method that uses GPU parallel processing and community detection algorithm to visualize graph communities. We combine parallelized streaming community detection algorithm and probabilistic data structure to leverage parallel processing of Graphics Processing Unit (GPU). To the best of our knowledge, this is the first attempt to combine the power of streaming algorithms coupled with GPU computing to tackle big graph visualization challenges. Our method extracts community information in a few passes on the edge list, and renders the community structures using the ForceAtlas2 algorithm. Our experiment with massive real-life graphs indicates that about 70 to 95 percent speedup can be achieved by visualizing graph communities, and the visualization appears to be meaningful and reliable. The biggest graph that we examined contains above 3 million nodes and 34 million edges, and the layout computation took about five minutes. We also observed that the BigGraphVis coloring strategy can be successfully applied to produce a more informative ForceAtlas2 layout.

cs.DC↗

arXiv2021

Finding a Maximum Clique in a Grounded 1-Bend String Graph

A grounded 1-bend string graph is an intersection graph of a set of polygonal lines, each with one bend, such that the lines lie above a common horizontal line $\ell$ and have exactly one endpoint on $\ell$. We show that the problem of finding a maximum clique in a grounded 1-bend string graph is APX-hard, even for strictly $y$-monotone strings. For general 1-bend strings, the problem remains APX-hard even if we restrict the position of the bends and end-points to lie on at most three parallel horizontal lines. We give fast algorithms to compute a maximum clique for different subclasses of grounded segment graphs, which are formed by restricting the strings to various forms of $L$-shapes.

cs.CG↗

arXiv2021

APX-Hardness and Approximation for the k-Burning Number Problem

Consider an information diffusion process on a graph $G$ that starts with $k>0$ burnt vertices, and at each subsequent step, burns the neighbors of the currently burnt vertices, as well as $k$ other unburnt vertices. The \emph{$k$-burning number} of $G$ is the minimum number of steps $b_k(G)$ such that all the vertices can be burned within $b_k(G)$ steps. Note that the last step may have smaller than $k$ unburnt vertices available, where all of them are burned. The $1$-burning number coincides with the well-known burning number problem, which was proposed to model the spread of social contagion. The generalization to $k$-burning number allows us to examine different worst-case contagion scenarios by varying the spread factor $k$. In this paper we prove that computing $k$-burning number is APX-hard, for any fixed constant $k$. We then give an $O((n+m)\log n)$-time 3-approximation algorithm for computing $k$-burning number, for any $k\ge 1$, where $n$ and $m$ are the number of vertices and edges, respectively. Finally, we show that even if the burning sources are given as an input, computing a burning sequence itself is an NP-hard problem.

cs.CC↗

arXiv2021

Simultaneous Embedding of Colored Graphs

A set of colored graphs are compatible, if for every color $i$, the number of vertices of color $i$ is the same in every graph. A simultaneous embedding of $k$ compatibly colored graphs, each with $n$ vertices, consists of $k$ planar polyline drawings of these graphs such that the vertices of the same color are mapped to a common set of vertex locations. We prove that simultaneous embedding of $k\in o(\log \log n)$ colored planar graphs, each with $n$ vertices, can always be computed with a sublinear number of bends per edge. Specifically, we show an $O(\min\{c, n^{1-1/γ}\})$ upper bound on the number of bends per edge, where $γ= 2^{\lceil k/2 \rceil}$ and $c$ is the total number of colors. Our bound, which results from a better analysis of a previously known algorithm [Durocher and Mondal, SIAM J. Discrete Math., 32(4), 2018], improves the bound for $k$, as well as the bend complexity by a factor of $\sqrt{2}^{k}$. The algorithm can be generalized to obtain small universal point sets for colored graphs. We prove that $n\lceil c/b \rceil$ vertex locations, where $b\ge 1$, suffice to embed any set of compatibly colored $n$-vertex planar graphs with bend complexity $O(b)$, where $c$ is the number of colors.

cs.CG↗

arXiv2020

Compatible Paths on Labelled Point Sets

Let $P$ and $Q$ be finite point sets of the same cardinality in $\mathbb{R}^2$, each labelled from $1$ to $n$. Two noncrossing geometric graphs $G_P$ and $G_Q$ spanning $P$ and $Q$, respectively, are called compatible if for every face $f$ in $G_P$, there exists a corresponding face in $G_Q$ with the same clockwise ordering of the vertices on its boundary as in $f$. In particular, $G_P$ and $G_Q$ must be straight-line embeddings of the same connected $n$-vertex graph. Deciding whether two labelled point sets admit compatible geometric paths is known to be NP-complete. We give polynomial-time algorithms to find compatible paths or report that none exist in three scenarios: $O(n)$ time for points in convex position; $O(n^2)$ time for two simple polygons, where the paths are restricted to remain inside the closed polygons; and $O(n^2 \log n)$ time for points in general position if the paths are restricted to be monotone.

cs.CG↗

arXiv2020

(Faster) Multi-Sided Boundary Labelling

A 1-bend boundary labelling problem consists of an axis-aligned rectangle $B$, $n$ points (called sites) in the interior, and $n$ points (called ports) on the labels along the boundary of $B$. The goal is to find a set of $n$ axis-aligned curves (called leaders), each having at most one bend and connecting one site to one port, such that the leaders are pairwise disjoint. A 1-bend boundary labelling problem is $k$-sided ($1\leq k\leq 4$) if the ports appear on $k$ different sides of $B$. Kindermann et al. ["Multi-Sided Boundary Labeling", Algorithmica, 76(1): 225-258, 2016] showed that the 1-bend three-sided and four-sided boundary labelling problems can be solved in $O(n^4)$ and $O(n^9)$ time, respectively. Bose et al. [SWAT, 12:1-12:14, 2018] improved the latter running time to $O(n^6)$ by reducing the problem to computing maximum independent set in an outerstring graph. In this paper, we improve both previous results by giving new algorithms with running times $O(n^3\log n)$ and $O(n^5)$ to solve the 1-bend three-sided and four-sided boundary labelling problems, respectively.

cs.CG↗

arXiv2020

Parameterized Complexity of Two-Interval Pattern Problem

A \emph{2-interval} is the union of two disjoint intervals on the real line. Two 2-intervals $D_1$ and $D_2$ are \emph{disjoint} if their intersection is empty (i.e., no interval of $D_1$ intersects any interval of $D_2$). There can be three different relations between two disjoint 2-intervals; namely, preceding ($<$), nested ($\sqsubset$) and crossing ($\between$). Two 2-intervals $D_1$ and $D_2$ are called \emph{$R$-comparable} for some $R\in\{<,\sqsubset,\between\}$, if either $D_1RD_2$ or $D_2RD_1$. A set $\mathcal{D}$ of disjoint 2-intervals is $\mathcal{R}$-comparable, for some $\mathcal{R}\subseteq\{<,\sqsubset,\between\}$ and $\mathcal{R}\neq\emptyset$, if every pair of 2-intervals in $\mathcal{R}$ are $R$-comparable for some $R\in\mathcal{R}$. Given a set of 2-intervals and some $\mathcal{R}\subseteq\{<,\sqsubset,\between\}$, the objective of the \emph{2-interval pattern problem} is to find a largest subset of 2-intervals that is $\mathcal{R}$-comparable. The 2-interval pattern problem is known to be $W[1]$-hard when $|\mathcal{R}|=3$ and $NP$-hard when $|\mathcal{R}|=2$ (except for $\mathcal{R}=\{<,\sqsubset\}$, which is solvable in quadratic time). In this paper, we fully settle the parameterized complexity of the problem by showing it to be $W[1]$-hard for both $\mathcal{R}=\{\sqsubset,\between\}$ and $\mathcal{R}=\{<,\between\}$ (when parameterized by the size of an optimal solution); this answers an open question posed by Vialette [Encyclopedia of Algorithms, 2008].

cs.CG↗

arXiv2019

Drawing HV-Restricted Planar Graphs

A strict orthogonal drawing of a graph $G=(V, E)$ in $\mathbb{R}^2$ is a drawing of $G$ such that each vertex is mapped to a distinct point and each edge is mapped to a horizontal or vertical line segment. A graph $G$ is $HV$-restricted if each of its edges is assigned a horizontal or vertical orientation. A strict orthogonal drawing of an $HV$-restricted graph $G$ is good if it is planar and respects the edge orientations of $G$. In this paper, we give a polynomial-time algorithm to check whether a given $HV$-restricted plane graph (i.e., a planar graph with a fixed combinatorial embedding) admits a good orthogonal drawing preserving the input embedding, which settles an open question posed by Maňuch et al. (Graph Drawing 2010). We then examine $HV$-restricted planar graphs (i.e., when the embedding is not fixed), and give a complete characterization of the $HV$-restricted biconnected outerplanar graphs that admit good orthogonal drawings.

cs.CG↗

arXiv2018

Polygon Simplification by Minimizing Convex Corners

Let $P$ be a polygon with $r>0$ reflex vertices and possibly with holes and islands. A subsuming polygon of $P$ is a polygon $P'$ such that $P \subseteq P'$, each connected component $R$ of $P$ is a subset of a distinct connected component $R'$ of $P'$, and the reflex corners of $R$ coincide with those of $R'$. A subsuming chain of $P'$ is a minimal path on the boundary of $P'$ whose two end edges coincide with two edges of $P$. Aichholzer et al. proved that every polygon $P$ has a subsuming polygon with $O(r)$ vertices, and posed an open problem to determine the computational complexity of computing subsuming polygons with the minimum number of convex vertices. We prove that the problem of computing an optimal subsuming polygon is NP-complete, but the complexity remains open for simple polygons (i.e., polygons without holes). Our NP-hardness result holds even when the subsuming chains are restricted to have constant length and lie on the arrangement of lines determined by the edges of the input polygon. We show that this restriction makes the problem polynomial-time solvable for simple polygons.

cs.CG↗

arXiv2018

The Complexity of Drawing a Graph in a Polygonal Region

We prove that the following problem is complete for the existential theory of the reals: Given a planar graph and a polygonal region, with some vertices of the graph assigned to points on the boundary of the region, place the remaining vertices to create a planar straight-line drawing of the graph inside the region. This strengthens an NP-hardness result by Patrignani on extending partial planar graph drawings. Our result is one of the first showing that a problem of drawing planar graphs with straight-line edges is hard for the existential theory of the reals. The complexity of the problem is open in the case of a simply connected region. We also show that, even for integer input coordinates, it is possible that drawing a graph in a polygonal region requires some vertices to be placed at irrational coordinates. By contrast, the coordinates are known to be bounded in the special case of a convex region, or for drawing a path in any polygonal region.

cs.CC↗

arXiv2018

Recognition and Drawing of Stick Graphs

A \emph{Stick graph} is an intersection graph of axis-aligned segments such that the left end-points of the horizontal segments and the bottom end-points of the vertical segments lie on a `ground line,' a line with slope $-1$. It is an open question to decide in polynomial time whether a given bipartite graph $G$ with bipartition $A\cup B$ has a Stick representation where the vertices in $A$ and $B$ correspond to horizontal and vertical segments, respectively. We prove that $G$ has a Stick representation if and only if there are orderings of $A$ and $B$ such that $G$'s bipartite adjacency matrix with rows $A$ and columns $B$ excludes three small `forbidden' submatrices. This is similar to characterizations for other classes of bipartite intersection graphs. We present an algorithm to test whether given orderings of $A$ and $B$ permit a Stick representation respecting those orderings, and to find such a representation if it exists. The algorithm runs in time linear in the size of the adjacency matrix. For the case when only the ordering of $A$ is given, we present an $O(|A|^3|B|^3)$-time algorithm. When neither ordering is given, we present some partial results about graphs that are, or are not, Stick representable.

cs.CG↗