arXiv subjects

Arya Tanmay Gupta

Publications and source records attributed to Arya Tanmay Gupta.

13 recordsLinked to original sources

arXiv2025

Convergence Sans Synchronization

We currently see a steady rise in the usage and size of multiprocessor systems, and so the community is evermore interested in developing fast parallel processing algorithms. However, most algorithms require a synchronization mechanism, which is costly in terms of computational resources and time. If an algorithm can be executed in asynchrony, then it can use all the available computation power, and the nodes can execute without being scheduled or locked. However, to show that an algorithm guarantees convergence in asynchrony, we need to generate the entire global state transition graph and check for the absence of cycles. This takes time exponential in the size of the global state space. In this dissertation, we present a theory that explains the necessary and sufficient properties of a multiprocessor algorithm that guarantees convergence even without synchronization. We develop algorithms for various problems that do not require synchronization. Additionally, we show for several existing algorithms that they can be executed without any synchronization mechanism. A significant theoretical benefit of our work is in proving that an algorithm can converge even in asynchrony. Our theory implies that we can make such conclusions about an algorithm, by only showing that the local state transition graph of a computing node forms a partial order, rather than generating the entire global state space and determining the absence of cycles in it. Thus, the complexity of rendering such proofs, formal or social, is phenomenally reduced. Experiments show a significant reduction in time taken to converge, when we compare the execution time of algorithms in the literature versus the algorithms that we design. We get similar results when we run an algorithm, that guarantees convergence in asynchrony, under a scheduler versus in asynchrony.

cs.DC↗

arXiv2024

Fully Lattice-Linear Algorithms

Lattice-linearity was introduced as a way to model problems using predicates that induce a lattice among the global states (Garg, SPAA 2020). A key property of \textit{the predicate} representing such problems is that it induces \textit{one} lattice in the state space. An algorithm that emerges from such a predicate guarantees the execution to be correct even if nodes execute asynchronously. However, many interesting problems do not exhibit lattice-linearity. This issue was somewhat alleviated with the introduction of eventually lattice-linear algorithms (Gupta and Kulkarni, SSS 2021). They induce \textit{single} or \textit{multiple} lattices in \textit{a subset of the state space} even when the problem cannot be defined by a predicate under which the global states form a lattice. This paper focuses on analyzing and differentiating between lattice-linear problems and algorithms. We introduce \textit{fully lattice-linear algorithms}. These algorithms partition the \textit{entire} reachable state space into \textit{one or more lattices}, and as a result, ensure that the execution remains correct even if nodes execute asynchronously. For demonstration, we present lattice-linear self-stabilizing algorithms for minimal dominating set (MDS), graph colouring (GC), minimal vertex cover (MVC) and maximal independent set (MIS) problems. The algorithms for MDS, MVC and MIS converge in $n$ moves and the algorithm for GC converges in $n+2m$ moves. These algorithms preserve this time complexity while allowing the nodes to execute asynchronously. They present an improvement to the existing algorithms present in the literature. Our work also demonstrates that to allow asynchrony, a more relaxed data structure can be allowed (called $\prec$-lattice in this paper, where the meet of a pair of global states may not be defined), rather than a distributive lattice as assumed by Garg.

cs.DC↗

arXiv2024

Tolerance to Asynchrony in Algorithms for Multiplication and Modulo

In this article, we study some parallel processing algorithms for multiplication and modulo operations. We demonstrate that the state transitions that are formed under these algorithms satisfy lattice-linearity, where these algorithms induce a lattice among the global states. Lattice-linearity implies that these algorithms can be implemented in asynchronous environments, where the nodes are allowed to read old information from each other. It means that these algorithms are guaranteed to converge correctly without any synchronization overhead. These algorithms also exhibit snap-stabilizing properties, i.e., starting from an arbitrary state, the sequence of state transitions made by the system strictly follows its specification.

cs.DC↗

arXiv2024

DAG-Inducing Problems and Algorithms

Consider the execution of a sequential algorithm that requires the program to converge to an optimal state, and then terminate/stutter. To design such an algorithm, we need to ensure that the state space that it traverses forms a directed acyclic graph (DAG) and its sink nodes are optimal states. However, if we run the same algorithm on multiple computing nodes running in parallel, and without synchronization, it may not reach an optimal state. In most parallel processing algorithms designed in the literature, a synchronization primitive is assumed. Synchronization ensures that the nodes read fresh value, and the execution proceeds systematically, such that the subject algorithm traverses a DAG induced among the global states. With this observation, we investigate the conditions that guarantee that the execution of an algorithm is correct even if it is executed in parallel and without synchronization. To this end, we introduce DAG-inducing problems and DAG-inducing algorithms. We show that induction of a $\prec$-DAG (induced among the global states -- that forms as a result of a partial order induced among the local states visited by individual nodes) is a necessary and sufficient condition to allow an algorithm to run in asynchrony. In the paper, we first give a comprehensive description of DAG-inducing problems and DAG-inducing algorithms, along with some simple examples. Then we show some properties of an algorithm that is tolerant to asynchrony, which include the above-mentioned condition.

cs.DS↗

arXiv2024

Eventually Lattice-Linear Algorithms

Lattice-linear systems allow nodes to execute asynchronously. We introduce eventually lattice-linear algorithms, where lattices are induced only among the states in a subset of the state space. The algorithm guarantees that the system transitions to a state in one of the lattices. Then, the algorithm behaves lattice linearly while traversing to an optimal state through that lattice. We present a lattice-linear self-stabilizing algorithm for service demand based minimal dominating set (SDMDS) problem. Using this as an example, we elaborate the working of, and define, eventually lattice-linear algorithms. Then, we present eventually lattice-linear self-stabilizing algorithms for minimal vertex cover (MVC), maximal independent set (MIS), graph colouring (GC) and 2-dominating set problems (2DS). Algorithms for SDMDS, MVCc and MIS converge in 1 round plus $n$ moves (within $2n$ moves), GC in $n+4m$ moves, and 2DS in 1 round plus $2n$ moves (within $3n$ moves). These results are an improvement over the existing literature. We also present experimental results to show performance gain demonstrating the benefit of lattice-linearity.

cs.DC↗

arXiv2024

Tolerance to Asynchrony of an Algorithm for Gathering Myopic Robots on an Infinite Triangular Grid

In this paper, we study the problem of gathering distance-1 myopic robots on an infinite triangular grid. We show that the algorithm developed by Goswami et al. (SSS, 2022) is lattice-linear (cf. Gupta and Kulkarni, SRDS 2023). This implies that a distributed scheduler, assumed therein, is not required for this algorithm: it runs correctly in asynchrony. It also implies that the algorithm works correctly even if the robots are equipped with a unidirectional \textit{camera} to see the neighbouring robots (rather than an omnidirectional one, which would be required under a distributed scheduler). Due to lattice-linearity, we can predetermine the point of gathering. We also show that this algorithm converges in $2n$ rounds, which is lower than the complexity ($2.5(n+1)$ rounds) that was shown in Goswami et al.

cs.DC↗

arXiv2023

Spread and defend infection in graphs

The spread of an infection, a contagion, meme, emotion, message and various other spreadable objects have been discussed in several works. Burning and firefighting have been discussed in particular on static graphs. Graph burning simulates the notion of the spread of "fire" throughout a graph (plus, one unburned node burned at each time-step); graph firefighting simulates the defending of nodes by placing firefighters on the nodes which have not been already burned while the fire is being spread (started by only a single fire source). This article studies a combination of firefighting and burning on a graph class which is a variation (generalization) of temporal graphs. Nodes can be infected from "outside" a network. We present a notion of both upgrading (of unburned nodes, similar to firefighting) and repairing (of infected nodes). The nodes which are burned, firefighted, or repaired are chosen probabilistically. So a variable amount of nodes are allowed to be infected, upgraded and repaired in each time step. In the model presented in this article, both burning and firefighting proceed concurrently, we introduce such a system to enable the community to study the notion of spread of an infection and the notion of upgrade/repair against each other. The graph class that we study (on which, these processes are simulated) is a variation of temporal graph class in which at each time-step, probabilistically, a communication takes place (iff an edge exists in that time step). In addition, a node can be "worn out" and thus can be removed from the network, and a new healthy node can be added to the network as well. This class of graphs enables systems with high complexity to be able to be simulated and studied.

physics.soc-ph↗

arXiv2022

Fully Lattice Linear Algorithms

This paper focuses on analyzing and differentiating between lattice linear problems and algorithms. It introduces a new class of algorithms called \textit{(fully) lattice linear algorithms}. A property of these algorithms is that they induce a partial order among all states and form \textit{multiple lattices}. An initial state locks in one of these lattices. We present a lattice linear self-stabilizing algorithm for minimal dominating set.

cs.DC↗

arXiv2022

Technical Report: Using Static Analysis to Compute Benefit of Tolerating Consistency

Synchronization is the Achilles heel of concurrent programs. Synchronization requirement is often used to ensure that the execution of the concurrent program can be serialized. Without synchronization requirement, a program suffers from consistency violations. Recently, it was shown that if programs are designed to tolerate such consistency violation faults (\cvf{s}) then one can obtain substantial performance gain. Previous efforts to analyze the effect of \cvf-tolerance are limited to run-time analysis of the program to determine if tolerating \cvf{s} can improve the performance. Such run-time analysis is very expensive and provides limited insight. In this work, we consider the question, `Can static analysis of the program predict the benefit of \cvf-tolerance?' We find that the answer to this question is affirmative. Specifically, we use static analysis to evaluate the cost of a \cvf and demonstrate that it can be used to predict the benefit of \cvf-tolerance. We also find that when faced with a large state space, partial analysis of the state space (via sampling) also provides the required information to predict the benefit of \cvf-tolerance. Furthermore, we observe that the \cvf-cost distribution is exponential in nature, i.e., the probability that a \cvf has a cost of $c$ is $A.B^{-c}$, where $A$ and $B$ are constants, i.e., most \cvf{s} cause no/low perturbation whereas a small number of \cvf{s} cause a large perturbation. This opens up new aveneus to evaluate the benefit of \cvf-tolerance.

cs.DC↗

arXiv2021

Extending Lattice linearity for Self-Stabilizing Algorithms

In this article, we focus on extending the notion of lattice linearity to self-stabilizing programs. Lattice linearity allows a node to execute its actions with old information about the state of other nodes and still preserve correctness. It increases the concurrency of the program execution by eliminating the need for synchronization among its nodes. The extension -- denoted as eventually lattice linear algorithms -- is performed with an example of the service-demand based minimal dominating set (SDDS) problem, which is a generalization of the dominating set problem; it converges in $2n$ moves. Subsequently, we also show that the same approach could be used in various other problems including minimal vertex cover, maximal independent set and graph coloring.

cs.DC↗

arXiv2021

A secure home automation prototype built on raspberry-pi

With the development of sensors, wireless mobile communication, embedded system, the technologies of the Internet of Things have been widely used in SmartMeter, public security, intelligent building and so on. Because of its huge market prospects, the Internet of Things has been paid close attention by several governments all over the world. IoT facilitates the seamless integration of wireless sensor networks. In this paper, we present an IoT prototype that is built on Raspberry Pi and uses SMTP (simple mail transfer protocol) for communication. Through this device, we have proposed a communication system that is less complex and more secure. It integrates with any "thing" and makes it electronically communicable. We give an implementation of the prototyping system and system validation.

cs.RO↗

arXiv2020

NP-Completeness Results for Graph Burning on Geometric Graphs

Graph burning runs on discrete time steps. The aim is to burn all the vertices in a given graph in the least number of time steps. This number is known to be the burning number of the graph. The spread of social influence, an alarm, or a social contagion can be modeled using graph burning. The less the burning number, the faster the spread. Optimal burning of general graphs is NP-Hard. There is a 3-approximation algorithm to burn general graphs where as better approximation factors are there for many sub classes. Here we study burning of grids; provide a lower bound for burning arbitrary grids and a 2-approximation algorithm for burning square grids. On the other hand, burning path forests, spider graphs, and trees with maximum degree three is already known to be NP-Complete. In this article we show burning problem to be NP-Complete on connected interval graphs, permutation graphs and several other geometric graph classes as corollaries.

cs.DS↗

arXiv2020

Burning Geometric Graphs

A procedure called \textit{graph burning} was introduced to facilitate the modelling of spread of an alarm, a social contagion, or a social influence or emotion on graphs and networks. Graph burning runs on discrete time-steps (or rounds). At each step $t$, first (a) an unburned vertex is burned (as a \textit{fire source}) from "outside", and then (b) the fire spreads to vertices adjacent to the vertices which are burned till step $t-1$. This process stops after all the vertices of $G$ have been burned. The aim is to burn all the vertices in a given graph in minimum time-steps. The least number of time-steps required to burn a graph is called its \textit{burning number}. The less the burning number is, the faster a graph can be burned. Burning a general graph optimally is an NP-Complete problem. It has been proved that optimal burning of path forests, spider graphs, and trees with maximum degree three is NP-Complete. We study the \textit{graph burning problem} on several sub-classes of \textit{geometric graphs}. We show that burning interval graphs (Section 7.1, Theorem 7.1), permutation graphs (Section 7.2, Theorem 7.2) and disk graphs (Section 7.3, Theorem 7.3) optimally is NP-Complete. In addition, we opine that optimal burning of general graphs (Section 9.2, Conjecture 9.1) cannot be approximated better than 3-approximation factor.

cs.DM↗