DAG-Inducing Problems and Algorithms

TL;DR

This paper introduces DAG-inducing problems and algorithms, providing conditions under which asynchronous parallel algorithms can guarantee convergence to optimal states without synchronization.

Contribution

It formalizes DAG-inducing problems and proves that inducing a AG among global states is necessary and sufficient for asynchronous correctness.

Findings

Induction of a AG is necessary and sufficient for asynchronous execution.

Provides properties of algorithms tolerant to asynchrony.

Describes conditions for correct parallel execution without synchronization.

Abstract

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.

Full text

We demonstrate that the dominant clique (DC) problem and shortest path (SP) problem are DAG-inducing problems. Among these, DC allows self-stabilization, whereas the algorithm that we present for SP does not. We demonstrate that maximal matching (MM) is not a DAG-inducing problem. However, a DAG-inducing algorithm can be developed for it. The algorithm for MM allows self-stabilization. This algorithm converges in $2n$ moves and does not require a synchronous environment, which is an improvement over the existing algorithms in the literature. The algorithm for DC converges in $2m$ moves, and the algorithm for SP converges in $\mathcal{D}$ rounds. ($n$ is the number of nodes and $m$ is the number of edges in the input graph, and $\mathcal{D}$ is its diameter.) We also note that DAG-inducing problems are more general than, and encapsulate, lattice linear problems (Garg, SPAA 2020). Similarly, DAG-inducing algorithms encapsulate lattice linear algorithms (Gupta and Kulkarni, SSS 2022).

We also show that a partial order induced among the local states visited by a node, as discussed above, is a necessary and sufficient condition to allow asynchrony.

Keywords: DAG-inducing problems, DAG-inducing algorithms, asynchrony, dominant clique, shortest path, maximal matching

1 Introduction

A multiprocessor system consists of multiple processes that solve a problem. In such systems, processes need to coordinate with each other. This could be achieved via shared memory (where the data is stored centrally and processes have direct access to all data) or message passing (where processes share their information via messages). In such systems, as the level of parallelization increases, the need for synchronization increases as well.

If an algorithm can run without synchronization and still lead to a correct answer, then it can highly benefit from the available concurrency permitting each node to execute at its own pace. While the embarrassingly parallel algorithms, in which there is no data dependency among the nodes, do fit this requirement, most problems require the nodes to share data. We study problems and algorithms where such asynchronous execution can be permitted. Towards this end, in this paper, we introduce DAG-inducing problems and DAG-inducing algorithms.

When an algorithm executes without synchronization, it is possible that some nodes use an old value of other nodes. Thus, if we allow asynchrony, then we have to ensure that the algorithm provides a correct answer even if a node executes based on old values of variables.

In this context, Garg [3] introduced modelling of problems such that the state space forms a lattice. These problems are called lattice linear problems. The key idea of lattice linearity is that a process/node determines that its local state is not feasible in any reachable optimal global state. In other words, it has to change its state to reach an optimal state. Thus, if node $i$ changes its state from $st.i$ to $st^{\prime}.i$ it never revisits state $st.i$ again. Consequently, the local states visited by a node form a total order. Hence, it can change its state even if it is relying on the old values of its neighbours. As a result, the nodes can run without synchronization and the system is guaranteed to reach an optimal state.

Gupta and Kulkarni [6] studied problems that contain multiple optimal states and require self-stabilization. The algorithms in [6] induce single or multiple disjoint lattices in a subset of the state space. The supremum of each lattice is an optimal state, and so these algorithms are self-stabilizing. Because of the kind of partial order induced among the global states, these algorithms are called eventually lattice linear algorithms. In addition, Gupta and Kulkarni [7] introduced fully lattice linear algorithms and provided with an algorithm for minimal dominating set. This algorithm is capable of inducing multiple disjoint lattices in the entire state space while guaranteeing that every supremum is an optimal state. Hence starting from an arbitrary state, the algorithm is guaranteed to traverse to an optimal state.

We note the class of DAG-inducing problems (resp., DAG-inducing algorithms) identified in this paper are a superset of lattice linear problems (resp., lattice linear algorithms).

1.1 Contributions of the paper

In this paper, we study the problems that can be represented by a predicate which induces a DAG among the states, and the problems in which a DAG can be induced algorithmically. Inducing a DAG is extremely valuable as it allows the nodes to run asynchronously. Furthermore, inducing a DAG is more general than inducing lattices (as considered in [3, 7]). Our specific contributions are listed as follows.

• •

We introduce the classes of DAG-inducing problems and DAG-inducing algorithms.

• •

We show that the dominant clique (DC) problem and the shortest path (SP) problem are DAG-inducing problems. Among these, DC allows self-stabilization, whereas the algorithm that we present for the SP does not.

• •

We demonstrate that maximal matching problem is not a DAG-inducing problem. We present a DAG-inducing algorithm for it. This algorithm allows self-stabilization.

• •

We study the upper bound to the convergence time of an algorithm traversing a DAG of states.

• •

Algorithms for the dominant clique and shortest path, converge in $2m$ moves and $\mathcal{D}$ rounds respectively. The algorithm for the maximal matching converges in $2n$ moves. Here, $n$ is the number of nodes and $m$ is the number of edges in the input graph, and $\mathcal{D}$ is its diameter.

• •

We show how inducing a $<$-DAG (described in Section 3) in the state space is crucial to allow asynchrony: the induction of a $<$-DAG is a necessary and sufficient condition to allow asynchrony.

The major focus and benefit of this paper is inducing a partial order among the local states of nodes to allow asynchronous executions. Some applications of the specific problems studied in this paper are listed as follows. Dominant clique is applied in (1) social networks, where a clique contains information of a set of mutually connected persons, and (2) ecology, where it is used to compute dominant cliques in interval graphs – most food webs, where there is an edge between species that feed on a common species, can be represented as interval graphs [1], on which cliques can be computed in polynomial time. Shortest path is applied in (1) source routing, and (2) maps, to obtain shortest routes. (Note that in these applications of shortest path, the distance is not sufficient – from a node, it is required to know which node to go to, to be able to traverse a shortest path). Matching is applied in (1) modelling bonds in chemistry, and (2) stable marriage/bipartite matching for job allocation.

1.2 Organization of the paper

We discuss the preliminaries in Section 2. In Section 3, we study the characteristics of DAG-inducing problems, and in Section 4, we study the characteristics of DAG-inducing algorithms for non-DAG-inducing problems, with examples. In Section 5, we study the properties of DAG-inducing algorithms. We discuss the related work in Section 6. Finally, we conclude in Section 7. Appendices are provided on page Appendix, followed by references on page References.

2 Preliminaries

We are mainly interested in graph algorithms where the input is a graph $G$, $V(G)$ is the set of its nodes, $E(G)$ is the set of its edges, $n=|V(G)|$, and $m=|E(G)|$. For a node $i\in V(G)$, $Adj_{i}$ is the set of nodes adjacent to $i$, and $Adj^{x}_{i}$ is the set of nodes within distance-$x$ from $i$, excluding $i$. $deg(i)=|Adj_{i}|$. $dis(i,j)$ is the length of shortest path from $i$ to node $j$. For a finite natural number $x$, $[1:x]$ denotes a sequence of all natural numbers from 1 to $x$.

Each node $i$ is associated with a set of variables. The algorithms are written in terms of rules, where each rule for every process $i$ is of the form $g\longrightarrow a_{c}$ where the guard $g$ is a proposition consisting of the variables of $i$ along with the variables of other nodes. If at least one of the guards $g$ hold true for $i$, we say that $i$ is enabled. We say that $i$ makes a move when $i$ is enabled and updates its variables by executing action $a_{c}$ corresponding to the guard $g$ that holds true. A round is a sequence of events in which every node evaluates its guards at least once, and makes a move accordingly.

We denote $S$ to be the set of all global states. A global state $s\in S$ is represented as a vector where $s[i]$ denotes the variables of node $i$, $s[i]$ itself is a vector of the variables of $i$. The state transition system $\mathcal{S}$ on the state space $S$ is a discrete structure that defines all the possible transitions that can take place among the states of $S$. Under a given algorithm, $\mathcal{S}$ is a directed graph such that $V(\mathcal{S})=S$, and $E(\mathcal{S})=\{\langle s,s^{\prime}\rangle|\langle s,s^{\prime}\rangle$ is a state transition$\}$.

A scheduler/daemon is a node whose function is to choose one, some, or all nodes in a time step, throughout the execution, so that the selected nodes can evaluate their guards and take the corresponding action. A central scheduler chooses one arbitrary node per time step. A distributed scheduler chooses one or more arbitrary nodes per time step. A synchronous scheduler chooses all the nodes in each time step.

An algorithm $A$ is self-stabilizing with respect to the subset $S_{o}$ of $S$ iff (1) convergence: starting from an arbitrary state, any sequence of computations of $A$ reaches a state in $S_{o}$, and (2) closure: any computation of $A$ starting from $S_{o}$ always stays in $S_{o}$. We assume $S_{o}$ to be the set of optimal states: the system is deemed converged once it reaches a state in $S_{o}$. $A$ is a silent self-stabilizing algorithm if no node becomes enabled once a state in $S_{o}$ is reached.

2.1 Execution without Synchronization

Typically, we view the computation of an algorithm as a sequence of global states $\langle s_{0},s_{1},\cdots\rangle$, where $s_{\ell+1},\ell\geq 0,$ is obtained by executing some action by one or more nodes (as decided by the scheduler) in $s_{\ell}$. For the sake of discussion, assume that only node $i$ executes in state $s_{\ell}$. The computation prefix uptil $s_{\ell}$ is $\langle s_{0},s_{1},\cdots,s_{\ell}\rangle$. The state that the system traverses to after $s_{\ell}$ is $s_{\ell+1}$. Under proper synchronization, $i$ would evaluate its guards on the current local states of its neighbours in $s_{\ell}$, resulting in the system reaching $s_{\ell+1}$.

To understand the execution works in asynchrony, let $x(s)$ be the value of some variable $x$ in state $s$. If $i$ executes in asynchrony, then it views the global state that it is in to be $s^{\prime}$, where $x(s^{\prime})\in\{x(s_{0}),x(s_{1}),\cdots,x(s_{\ell})\}.$ In this case, $s_{\ell+1}$ is evaluated as follows. If all guards in $i$ evaluate to false, then the system will continue to remain in state $s_{\ell}$, i.e., $s_{\ell+1}=s_{\ell}$. If a guard $g$ evaluates to true then $i$ will execute its corresponding action $a_{c}$. Here, we have the following observations: (1) $s_{\ell+1}[i]$ is the state that $i$ obtains after executing an action in $s^{\prime}$, and (2) $\forall j\neq i$, $s_{\ell+1}[j]=s_{\ell}[j]$.

In this paper, we are interested in two models: arbitrary asynchrony (AA) and asynchrony with monotonous read (AMR). In the AA model, a node can read old values of other nodes arbitrarily, requiring that if some information is sent from a node, it eventually reaches the target node. The model described in the above paragraph is AA model. Similar to AA, in AMR, the nodes execute without coordination with each other and can read the old values of other nodes. However, the AMR model adds another restriction; when node $i$ reads the state of node $j$, the reads are monotonic, i.e., if $i$ reads a newer value of the state of $j$ then it cannot read an older value of $j$ at a later time. For example, if the state of $j$ changes from [math] to $1$ to $2$ and node $i$ reads the state of $j$ to be $1$ then its subsequent read will either return $1$ or $2$, it cannot return [math]. In both these models, node $i$ reads the most recent state of itself.

3 Natural DAG induction: DAG-inducing Problems

In this section, we discuss properties of problems where a DAG can be induced naturally. The problems/algorithms considered in this paper rely on the requirement that execution of such node(s) is critical for reaching an optimal state. We first elaborate on, in the following, the discrete structure that, if induced among the global states, allows a program to run in asynchrony (under some additional constraints).

3.1 Embedding a $<$-DAG among global states

To explain the embedding of a $<$-DAG, first, we define a partial order $<_{l}$ among the local states of a node. This partial order defines all the possible transitions that a node is allowed to take. $<_{l}$ is used to restrict how node $i$ can execute: $i$ can go from state $s[i]$ to $s^{\prime}[i]$ only if $s[i]<_{l}s^{\prime}[i]$.

Using $<_{l}$, we define a partial order $<_{g}$ among global states as follows. We say that $s<_{g}s^{\prime}$ iff $(\forall i:s[i]=s^{\prime}[i]\lor s[i]<_{l}s^{\prime}[i])\land(\exists i:s[i]<_{l}s^{\prime}[i])$. $s=s^{\prime}$ iff $\forall i~{}s[i]=s^{\prime}[i]$. For brevity, we use $<$ to denote $<_{l}$ and $<_{g}$: $<$ corresponds to $<_{l}$ while comparing local states, and $<$ corresponds to $<_{g}$ while comparing global states. We also use the symbol ‘$>$’ which is such that $s>s^{\prime}$ iff $s^{\prime}<s$. Similarly, we use symbols ‘$\leq$’ and ‘$\geq$’; e.g., $s\leq s^{\prime}$ iff $s=s^{\prime}\vee s<s^{\prime}$. We call the DAG, formed from such partial order, a $<$-DAG.

Definition 1**.**

$<$-DAG. Given a partial order $<_{l}$ that orders the states visited by $i$ (for each $i$), the $<$-DAG corresponding to $<_{l}$ is defined by the following partial order: $s<s^{\prime}$ iff $(\forall i\ \ s[i]\leq_{l}s^{\prime}[i])\wedge(\exists i\ \ s[i]<_{l}s^{\prime}[i])$.

A $<$-DAG constraints how global states can transition among one another: state $s$ can transition to state $s^{\prime}$ iff $s<s^{\prime}$. By varying $<_{l}$ that identifies a partial order among the local states of a node, one can obtain different DAGs. A $<$-DAG, embedded in the state space, is useful for permitting the algorithm to execute asynchronously. Under proper constraints on the structure of $<$-DAG, convergence can be ensured. We elaborate on this in Section 3.2.

Remark: If local states were totally ordered, the global states would form a lattice. However, this is not true if local states are allowed to form a partial order. Hence, the resultant structure may not be a lattice.

3.2 General Properties of DAG-Inducing Problems

A DAG-inducing problem $P$ can be represented by a predicate $\mathcal{P}$ such that for any node $i$, if it is violating $\mathcal{P}$ in some state $s$, then it must change its state, otherwise the system will not satisfy $\mathcal{P}$. In addition, any local state $st.i$ that is deemed in violation by $i$ will always make any global state $s$ suboptimal if $s[i]=st.i$. So $i$ never revisits $st.i$. As a result, the local states that $i$ traverses through form a partial order.

DAG-inducing problems require that if $\mathcal{P}(s)$ is false then node $i$ does not visit $st.i$ along with some other states. To explain this, let $st_{init}.i$ be the initial state of node $i$. For a given state $st.i$ of node $i$, we define $\textsc{Same-Level}(st.i,i)$ to be the local states of $i$ that are at the same distance from $st_{init}.i$, as compared to $st.i$. The partial order among the local states of node $i$ is induced by the requiring that if the current state $st.i$ violates $\mathcal{P}$, then all the states in $\textsc{Same-Level}(st.i,i)$ also violate $\mathcal{P}$. This ensures that $i$ must move up in the partial order. A node violating $\mathcal{P}$ in $s$ is called an impedensable node (an impediment to progress if does not execute, indispensable to execute for progress).

Definition 2**.**

$\textsc{Impedensable}(i,s,\mathcal{P})\equiv\lnot\mathcal{P}(s)\land(\forall s^{\prime}>s:s^{\prime}[i]\in\textsc{Same-Level}(s[i],i)\Rightarrow\lnot\mathcal{P}(s^{\prime}))$.

If a node $i$ is impedensable in state $s$, then in any state $s^{\prime}$ such that $s^{\prime}>s$, if the state of $i$ remains the same, then the system does not converge. Thus, predicate $\mathcal{P}$ induces a partial order among the local states visited by a node, for all nodes. Consequently, the discrete structure that gets induced among the global states is a $<$-DAG, as described in Definition 1. We say that $\mathcal{P}$, satisfying Definition 2, is DAG-inducing with respect to that $<$-DAG.

Multiple DAGs can be induced among the global states. A system cannot guarantee convergence while traversing an arbitrary DAG. To guarantee convergence, we design the predicate $\mathcal{P}$ such that it fulfils some properties, and guarantees reachability to an optimal state. $\mathcal{P}$ is used by the nodes to determine if they are impedensable, using Definition 2. Thus, in any suboptimal global state, there will be at least one impedensable node.

Definition 3**.**

DAG-Inducing Predicate. $\mathcal{P}$ is a DAG-inducing predicate with respect to a $<$-DAG induced among the global states iff $\forall s\in S:\lnot\mathcal{P}(s)\Rightarrow\exists i:\textsc{Impedensable}(i,s,\mathcal{P})$.

Now we complete the definition of DAG-inducing problems. In a DAG-inducing problem $P$, given any suboptimal global state, we can identify all and the only nodes that cannot retain their state. In this paper, we observe that the algorithms that we study exploit this nature of the problems that they are developed for. $\mathcal{P}$ is thus designed conserving this nature of the subject problem $P$.

Definition 4**.**

DAG-inducing problem (DIP). A problem $P$ is DAG-inducing iff there exists a predicate $\mathcal{P}$ and a $<$-DAG such that

• •

$P$* is deemed solved iff the system reaches a state where $\mathcal{P}$ is true,*

• •

$\mathcal{P}$* is DAG-inducing with respect to the $<$-DAG induced in $S$, i.e., $\forall s:\neg\mathcal{P}(s)\Rightarrow\exists i:\textsc{Impedensable}(i,s,\mathcal{P})$,*

• •

$\forall s:(\forall i:\textsc{Impedensable}(i,s,\mathcal{P})\Rightarrow(\forall s^{\prime}:\mathcal{P}(s^{\prime})\Rightarrow s^{\prime}[i]\neq s[i]))$.

The algorithms developed for DAG-inducing problems, that follow the constraints of DAG-induction, fully tolerate asynchrony in AA model. This is because an impedensable node cannot retain its state in any optimal global state.

Definition 5**.**

Successors of a global state. A state $s^{\prime}$ is a successor of a state $s$ iff $s^{\prime}$ is reachable from $s$ in the induced DAG. Formally, $\textsc{Successors}(s)\equiv\{s^{\prime}:s^{\prime}>s\}$.

Definition 6**.**

$\textsc{Successor}(s,s^{\prime})\equiv s^{\prime}\in\textsc{Successors}(s)$.

Definition 7**.**

Terminal Successors. A state $s^{\prime}$ is a terminal successor of $s$ iff $s^{\prime}$ is the successor of $s$ and $s^{\prime}$ has no successor. Formally, $\textsc{Terminal-Successors}(s)$ $\equiv$ $\{s^{\prime}|$ $\textsc{Successor}(s$, $s^{\prime})\land$ $\textsc{Successors}(s^{\prime})$ $=$ $\phi\}$.

Definition 8**.**

$\textsc{Terminal-Successor}(s,s^{\prime})\equiv$* $s^{\prime}$ $\in\textsc{Terminal-Successors}(s)$.*

$\mathcal{P}$ satisfies Definition 9 only if starting from any arbitrary state, the system is able to converge to an optimal state. Notice that this, in turn, is possible only if all terminal successors in the DAG induced among the global states are guaranteed to be optimal states. Note that $\mathcal{P}$ can be true in other states as well.

Definition 9**.**

Self-stabilizing DAG-inducing predicate. Continuing from Definition 4, $\mathcal{P}$ is a self-stabilizing DAG-inducing predicate if and only if all terminal successors in the DAG induced by $\mathcal{P}$ are optimal states, i.e. $\forall s,s^{\prime}\in S:\textsc{Terminal-Successor}(s,s^{\prime})\Rightarrow\mathcal{P}(s^{\prime})=true$.

3.3 Dominant Clique (DC) problem

Definition 10**.**

Dominant clique. In the dominant clique problem, the input is an arbitrary graph $G$ such that for the variable $cliq.i$ of each node $i$, $cliq.i\subseteq Adj_{i}\cup\{i\}$ and $\{i\}\subseteq cliq.i$. The task is to compute maximal cliques such that for any node $i$, (1) all the nodes in $cliq.i$ form a clique, i.e. $\forall j,k\in cliq.i,j\neq k:k\in Adj_{j}$, and (2) there exists no clique $c$ in $G$ such that $cliq.i$ is a proper subset of $c$, i.e. $\not\exists j\in Adj_{i}:j\not\in cliq.i\land(\forall k\in cliq.i:k\in Adj_{j})$.

Thus, the DC problem can be defined by the following predicate.

$\mathcal{P}_{dc}\equiv(\forall j,k\in cliq.i,j\neq k:k\in Adj_{j})\land(\not\exists j\in Adj_{i}:j\not\in cliq.i\land(\forall k\in cliq.i,:k\in Adj_{j}))$

The local state of a node $i$ is defined by $\langle cliq.i\rangle$. An impedensable node $i$ in a state $s$ is a node for which (1) all the nodes in $cliq.i$ do not form a clique, or otherwise (2) there exists some node $k$ in $Adj_{i}$ such that $cliq.i\cup\{k\}$ is a valid clique, but $k$ is not in $cliq.i$. Formally,

$\textsc{Impedensable-DC}(i)\equiv$ $\lnot(i\in cliq.i\land(\forall j,k\in cliq.i,j\neq k:j\in Adj_{k}))$ $\lor$

$(\exists j\in Adj_{i}:j\not\in cliq.i\land(\forall k\in cliq.i:k\in Adj_{j}))$.

The algorithm is defined as follows. If all the nodes in $cliq.i$ do not form a clique, then $cliq.i$ is reset to be $\{i\}$. If there exists some node $j$ in $Adj_{i}$ such that $cliq.i\cup\{j\}$ is a clique, but $j$ is not in $cliq.i$, then $j$ is added to $cliq.i$.

Algorithm 1**.**

Rules for node $i$ in state $s$.

\begin{array}[]{|l|}\hline\cr\textsc{Impedensable-DC}(i)\longrightarrow\begin{cases}cliq.i=\{i\}&\text{if \lnot(i\in cliq.i\land(\forall j,k\in cliq.i,j\neq k:j\in Adj_{k}))}\\ cliq.i=cliq.i~{}\cup\{j\}&\text{otherwise (j:\forall i\in cliq.i:j\in Adj_{i})}\end{cases}{}\\ \hline\cr\end{array}

To present the abstraction of the partial order among the local states, we define the state value as follows.

\begin{array}[]{l}\textsc{State-Value-DS}(i,s)=\begin{cases}|C|-|cliq.i|:C=\text{the largest superset of cliq.i}&\text{if cliq.i is a clique}.\\ |Adj.i|+1&\text{otherwise}.\end{cases}\end{array}

$\mathcal{P}$ induces a partial order among the local states, which can be abstracted by state value as defined above: for a pair of global states $s$ and $s^{\prime}$, $s[i]<s^{\prime}[i]$ iff $\textsc{State-Value-DS}(i,s^{\prime})<\textsc{State-Value-DS}(i,s)$. As an instance, the partial order induced among the local states of node $v_{1}$ (of the graph in Figure 1 (a)) is shown in Figure 1 (b).

To present the abstraction of DAG induction, we define the rank of a global state as follows.

$\textsc{Rank-DC}(s)=\sum\limits_{i\in V(G)}\textsc{State-Value-DC}(i,s).$

As a result, the global states of the graph in Figure 1 (a) form a DAG that we show in Figure 2. For a pair of global states $s$ and $s^{\prime}$, $s<s^{\prime}$ iff $\textsc{Rank-DC}(s^{\prime})<\textsc{Rank-DC}(s)$. In Figure 2, a global state is represented as $\langle\langle cliq.v_{1}\rangle,\langle cliq.v_{2}\rangle,\langle cliq.v_{3}\rangle\rangle$. Note that the state space for this instance has a total 512 states. In the figure, we only show the states where the second guard is false in all the nodes. Observe that all the global states where the second guard is true in some nodes will converge to one of the states present in this figure, and then it will converge to one of the terminal successors of this graph.

Notice that $\forall i\lnot\textsc{Impedensable-DC}(i)$ is a self-stabilizing DAG-inducing predicate and satisfies Definition 9; Algorithm 1 that utilizes this predicate is a self-stabilizing algorithm. We show that the dominant Clique problem is a DAG-inducing problem and Algorithm 1 is a converging algorithm for the dominant clique problem in Appendix A.

Observe that Algorithm 1 fully tolerates asynchrony in AA model. This is because in a given state $s$ some node $i$ is impedensable iff $i$ does not store a dominant clique, thus, $s$ will never transition to an optimal state without $i$ changing its state.

3.4 Shortest Path (SP) Problem

Definition 11**.**

Shortest path. In the shortest path problem, the input is a weighted arbitrary connected graph $G$ (all edge weights are positive) and a destination node $v_{des}$. Every node $i$ stores $p.i$ (initialized with $\top$) and $d.i$ (initialized with $\infty$). The task is to compute, $\forall i\in V(G)$, the length $d.i$ of a shortest path from $i$ to $v_{des}$, and the parent $p.i$ through which an entity would reach $v_{des}$ starting from $i$.

The positive weights assigned for every edge denote the cost that it would take to move from node $i$ to node $j$, given that $\{i,j\}\in E(G)$. In this problem, if we consider the local state of a node $i$ to be represented only by the variable $d.i$ then the local states of the nodes will form a total order. Consequently, the resultant discrete structure formed among the global states will be a lattice. This was shown in [3]. On the other hand, in applications such as source routing [11] where the source node specifies the path that should be taken, the local states form a partial order: such a system cannot be simulated within a total order. For brevity, we only represent the next hop in $p.i$. The SP problem can be represented by the following predicate, where, $w(i,j)$ is the weight of edge $\{i,j\}$.

$\mathcal{P}_{sp}\equiv\forall i:(d.i=dis(i,v_{des})=\min\{dis(j,v_{des})+w(i,j):j\in Adj_{i}\})\land$

$(p.i=\text{arg }\min\{dis(j,v_{des})+w(i,j):j\in Adj_{i}\})$.

The local state of a node $i$ is defined by $\langle p.i,d.i\rangle$. An impedensable node $i$ in a state $s$ is a node for which its current parent is not a direct connection to the shortest path from $i$ to $v_{des}$. Formally,

$\textsc{Impedensable-SP}(i)\equiv(d.i\neq 0\land i=v_{des})\lor(\exists j\in Adj_{i}:d.i>d.j+w(i,j))$.

The algorithm is defined as follows. If an impedensable node $i$ is $v_{des}$, then $d.i$ is updated to 0 and $p.i$ is updated to $v_{des}$. Otherwise, $p.i$ is updated to the $j$ in $Adj_{i}$ for which $d.j+w(i,j)$ is minimum.

Algorithm 2**.**

Rules for node $i$.

\begin{array}[]{|l|}\hline\cr\textsc{Impedensable-SP}(i)\longrightarrow\\ \begin{cases}d.i=0,p.i=i&\text{if i=v_{des}}\\ \langle d.i,p.i\rangle=\langle d.j+w(i,j),j\rangle:j=\text{arg}\min\{d.k+w(i,k):k\in Adj_{i}\}&\text{otherwise}\end{cases}{}\\ \hline\cr\end{array}

To present the abstraction of DAG induction, we define the state value and rank as follows.

$\textsc{State-Value-SP}(i,s)=d.i-dis(i,v_{des}).$

$\textsc{Rank-SP}(s)=\sum\limits_{i\in V(G)}\textsc{State-Value-SP}(i,s).$

Under Algorithm 2, the global states form a DAG. We show an example in Figure 4 in Appendix B.

The above algorithm requires that all nodes are initialized where $d.i=\infty,p.i=\top$. If nodes were initialized to an arbitrary value (e.g., if for all nodes $i$, $d.i=0$) then the algorithm does not compute shortest paths. Hence, $\forall i~{}\lnot\textsc{Impedensable-SP}(i)$ is a DAG-inducing predicate but is not self-stabilizing; Algorithm 2 that utilizes this predicate is not self-stabilizing. We show that the shortest path problem is a DAG-inducing problem and Algorithm 2 solves the shortest path problem on a connected positive weighted graph in Appendix C.

Observe that Algorithm 2 fully tolerates asynchrony in AA model. This is because in a given state $s$, some node $i$ is impedensable iff there is a shorter path that $i$ can follow to reach $v_{des}$, thus, $s$ will never transition to an optimal state without $i$ changing its state.

3.5 Limitations of modelling problems as DAG-inducing problems

Unlike the DAG-inducing problems where the problem description creates a DAG among the states in $S$, there are problems where the states do not form a DAG naturally. Such problems are non-DAG-inducing problems. In such problems, there are instances in which the impedensable nodes cannot be distinctly determined, i.e., in those instances $\exists s:\lnot\mathcal{P}(s)\land(\forall i:\exists s^{\prime}:\mathcal{P}(s^{\prime})\land s[i]=s^{\prime}[i]$).

Maximal matching (MM) is a non-DAG-inducing problem. This is because, for any given node $i$, an optimal state can be reached if $i$ does or does not change its state. Thus $i$ cannot be deemed as impedensable or not impedensable under the natural constraints of MM. This can be illustrated through a simple instance of a 3 nodes network forming a simple path $\langle A,B,C\rangle$. Initially no node is paired with any other node. Here, MM can be obtained by matching $A$ and $B$. Thus, $C$ is not impedensable. Another maximal matching can be obtained by matching $B$ and $C$, in which case $A$ is not impedensable. Thus the problem itself does not define which node is impedensable.

We observe that it is possible to induce a DAG in non-DAG-inducing problems algorithmically. In the next section (Section 4), we study the properties of a DAG-inducing algorithm, which is capable of inducing a DAG in a non-DAG-inducing problem, along with an example (of MM) for demonstration.

4 Imposed DAG Induction: DAG-inducing Algorithms

In this section, we study algorithms that can be developed for problems that cannot be represented by a predicate under which the global states form a DAG.

4.1 General Properties of DAG-Inducing Algorithms

Non-DAG-inducing problems do not naturally define which node is impedensable. Thus, there may be multiple optimal states. However, an impedensable node can be determined algorithmically.

Definition 12**.**

DAG-inducing algorithms (DIA). $A$ is a DIA for a problem $P$, represented by predicate $\mathcal{P}$, iff

• •

$P$* is deemed solved iff the system reaches a state where $\mathcal{P}$ is true.*

• •

$\mathcal{P}$* is DAG-inducing with respect to the partial order induced in $S$ by $A$, i.e.*

$\forall s\in S:\lnot\mathcal{P}(s)\Rightarrow\exists i\ \ \textsc{Impedensable}(i,s,\mathcal{P})$.

An algorithm that traverses a $<$-DAG of global states is a DAG-inducing algorithm. Thus, an algorithm that solves a DAG-inducing problem, under the constraints of DAG-induction, e.g. Algorithms 1 & 2, is a DAG-inducing algorithm.

Definition 13**.**

Self-stabilizing DIA. Continuing from Definition 12, $A$ is self-stabilizing only if in the $<$-DAG induced by $A$, $\forall s,s^{\prime}\in S:\textsc{Terminal-Successor}(s,s^{\prime})\Rightarrow\mathcal{P}(s^{\prime})=true$.

A DAG-inducing algorithms developed for a non-DAG-inducing problem tolerates asynchrony in AMR model, but may not tolerate AA model. This is because a node in its current state may wrongly evaluate itself to be impedensable if it gets information, from other nodes, out of order. This, in turn, is because in a general case, a node $i$ may be impedensable in a state $s$, whereas it may not be impedensable in another state $s^{\prime}$, i.e., $s^{\prime}$ has a path to an optimal state where $i$ can retain its state, whereas $s$ does not have a path to any optimal state where $i$ can retain its state.

4.2 Maximal Matching (MM) problem

As discussed in Section 3.5, MM is not a DAG-inducing problem. However, a DAG-inducing algorithm can be developed for this problem, which we discuss in the following. We start by defining the MM problem as follows.

Definition 14**.**

Maximal matching. In the maximal matching problem, the input is an arbitrary graph $G$. For all $i$, $match.i$ of each node $i$ has the domain $Adj_{i}\cup\{\top\}$. The task is to compute the matchings such that for any node $i$, (1) $\forall i:match.i\neq top\Rightarrow match.(match.i)=i$, and (2) if $match.i=\top$, then there must not exist a $j$ in $Adj_{i}$ such that $match.j=\top$.

The local state of a node $i$ is defined by $\langle match.i\rangle$. We use the following macros. A node $i$ is wrongly matched if $i$ is pointing to some node $j$, but $j$ is pointing to some node $k\neq i$. A node $i$ is matchable if $i$ is not pointing to any node, i.e. $match.i=\top$, and there exists a node $j$ adjacent to $i$ which is also not pointing to any node. A node $i$ is being pointed to, or $i$ is $i$-pointed, if $i$ is not pointing to any node, and there exists a node $j$ adjacent to $i$ which is pointing to $i$. A node sees that another node is being pointed, or $i$ “sees” else-pointed, if some node $j$ around (in 2-hop neighbourhood of) $i$ is pointing to another node $k$ and $k$ is not pointing to anyone. A node is unsatisfied if it is wrongly matched or matchable. A node $i$ is impedensable if $i$ is i-pointed, or otherwise, given that $i$ does not see else-pointed, $i$ is the highest ID unsatisfied node in its distance-2 neighbourhood.

[TABLE]

The algorithm for an arbitrary node $i$ can be defined as follows. If $i$ is impedensable and i-pointed, then $i$ starts to point to the node which is pointing at $i$. If $i$ is wrongly matched and impedensable, then $i$ takes back its pointer, i.e. $i$ starts pointing to $\top$. Otherwise (if $i$ is matchable and impedensable) $i$ chooses a node $j$ which is not pointing to anyone, i.e. $match.j=\top$, and $i$ starts pointing to $j$.

Algorithm 3**.**

Rules for node $i$.

\begin{array}[]{|l|}\hline\cr\textsc{Impedensable-MM}(i)\longrightarrow\begin{cases}match.i=j:j\in Adj_{i}:match.j=i&\text{if \textsc{I-Pointed}(i)}.\\ match.i=\top&\text{if \textsc{Wrongly-Matched}(i)}.\\ match.i=j:j\in Adj_{i}:match.j=\top&\text{otherwise}.\end{cases}{}\\ \hline\cr\end{array}

To present the abstraction of DAG induction, we define the state value and rank as follows.

\begin{array}[]{l}\textsc{State-Value-MM}(i,s)=\begin{cases}3&\text{if \textsc{Wrongly-Matched}(i)}.\\ 2&\text{if \textsc{Matchable}(i)\land\lnot\textsc{I-Pointed}(i)}.\\ 1&\text{if \textsc{I-Pointed}(i)}.\\ 0&otherwise.\end{cases}\end{array}

$\textsc{Rank-MM}(s)=\sum\limits_{i\in V(G)}\textsc{State-Value-MM}(i,s).$

Under Algorithm 3, the global states form a DAG. We show an example in Figure 3: Figure 3 (a) is the input graph and Figure 3 (b) is the induced DAG. For a pair of global states $s$ and $s^{\prime}$, $s[i]<s^{\prime}[i]$ iff $\textsc{Rank-MM}(s^{\prime})<\textsc{Rank-MM}(i,s)$. In Figure 4, a global state is represented as $\langle\langle match.v_{1}\rangle$, $...$, $\langle match.v_{4}\rangle\rangle$.

Since the solution presented for this problem is self-stabilizing, $\forall i\lnot\textsc{Impedensable-MM}(i)$ forms a self-stabilizing predicate with respect to the $<$-DAG induced byAlgorithm 3. Thus, Algorithm 3 is a DAG-inducing self-stabilizing algorithm and satisfies Definition 13. We show that Algorithm 3 induces a DAG in the global state space and Algorithm 3 is a DAG-inducing algorithm for the maximal matching problem in Appendix D.

Observe that Algorithm 3 fully tolerates asynchrony in AMR model. This is because in a given state $s$, if some node $i$ is impedensable, it means that $i$ is being pointed to by some node $j$ but $i$ is not pointing to $\top$, or otherwise, $i$ is unsatisfied. Since no node in $Adj^{2}_{i}$ will change its state until $i$ changes its state, $s$ can never transition to an optimal state until $i$ changes its state. Also observe that Algorithm 3 cannot tolerate asynchrony in AA model. This is because a node $i$ in its current state may wrongly evaluate itself to be i-pointed or unsatisfied-impedensable if it gets information, from other nodes, out of order. This can result in $i$ changing its state incorrectly. As a consequence of execution in $AA$ model, $i$ can keep repeating such execution and as a result, the system will not obtain an optimal state.

5 Properties of DAG-Induction

5.1 DAG-induction to obtain asynchrony

In this subsection, we consider whether $<$-DAG induction is necessary and sufficient for asynchronous execution.

Theorem 1**.**

Let $P$ be a problem that requires an algorithm to reach a state where $\mathcal{P}$ is true. Let A be an algorithm for $P$ that is correct under a centralized scheduler.

If the state transition system $\mathcal{S}$ forms a $<$-DAG under A, then A guarantees convergence in asynchrony.

Proof.

Definition 12 follows that the local states form a partial order if every node, under Algorithm A, rejects each violating local state permanently. Consequently, a $<$-DAG is induced among the global states.

A $<$-DAG, induced under $\mathcal{P}$, allows asynchrony because if a node, reading old values, reads the current state $s$ as $s^{\prime}$, then $s^{\prime}<s$. So $\lnot\mathcal{P}(s^{\prime})\Rightarrow\lnot\mathcal{P}(s)$ because $\textsc{Impedensable}(i,s^{\prime},\mathcal{P})$ and $s^{\prime}[i]=s[i]$. ∎

The limitation of the application of the above theorem is as follows. An algorithm $A$ guarantees convergence in asynchrony in some model only if it induces a $<$-DAG in that model. For instance, DAG-inducing algorithms developed for non-DAG-inducing problems (e.g., Algorithm 3) induce a $<$-DAG in AMR model. Thus, they guarantee asynchrony in AMR model. As we discussed in Section 4.1 amd Section 4.2, such algorithms do not necessarily induce a $<$-DAG in AA model, so they may not guarantee convergence in AA model.

In the above theorem, we showed that a $<$-DAG is sufficient for allowing asynchronous executions. Next, we study if a $<$-DAG is guaranteed to be induced among the global states given that an algorithm is correct under asynchrony. In other words, we study if a $<$-DAG is necessary for asynchrony. To study that, we first examine the representation of a global state, which is a mathematical abstraction of a multiprocessor system.

Let $C$ be an algorithm that runs correctly under a centralized scheduler. Let that $R$ be the set of states that can result from a global state $s$ under $C$, i.e. $\forall s^{\prime}\in R$, $\langle s,s^{\prime}\rangle$ is a valid transition under $C$. If $C$ and $s$ are given, $R$ can be correctly computed. In synchronous systems, $s$ is an abstraction of the global state that only contains the current local states of the nodes. However, if some algorithm $A$ were to be executed in asynchrony, then a set $R^{\prime}$ of resulting states cannot be computed correctly for a given state $s$. This is because some nodes would be reading the old values of other nodes. Thus, $s$ must also contain the information that nodes have about other nodes.

Let $\mathcal{S}$ be the original transition system, and $\mathcal{S}_{ext}$ be its extended version, where a given state $s_{ext}$ identifies local states of individual nodes and the information that the nodes maintain about other nodes. Similarly, $\mathcal{S}_{ext}$ can be constructed back to $\mathcal{S}$, by removing the information that the nodes have about other nodes, and merging the global states (along with the transition edges) which the same global states.

As we noted in this paper, the State-Value of a node $i$ provides information about how bad the current local state of $i$ is, with respect to an optimal global state farthest from its current global state $s$. Thus, the evaluation of the state value of $i$ can utilize the information about the local states of other nodes in $s$. In the following theorem, we use this observation as leverage to show some interesting properties of DAG-inducing systems. Herein, instead of $\mathcal{S}$ we elaborate on the necessity of $\mathcal{S}_{ext}$ being a $<$-DAG to allow asynchrony.

Theorem 2**.**

Let $P$ be a problem that requires an algorithm to reach a state where $\mathcal{P}$ is true.

If an algorithm $A$ guarantees convergence in asynchrony, then $\mathcal{S}_{ext}$ (the extended transition system) forms a $<$-DAG.

Proof.

Since $A$ guarantees to terminate under asynchrony and the extended state space $S_{ext}$ captures the effect of asynchrony (where a node may reading old values of the variables of other nodes), there will be no cycles present among the global states in $\mathcal{S}_{ext}$, i.e., $\mathcal{S}_{ext}$ forms a DAG. Next, we transform $\mathcal{S}_{ext}$ to a $<$-DAG.

Let $S_{o}$ be the set of optimal states. For each optimal global state $o\in S_{o}$, for each node $i$ in $s$, assign the state value of $i$ to be 0. Thus, the rank of $o$ is 0 (sum of state values of all nodes). For every non-optimal global state $s$, we assign the state value of every node $i$ to be $\infty$. Subsequently, if all successors of state $s$ have a finite rank (i.e., $\forall s^{\prime}:\langle s,s^{\prime}\rangle\in E(\mathcal{S}_{ext})\Rightarrow rank(s^{\prime})\neq\infty$) then we set the state value of each node $i$ in $s$ to be $(\max\{\textsc{Rank}(s^{\prime})|\langle s,s^{\prime}\rangle\in E(\mathcal{S}_{ext})\})/n+1$. We do this recursively until no more updates happen to any state value of any global state in $\mathcal{S}_{ext}$.

Since there are no cycles, this procedure will terminate in finite time. Observe that using the above procedure, we obtain a valid $<$-DAG from $\mathcal{S}_{ext}$: in this $<$-DAG, for all reachable global states $s^{\prime}$ and $s^{\prime\prime}$, $s^{\prime}<s^{\prime\prime}$ (i.e., $\langle s^{\prime},s^{\prime\prime}\rangle$ is in $E(\mathcal{S}_{ext})$) iff $s^{\prime}[i]\leq s^{\prime\prime}[i]$, $\forall i:[1:n]$. ∎

Note that if $\mathcal{S}$ forms a $<$-DAG then so does $\mathcal{S}_{ext}$, Hence, from Theorem 1 and Theorem 2, we have

Corollary 1**.**

Let $P$ be a problem that requires an algorithm to reach a state where $\mathcal{P}$ is true.

An Algorithm $A$ guarantees convergence in asynchrony iff it induces a $<$-DAG among the (extended) global states.

The above corollary shows that a $<$-DAG is a necessary and sufficient condition for a parallel processing system to guarantee convergence in asynchrony.

5.2 Time Complexity Properties of an algorithm traversing a $<$-DAG

Theorem 3**.**

Given a system of $n$ processes, with the domain of size not more than $m$ for each process, the acting algorithm will converge in $n\times(m-1)$ moves.

Proof.

Assume for contradiction that the underlying algorithm converges in $x\geq n\times(m-1)+1$ moves. This implies, by pigeonhole principle, that at least one of the nodes $i$ is revisiting their states $st.i$ after changing to $st^{\prime}.i$. If $st.i$ to $st^{\prime}.i$ is a step ahead transition for $i$, then $st^{\prime}.i$ to $st.i$ is a step back transition for $i$ and vice versa. For a system where the global states form a $<$-DAG, we obtain a contradiction since step back actions are absent in such systems. ∎

Corollary 2**.**

Let that in each node, atmost $r$ of these variables, $var_{1}.i,...,var_{r}.i$ (with domain sizes $m_{1}^{\prime},...m_{r}^{\prime}$ respectively) contribute independently to the formation of the lattice. Then an algorithm traversing a $<$-DAG will converge in $n\times((\prod_{j=1}^{r}m_{j}^{\prime})-1)$ moves.

Corollary 3**.**

(From Theorem 4 and Corollary 2) Algorithm 1 converges in $\sum\limits_{i\in V(G)}deg(i)=2m$ moves. In terms of rounds, it converges in $\Delta$ rounds, where $\Delta$ is the maximum degree of the input graph.

Corollary 4**.**

(From Theorem 5 and Corollary 2) Algorithm 2 converges converges in $\mathcal{D}$ rounds, where $\mathcal{D}$ is the diameter of the input graph.

Corollary 5**.**

(From Theorem 6 and Corollary 2) Algorithm 3 converges in $2n$ moves.

6 Related Work

Lattices and DAGs among global states: In [3], the authors have described problems which possess a predicate under which the states naturally form a lattice. Problems like the stable marriage problem, job scheduling, market clearing price and others are studied in [3]. In [4] and [2], the authors have studied lattice linearity in, respectively, housing market problem and several dynamic programming problems.

In [6], the authors have extended the theory in [3] to develop eventually lattice linear self-stabilizing algorithms for some non-lattice linear problems. Such algorithms induce single or multiple disjoint lattices in a subset of the state space of the transition system. In [7], the authors presented a fully lattice linear algorithm for the minimal dominating set problem, where the algorithm induces single or multiple disjoint lattices among all the global states.

In this paper, we introduce DAG-inducing problems and DAG-inducing algorithms. Since a lattice is a DAG, DAG-inducing problems encapsulate lattice linear problems and DAG-inducing algorithms encapsulate lattice linear algorithms. Effectively, an algorithm developed for a DAG-inducing problem (or lattice linear problem) under the constraints of DAG-induction (or lattice linearity) is also a DAG-inducing problem. We demonstrate that the dominant clique (DC) problem and the shortest path (SP) problem are DAG-inducing problems. We demonstrate that the maximal matching (MM) problem is not a DAG-inducing problem. We present a DAG-inducing algorithm for it. We study the upper bound to the convergence time of an algorithm traversing a DAG of states. We show that a partial order induced among the local states visited by a node is a necessary and sufficient condition to allow asynchrony.

Maximal Matching: A distributed self-stabilizing algorithm for the maximal matching problem is presented in [10]; this algorithm converges in $O(n^{3})$ moves. The algorithm in [8] converges in $O(\log^{4}n)$ moves under a synchronous scheduler. The algoritrithm for maximal matching presented in [5] converges in $n+1$ rounds. Hedetniemi et al. (2001) [9] showed that the algorithm presented in [10] converges in $2m+n$ moves.

The DAG-inducing algorithm for maximal matching, present in this paper, converges in $2n$ moves and is tolerant to asynchrony. This is an improvement to the algorithms present in the literature.

7 Conclusion

In this paper, we introduce the class of problems called DAG-inducing problems and the class of algorithms called DAG-inducing algorithms. The key idea in these problems and algorithms is that when the system is in a suboptimal state, there is at least one node that is impedensable; the execution of such nodes is essential to reach an optimal state.

The essential property for an algorithm $A$ to allow asynchrony is that $A$ should be able to enforce acyclic transitions among the global states. A partial order, induced among the local states, ensures this property. It means that a node $i$ does not revisit its state $st.i$ once $st.i$ is discarded. Consequently, a $<$-DAG is induced among the global states. In addition, an acyclic transition system can be represented as a $<$-DAG. Thus, the induction of a $<$-DAG is a necessary and sufficient condition to allow asynchrony, as we show in Section 5.1.

DAG-inducing problems exhibit a DAG among their states that allows convergence to an optimal state. If a problem is not DAG-inducing, a DAG-inducing algorithm may be designed for it. In both these cases, the execution of the impedensable nodes causes the system to move up in the DAG, and correctness is guaranteed in asynchrony.

In the literature, there are works on lattice linear problems and algorithms, where a ($<$-)lattice is induced under a predicate or an algorithm respectively. Since a total order is a special case of a partial order and (consequently) a lattice is a subclass of a DAG, lattice linear problems are a proper subset of the class of DAG-inducing problems, and lattice linear algorithms are a proper subset of the class of DAG-inducing algorithms.

Appendix

A Dominant Clique Problem is a DAG-Inducing Problem

Lemma 1**.**

The dominant Clique problem is a DAG-inducing problem.

Proof.

For a node $i$, $cliq.i$ contains the nodes that $i$ is connected with and the nodes in $cliq.i$ should form a clique. A global state does not manifest a dominant clique if at least one node $i$ in $s$ does not store a set of nodes forming a maximal clique with itself, i.e. (1) $cliq.i$ is not a maximal clique, that is, $\exists j\in Adj_{i}\setminus cliq.i:cliq.i\cup\{j\}$ forms a valid clique, or (2) the nodes in $cliq.i$ do not form a clique.

Next, we need to show that if some node $i$ in state $s$ is violated, then $\forall s^{\prime}>s$, if $s^{\prime}[i]=s[i]$, then $s^{\prime}$ will not manifest a dominant clique. This is straightforward from the definition itself, that if a node $i$ is impedensable, then $i$ does not store a set of nodes forming a maximal clique with itself. If $i$ is impedensable in $s$, and $i$ has the same state in some $s^{\prime}>s$ then $i$ stays impedensable in $s^{\prime}$ as well as it does not store a set of nodes forming a maximal clique. ∎

Theorem 4**.**

Algorithm 1* is n converging algorithm for the dominant clique problem.*

Proof.

We need to show that (1) Algorithm 1 traverses a DAG of global states, (2) for all suboptimal states, $\exists$ a terminal successor, and (3) all terminal global states are optimal states.

Let the current state be $s$. If $s$ is suboptimal, then for at least for one of the nodes $i$: (1) $cliq.i$ is not a maximal clique, that is, $\exists j\in Adj_{i}\setminus cliq.i:cliq.i\cup\{j\}$ forms a valid clique, or (2) the nodes in $cliq.i$ do not form a clique.

In the case that $s$ is suboptimal and the first case holds true for some node $i$, then under Algorithm 1, $i$ will include a node $j$ in $cliq.i$ which forms a clique with the nodes already present in $cliq.i$, which reduces the state value of $i$ by at least 1.

In the case that $s$ is suboptimal and the second case holds true for some node $i$, then under Algorithm 1, $i$ will change $cliq.i$ to be $\{i\}$, which reduces the state value of $i$ from $|Adj+1|$ to some value less than or equal to $|Adj_{i}|$.

Thus under Algorithm 1, an arbitrary graph will follow a DAG of states and if it transitions from a state $s$ to another state $s^{\prime}$, then we have that $s^{\prime}>s$ such that rank of $s^{\prime}$ is less than the rank of $s$.

The state value of any node is impedensable. Thus the rank of any global state is also impedensable. When a impedensable node $i$ makes an execution, then its state value reduces, until it becomes 0. Thus if there is a global state $s$ with rank greater than 0, then there exists at least one impedensable node in it. When any node performs execution in $s$ then $s$ transitions to some state with rank less than $s$. This shows that for every suboptimal global state, there exists at least one terminal successor.

Let that $s$ is a terminal successor. This implies that $\mathcal{P}(s)$ is true. There does no exist an impedensable node in $s$, so any node will not change its state and $s$ manifests a dominant clique. Thus we have that all terminal states are optimal states. ∎

B Figure for Shortest Path

Figure 4 (a) is the input graph and Figure 4 (b) is the DAG induced among the global states. For a pair of global states $s$ and $s^{\prime}$, $s<s^{\prime}$ iff $\textsc{Rank-SP}(s^{\prime})<\textsc{Rank-SP}(s)$. In Figure 4, a global state is represented as $\langle\langle p.v_{1}$, $d.v_{1}\rangle$, $...$, $\langle p.v_{4}$, $d.v_{4}\rangle\rangle$.

C Shortest Path Problem is a DAG-Inducing Problem

Lemma 2**.**

The shortest path problem is a DAG-inducing problem.

Proof.

For a node $i$, $d.i$ contains the distance of $v_{des}$ from node $i$. A global state $s$ does not manifest all correct distances if for at least one node $i$ in $s$, (1) $dis(i,v_{des})\neq d.i$, that is, $i$ does not store a shortest path from $i$ to $v_{des}$, or (2) the parent of $i$ is not a valid direct connection in a shortest path from $i$ to $v_{des}$.

Next, we need to show that if some node $i$ in state $s$ is violated, then $\forall s^{\prime}>s$, if $s^{\prime}[i]=s[i]$, then $s^{\prime}$ will not manifest all shortest paths. This is straightforward from the definition itself, that if a node $i$ is impedensable, then either $i=v_{des}$ and it is not pointing to itself through $p.i$, or there is at least one other node $j$ such that $d.i>d.j+w(i,j)$. If $i$ is impedensable in $s$, and $i$ has the same state in some $s^{\prime}>s$ then $i$ stays impedensable in $s^{\prime}$ as well as it does not store the length of a shortest path in $d.i$. ∎

Theorem 5**.**

Algorithm 2* solves the shortest path problem on a connected positive weighted graph.*

Proof.

We need to show that (1) Algorithm 2 traverses a DAG of global states, (2) for all suboptimal states, $\exists$ a terminal successor, and (3) all terminal global states are optimal states.

Let the current state be $s$. If $s$ is suboptimal, then for at least for one of the nodes $i$: (1) $p.i\neq i\land i=v_{des}$, that is, $i$ is the destination node and is not pointing to itself, or (2) $dis(i,v_{des})\neq d.i$, that is, $i$ does not store a shortest path from $i$ to $v_{des}$.

In the case that $s$ is suboptimal and the first case holds true for some node $i$, then under Algorithm 1, $i$ updates $d.i$ to 0 and $p.i$ to $i$, which reduces the state value of $i$ to 0.

In the case that $s$ is suboptimal and the second case holds true for some node $i$, then under Algorithm 2, $i$ will reduce its $d.i$ value and update $p.i$, which reduces the state value of $i$ at least by 1.

Thus under Algorithm 1, an arbitrary graph will follow a DAG of states and if it transitions from a state $s$ to another state $s^{\prime}$, then we have that $s^{\prime}>s$ such that rank of $s^{\prime}$ is less than the rank of $s$.

If no node is impedensable, then this implies that all nodes have computed the shortest distance in their $d.i$ variable, and thus the rank is 0. Thus if there is a global state $s$ with rank greater than 0, then there exists at least one impedensable node in it. When any node performs execution in $s$ then $s$ transitions to some state with rank less than $s$. This shows that for every suboptimal global state, there exists at least one terminal successor.

Let that $s$ is a terminal successor. This implies that $\mathcal{P}(s)$ is true. There does no exist an impedensable node in $s$, so any node will not execute and $s$ manifests correct shortest path evaluation for all nodes. Thus we have that all terminal states are optimal states. ∎

D Algorithm 3 is a DAG-Inducing Algorithm for the Maximal Matching Problem

Lemma 3**.**

Algorithm 3* induces a DAG in the global state space.*

Proof.

The DAG is induced in the global state space with respect to the state values. Let $s$ be a suboptimal state that the input graph is in. A node $i$ is impedensable in $s$ (1) if $i$ is wrongly matched, (2) if $i$ is matchable, or (3) if $i$ is being pointed at by another node $j$, but $i$ does not point back to $j$ or any other node.

Next we show that if some node $i$ is impedensable in some state $s$, then for any state $s^{\prime}:s^{\prime}>s$, if $s^{\prime}[i]=s[i]$, then $s^{\prime}$ will not form a maximal matching under Algorithm 3.

In the case if $i$ is wrongly matched in $s$ and is impedensable, and it is pointing to the same node in $s^{\prime}$ as well, then $i$ stays to be impedensable in $s^{\prime}$ because any other node will not take back its pointer before $i$ does under Algorithm 3. Thus $s^{\prime}$ does not have a correct matching.

In the case if in $s$, $i$ is being pointed to by some node but $j$ does not point to any node, and $i$ stays in the same state in $s^{\prime}$, then $s^{\prime}$ is stays to be impedensable as $s^{\prime}$ because once a node points towards an unmatched node, it does not retreat its pointer under Algorithm 3. Also, any node in $Adj^{2}_{j}$ will not execute until $i$ does under. Thus $s^{\prime}$ does not form a correct matching.

Finally, in the case if $i$ is matchable and impedensable in $s^{\prime}$, and it stays the same in $s^{\prime}$, then it is still impedensable as any other node in $Adj_{i}$ will not initiate matching with it under Algorithm 3. Also, any node in $Adj^{2}_{i}$ will not execute until $i$ does. Thus $s^{\prime}$ stays to be impedensable. ∎

Theorem 6**.**

Algorithm 3* is a DAG-inducing algorithm for the maximal matching problem.*

Proof.

We show that (1) Algorithm 3 traverses a DAG that has the properties as mentioned in Lemma 3, (2) for all subpotimal states $\exists$ a terminal successor, and (3) all terminal global states are optimal states.

If $s$ is suboptimal, then for at least one of the nodes $i$: (1) $i$ is wrongly matched, (2) $i$ is matchable, or (3) $i$ is being pointed at by another node $j$, but $i$ does not point back to $j$ or any other node.

In the case that $s$ is suboptimal and some node $i$ is being pointed to by some node $j$ and $i$ does not point to any node, then under Algorithm 3, $i$ will point back to $j$, and thus the state value of $i$ will get reduced from $1$ to [math].

In the case that $s$ is suboptimal and some node $j$ is wrongly matched or matchable with $\lnot\textsc{Else-Pointed}(j)$, then at least one node (e.g., a node with highest ID which is wrongly matched or matchable) will be unsatisfied and impedensable. Let that $i$ is unsatisfied and impedensable. Here $i$ is either wrongly matched or matchable. If $i$ is wrongly matched, then $i$ will change its pointer and start pointing to $\top$, in which case its state value will change from 3 to 2, 1, or 0. If $i$ is matchable then, $i$ will start pointing to some node $i^{\prime}$ in $Adj_{i}$, in which case, the state value of $i$ will change from 2 to 0 and the state value of $i^{\prime}$ will change from 2 to 1.

In all the above cases, we have that under Algorithm 3, if $s$ is a suboptimal state, then its rank will be of some value greater than zero because at least one of the nodes will be impedensable. $s$ will transition to some state $s^{\prime}$ whose rank is less than that of $s$. Thus, we have that Algorithm 3 transitions $s$ to $s^{\prime}$ and thus decreases the rank of the system. This shows that (1) Algorithm 3 traverses a DAG that has the properties as mentioned in Lemma 3, (2) for all subpotimal states $\exists$ a terminal successor.

In the case that $s$ is an optimal state, then none of the nodes will be optimal. So no node will change its state. This state will manifest a maximal matching. This shows that all terminal successors are optimal states. ∎