Stabilization Time in Minority Processes

TL;DR

This paper investigates the stabilization time of minority processes in graphs, establishing new lower bounds that are nearly quadratic, applicable in various models including sequential and concurrent, revealing fundamental limits of such dynamics.

Contribution

The paper introduces a novel graph construction that proves a nearly quadratic lower bound on stabilization time for minority processes, extending previous bounds to more general models.

Findings

Establishes an $oldsymbol{ ext{Ω}(n^2)}$ lower bound in the sequential adversarial model.

Proves a $oldsymbol{ ext{Ω}(n^{2-oldsymbol{ ext{ε}}})}$ lower bound for any $ ext{ε}>0$.

Bounds hold even in benevolent and concurrent models.

Abstract

We analyze the stabilization time of minority processes in graphs. A minority process is a dynamically changing coloring, where each node repeatedly changes its color to the color which is least frequent in its neighborhood. First, we present a simple $\Omega(n^2)$ stabilization time lower bound in the sequential adversarial model. Our main contribution is a graph construction which proves a ${\Omega}(n^{2-\epsilon})$ stabilization time lower bound for any $\epsilon>0$. This lower bound holds even if the order of nodes is chosen benevolently, not only in the sequential model, but also in any reasonable concurrent model of the process.

Tables

Table 1. Table 1 : Number of steps on some specific graphs

Input ($r$)		Nodes ($n$)		Steps
2		99		112
4		469		772
8		1 929		5 884
16		7 729		47 404
24		17 369		161 372
30		27 119		316 568
40		48 169		754 108
60		108 269		2 559 188
80		192 369		6 084 268
100		300 469		11 905 348
120		432 569		20 598 428

Full text

1 Introduction

If you google “bad wifi”, one advice you will get for sure is to choose the least crowded frequency in order to minimize interference with your neighbors. Unfortunately, this least crowded frequency may change again if some of your neighbors do the same.

Frequency allocation is a familiar example of minority processes in graphs: given a graph, a set of colors, and an initial coloring of the nodes with these colors, a minority process is a process where each node, when given the chance to act, modifies its color to a color that has the smallest number of occurrences in its neighborhood. This results in a dynamically changing coloring, which is essentially a form of distributed automata. Minority processes arise in various fields of economics [22] or social science [9] when players are motivated to differentiate from each other, but they also emerge in cellular biology [10] or crystallization mechanics [6, 7].

A minority process is said to stabilize when no node has an incentive to change its color anymore. The aim of the paper is to understand how long it takes until such a minority process reaches a stable state. We study the process in several different models, some of them sequential, some concurrent. In sequential models, when only one node at a time can change its color, stabilization time depends on the choice of the order of nodes. Hence, the model can further be subdivided into three cases, depending on whether the order of acting nodes is specified benevolently (trying to minimize stabilization time), adversarially (trying to maximize stabilization time), or randomly.

On the other hand, in concurrent models, multiple nodes are allowed to switch their color at the same time. However, if two (or more) neighboring nodes continuously keep on forcing each other to switch their color, the system may never stabilize. The simplest such example is a graph of two connected nodes that have the same initial color, and keep on switching to the same new color in every step. We also study concurrent models that exclude this behavior, as it is unrealistic in many application areas where neighbors are unlikely to switch at the exact same time.

In any model where simultaneous neighboring switches are excluded, it is easy to prove a $O(n^{2})$ upper bound on stabilization time for minority processes. Initially, some (maybe even all) of the at most $O(n^{2})$ edges in the graph are monochromatic (i.e., they have a conflict). When a node switches its color to the minority color in its neighborhood (but its neighbors do not change color in the same step), then the number of conflicts on the adjacent edges strictly decrease. Since the original number of conflicts is $O(n^{2})$ and the overall number of conflicts decreases by 1 at least in each step, the number of steps is limited to $O(n^{2})$.

However, this raises a natural question: are there example graphs that exhibit this naive upper bound? Or is there a significantly lower (e.g. linear) upper bound on stabilization time in some models? While these questions are already answered for the “dual” problem of majority processes (when nodes switch to the most frequent color in their neighborhood), for the case of minority processes, they have remained open so far.

The main contributions of the paper are constructions that prove lower bounds on stabilization time of minority processes. As a warm-up, we present a simple example in Section 4 which shows that in the sequential adversarial model, stabilization may take $\Theta(n^{2})$ steps. Our main result is a construction proving that stabilization can also take superlinear time in the sequential benevolent case. We first present a graph and an initial coloring in Section 5 where any selectable sequence lasts for $\Omega(n^{3/2})$ steps. Then in Section 6, we outline how a recursive application of this technique leads to a stabilization time of $\Omega(n^{2-\epsilon})$ for any $\epsilon>0$, almost matching the upper bound of $O(n^{2})$. This is an interesting contrast to majority processes, where stabilization time is bounded by $O(n)$ in the benevolent case. Furthermore, our construction shows that this almost-quadratic lower bound holds not only in the sequential model, but also in any reasonable concurrent setting.

2 Related work

While there is a wide variety of results on both minority and majority processes, majority processes have been studied much more extensively. Recently, [13] has shown that stabilization time in majority processes can be superlinear both in the synchronous model, and in the sequential model if the order is chosen by an adversary. However, [13] has also shown that stabilization always happens in $O(n)$ time in the sequential benevolent model. In case of majority processes in weighted graphs, a $2^{\Theta(n)}$ lower bound on stabilization time was also shown in [21].

Other aspects of majority processes have also been studied thoroughly, especially in the synchronous model. Results on majority processes include basic properties [18, 32], their behavior on random graphs [14, 24], complexity results on determining stabilization time [20], minimal sets of nodes that dominate the process [11, 15], the existence of stable states in the process [3, 16, 17, 29, 4, 2, 5], and modified process variants [31, 23].

In contrast to this, the dynamics of minority processes has received less attention. The stabilization of minority processes has only been studied in special classes of graphs, including tori, cycles, trees and cliques [26, 27, 28]. These studies are mostly conducted only in the synchronous or the sequential random model. More importantly, these results study a different variant of the minority process, which considers the closed neighborhood of nodes, and thus can result in significantly larger (possibly exponential) stabilization time, even in the unweighted case. An experimental study of the processes on grids is also available in [26].

In weighted graphs, it has recently been shown in [25] that stabilization of minority processes can take $2^{\Theta(n)}$ steps in various models, matching a straightforward exponential upper bound in the weighted case. However, the constructions of [25] use exponentially large node or edge weights to obtain these results; as such, the same techniques are not applicable in the unweighted case.

Besides these studies on the dynamics of the process, there are also numerous theoretical results on stable states in minority processes. These include complexity results on deciding the existence of different stable state variants [22, 3], characterization of infinite graphs with a stable state [30, 1, 8], and analysis of price of anarchy in such states as local minima [22, 12]. In the work of [19], it is also shown that slightly modified minority processes, based on distance-2 neighborhood of nodes, can provide better local minima at the cost of larger (but still polynomial) stabilization time.

However, in contrast to majority processes, the stabilization time of minority processes in general unweighted graphs has remained unresolved so far.

3 Definitions and background

3.1 Models

In the paper, we primarily focus on the following models:

1. A.

Sequential adversarial: In every step, only one node switches. The order of nodes is specified by an adversary who maximizes stabilization time. 2. B.

Sequential benevolent: In every step, only one node switches. The order is specified by a benevolent player who minimizes stabilization time. 3. C.

Independent benevolent: In every step, the benevolent player is allowed to choose any independent set of switchable nodes, and switch them simultaneously. 4. D.

Free benevolent: In each step, the benevolent player is allowed to choose any set of switchable nodes, and switch them simultaneously.

However, our lower bounds extend to a range of other popular models:

1. E.

Concurrent synchronous: In every step, all switchable nodes switch simultaneously. 2. F.

Sequential random: In every step, only one node switches, chosen uniformly at random among the switchable nodes. 3. G.

Concurrent random: In every step, every switchable node switches with probability $p$, independently from other nodes.

An intuitive illustration of these models is shown in Figure 1. The vertical axis shows how concurrent a model is, the horizontal shows how wide is the set of opportunities it grants the player to speed up / slow down stabilization. In the case of majority processes, models A and E are shown to take superlinear time to stabilize for some graphs, but model B always stabilizes in linear time [13]. However, we prove that for minority processes, even model B can take superlinear time. Models C and D grant even wider sets of possible (concurrent) moves for the benevolent player, which may drastically reduce the number of steps in some cases; however, we show that the same lower bound holds even if such moves are available.

Note that models A, B, C and F exhibit a natural $O(n^{2})$ upper bound on stabilization time, as the overall number of conflicts decreases in each step by at least 1. On the other hand, models D, E or G may allow neighboring nodes to switch at the same time, and thus in these models, some nodes may keep on endlessly changing colors. However, our constructions specifically ensure that connected nodes are never switchable at the same time, and thus for these particular graphs, the process stabilizes in any of the models.

Through most of the analysis in the paper, we focus on the sequential models. We first show a simple construction with $\Theta(n^{2})$ stabilization time in model A. We then present a more complex construction to first show $\Omega(n^{3/2})$, and then $\Omega(n^{2-\epsilon})$ stabilization time in model B. It then follows from a few observations that these latter constructions also have the same stabilization time in models C and D. Since model D provides the widest set of opportunities from all models, this implies the same lower bound for each of the listed models.

3.2 Preliminaries

Throughout the paper, we consider simple, unweighted, undirected graphs. Graphs are denoted by $G$, their number of nodes by $n$, and the maximum degree in the graph by $\Delta$.

Given a graph $G$ on the vertex set $V$, an independent set is a subset of $V$ such that no two nodes in this subset are connected. A coloring of the graph with $k$ colors is the assignment of one of the colors (numbers) from $\{1,2,...,k\}$ to each of the nodes. If two nodes share an edge and are assigned the same color, then the nodes have a conflict on this edge.

Our process consists of discrete time steps (states), where we have a current coloring of the graph in every state. When a node $v$ is currently colored $c_{1}$, but there exists a color $c_{2}$ such that the neighborhood of $v$ contains strictly less nodes colored $c_{2}$ than nodes colored $c_{1}$, then the node is switchable (since the node could reduce its number of conflicts by changing its color). The process of $v$ changing its color is switching. Nodes always make locally optimal solutions, that is, they switch to the color which is least frequent in their neighborhood. In case of multiple optimal colors, related work on majority processes considers different tie-breaking rules. However, our constructions ensure that a tie can never occur, and thus our bounds hold for any tie-breaking strategy.

The minority process is a sequence of steps, where each step is described by a set of nodes that switch. Note that we only consider valid steps, where every chosen node is switchable.

A state is stable when no node in the graph is switchable; a system stabilizes if it reaches a stable state. Stabilization time is the number of steps until the process stabilizes. Note that in case of model E, papers studying majority processes often use a different definition of stabilization, based on periodicity. However, our constructions ensure that the process always ends in a stable state, thus for the graphs in the paper, the two definitions of stabilization are equivalent.

In our examples, we will consider the case of having only two available colors, black and white. However, as discussed in Section 3.3, our lower bounds are easy to generalize to any number of colors.

The restriction to two colors allows us to introduce some helpful terminology. Consider a node $v$ at a given state of the process. If $v$ has $v_{s}$ neighbors with the same color as $v$, and $v_{o}$ neighbors with the opposite color, the number $v_{o}-v_{s}$ is called the balance of $v$. Note that if one of the neighbors of $v$ switches, then the balance of $v$ either increases or decreases by 2 (which shows that the parity of the balance of $v$ can never change). The definition also implies that $v$ is switchable if and only if its balance is negative. Switching $v$ changes the sign of its balance.

3.3 General tools in the constructions

Groups.

We use the notion group to refer to a set of nodes that have the same initial color and the exact same set of neighbors (hence, groups are independent sets). Groups are, in fact, only a tool to consider certain nodesets together as one entity for simpler presentation. They will be shown as only one node with double borders in the figures, with the size of the group indicated in brackets.

In the adversarial case, we will only consider sequences that switch groups together (i.e consecutively in any order). In the benevolent case, groups will be switched together in the sense that if a node in the group switches, then all other nodes in the group will also switch before any neighbor of the group becomes switchable; this property is enforced by the graph construction.

The more complicated definition in the benevolent case is due to the fact that we have to consider every possible sequence that the player can choose. Technically, in some sequences, a group might not be switched consecutively (it might be interrupted by switches in other, distant parts of the graph), but the outcome will still be equivalent to switching them consecutively.

Fixed nodes.

Assume we already have a graph $G$ on $n$ nodes, with maximum degree $\Delta$. Now let us add two more set of nodes $F_{w}$, $F_{b}$ to the graph such that $|F_{w}|=|F_{b}|=n+1$, and $v_{w}$ and $v_{b}$ are connected for all $v_{w}\in F_{w}$, $v_{b}\in F_{b}$. Let the color of $F_{w}$ and $F_{b}$ initially be white and black, respectively. The nodes in $F_{w}$ and $F_{b}$ will be referred to as fixed nodes, and we will connect them to some of the nodes in our original graph. Note that these fixed nodes already have $n+1$ neighbors of the opposite color, and can never have more neighbors of the same color (as they can have at most $n$ neighbors $G$), so their color is indeed fixed and they can never switch.

Such fixed nodes are widely used in our construction; we can allow any node in $G$ to have up to $\Delta+1$ fixed neighbors of either color (having more fixed node neighbors does not affect the behavior of the node anymore). The introduction of fixed nodes increases the graph size only by a constant factor (to $3n+2$), so all lower bounds expressed as a function of $n$ will still be of the same magnitude as a function of $3n+2$. Therefore, for ease of presentation, we still use $n$ to denote the number of nodes in the graph without the extra fixed nodes, and express our bounds as a function of $n$.

Fixed node neighbors are denoted by squares in the figures, with the multiplicity written beside the node (if more than 1). Note that for convenience, we draw separate squares for different nodes, even though the corresponding fixed node sets might overlap. This is because fix node connections are thought of as a “property” of the node, introducing an offset into its initial balance.

Generalization to more colors.

While the paper discusses the case of two colors, a simple idea allows a generalization to any constant number of colors $k$. Assume we have a construction $G$ on $n$ nodes, showing a lower bound on stabilization time with two colors; we can simply add sets of nodes $F_{3}$, $F_{4}$, …, $F_{k}$ of size $\Delta+1$ such that they form a complete multipartite graph, and connect all these new nodes to all nodes in $G$. Let us color the nodes in $F_{i}$ with color $i$.

None of the original nodes in $G$ will ever assume any of the colors $3$, $4$, …, $k$, since they always have $\Delta+1$ neighbors of these colors, while they have strictly less (at most $\Delta$) neighbors of colors $1$ and $2$. Nodes in $F_{i}$ will never have any incentive to switch, since they have no conflicts at all. Thus the process will behave as if the graph only consisted of $G$ with colors 1 and 2. As the new nodes only increase the graph size by a constant factor, we receive an example with the same magnitude of running time, but with $k$ colors.

With the same technique, our lower bound of $\Omega(n^{3/2})$ can also be generalized to the case of up to $\Theta(\sqrt{n})$ colors; details of this are discussed in Appendix B.

4 Sequential adversarial model

We first present a simple example where model A takes $\Omega(n^{2})$ steps. Let us introduce a parameter $m$, the value of which will be determined later. Our construction, shown in Figure 2, consist of a group $P$ of size $m$, initially colored white, and $2m$ distinct nodes $A_{1}$, $A_{2}$, …, $A_{2m}$, such that $A_{i}$ is initially colored black for odd values of $i$ and white for even $i$. Let us connect all nodes $A_{i}$ to $P$, and add one more fixed black node that is connected only to $P$. Finally, let us connect each $A_{i}$ to $m+1$ fixed nodes of the same color as $A_{i}$. Recall that although the figure shows multiple squares, there are in fact only $n+1$ fixed black and $n+1$ fixed white nodes in the graph altogether.

In this graph, $P$ has a balance of 1 initially, while black $A_{i}$ have a balance of $-1$ and white $A_{i}$ have a balance of $-(2m+1)$. Note that even after execution begins, until $A_{i}$ is switched for the first time, it will have $m+1$ fixed neighbors of the same color and at most $m$ neighbors of the opposite color (depending on the current color of $P$), and thus a negative balance. Therefore, each $A_{i}$ is switchable anytime if it has not been switched before.

Consider the following sequence of adversarial moves in this graph: the player first decides to switch $A_{1}$, then $P$, then $A_{2}$, then $P$ again, then $A_{3}$, $P$, …, $A_{2m}$, and finally $P$ again. As each $A_{i}$ is used only once, they are clearly all switchable. As for $P$, its balance first changes from 1 to $-1$, when changing $A_{1}$ to white, but increases back to $1$ when we switch $P$ itself. Then it changes to $-1$ once again after changing $A_{2}$, so it is switchable again, and so on: each time we switch an $A_{i}$, we change it to the same color that $P$ currently has, decreasing $P$’s balance to $-1$, which increases back to 1 again as we switch $P$. Therefore, this strategy is indeed a sequence of valid switches.

Since $P$ contains $m$ nodes and is switched $2m$ times in this sequence, this alone contributes to $2m^{2}$ switches. Altogether, we have $3m$ nodes in the graph, allowing us a choice of $m=\frac{n}{3}$ (recall that fixed nodes are ignored when counting the nodes in the graph). This gives us a sequence with at least $\frac{2}{9}n^{2}$ steps.

Theorem 1**.**

There exists a graph construction with $\Omega(n^{2})$ stabilization time in model A.

5 Construction for benevolent models

This section presents a graph construction with $\Omega(n^{3/2})$ stabilization time in benevolent models. Note that it is much more involved to find an example where benevolent models take $\omega(n)$ steps, since in such a construction, we have to ensure that any possible sequence lasts for a long time. In order to have an easy-to-analyze construction, our graph will, at any point in time, contain only one, or a small given set of nodes that are switchable, and switching this or these nodes enables the next such set of nodes (i.e., makes them switchable). This way, the switchable point “propagates” through the graph, and the benevolent player has no other valid move than to follow this path of propagation that has been designed into the graph.

The general idea behind the construction is to have a linearly long chain of nodes which is propagated through multiple times. After each such round, the propagation enters a different branch of further nodes; this branch resets the chain for the following round, and then also triggers the following round of propagation (as outlined later in Figure 10).

Due to the complexity of the construction, we do not describe it directly; instead, we define smaller functional elements (gadgets) that execute a certain task. We then use these gadgets as building blocks to put our example graph together. This section outlines the tasks and main properties of the gadgets; a detailed description and analysis of each gadget can be found in Appendix B. While the concrete gadget designs are specific to minority processes, they are built on general ideas and techniques for benevolent models; as such, we hope they may inspire similar solutions in the analysis of related processes or cellular automata.

When describing a gadget, the edges connecting the gadget to other nodes in the graphs are drawn as dashed lines in the figures, with the external node usually denoted by $v$ (possibly with some subscript). Although our graph is undirected, we often refer to such edges as input or output edges of the gadget, and also show this direction in the figures. This will refer to the role that the external node plays in the functionality of the gadget. That is, whenever the gadget is used in our constructions, it is triggered by (some of) its input nodes switching, and upon completing its task, the gadget makes (some of) its output nodes switchable.

Naturally, as in the entire graph, the role of the two colors is always interchangeable within the gadgets. Therefore, we only present each such gadget in one color variant.

Due to the complexity of the construction, we have also verified its correctness through implementing the process. A discussion of these simulations is available in Appendix C.

Simple relay.

As our most basic tool to propagate the only possible point of switching, we use the simple relay gadget shown in Figure 3(a). A simple relay only consist of a base node $B$, connected to a fixed node of the same color.

Besides the fixed node, $B$ also has a left and a right neighbor ($v_{L}$ and $v_{R}$) outside of the gadget, both of which initially have the opposite color as $B$. This way, until neither of the two switch, $B$ has positive balance and cannot switch either. However, as soon as $v_{L}$ switches to the color of $B$, $B$ becomes switchable, and as $B$ switches, this can propagate the point of change to its other neighbor $v_{R}$ (Figure 3(b)).

Note that connecting alternating-colored relays into a chain already gives a simple example of linear stabilization time (see Figure 3(c)). If the leftmost (white) relay’s base node is connected to a fixed white node, then the only available sequence of moves is to switch the base nodes in the relays one by one from left to right, resulting in a sequence of $n$ steps.

Through the concept of input and output nodes, relays essentially allow us to connect other, more sophisticated gadgets in our constructions. If some gadget has an output node $v_{1}$ and another gadget has an input node $v_{2}$, we can add a chain of relays between $v_{1}$ and $v_{2}$, ensuring that once $v_{1}$ switches, it will be followed by $v_{2}$ eventually. Because of this role, simple relays are not shown explicitly in our final overview figure of the construction, but only represented by arrows, indicating the direction of propagation between more complex gadgets.

Rechargeable relay.

A more sophisticated version of a relay is the rechargeable relay shown in Figure 4(a). In such a relay, node $B$ is extended by an upper node $U$, a control group $C$ of size 2, and two recharge nodes $R_{1}$, $R_{2}$, the role of which are interchangeable. Besides $v_{L}$ and $v_{R}$, the nodes $R_{1}$ and $R_{2}$ also have edges to some external nodes. It is always ensured that the initial balance of $R_{1}$ and $R_{2}$ from these upper neighbors (that is, with $C$ ignored) is exactly 3.

As in case of a simple relay, if $v_{L}$ switches, then $B$ itself can switch, followed by $v_{R}$. Now assume that in this “used” phase of the relay, some outside circumstance changes 3 neighbors of node $R_{2}$ from black to white, and thus its balance changes from the current value of 5 to $-1$ (the relay is recharged). Then $R_{2}$ can switch to black, making $C$ and in turn $U$ switch, too. Finally, assume that some other outside circumstance then changes the balance of $R_{2}$ from 5 to $-1$ again (known as resetting the relay); then $R_{2}$ will switch back to white (with a new balance of 1), and we end up in the initial state of a rechargeable relay of the opposite color. The steps of the process are shown in Figure 4(b).

This is exactly the essence of this gadget: it is a relay which can be used the same way multiple times. Connecting such gadgets into a chain in the same fashion as Figure 3(c), we get a chain that can propagate the point of change not only once, but multiple times if “recharged” through their upper connections between two such propagations.

Recharging system.

The rechargeable relay suggests that it is useful to have a tool to “recharge” some nodes, i.e. to decrease their balance by switching some of their neighbors to the color they currently have. To execute this task efficiently on many nodes, we present a recharging system.

For the first version of this gadget, assume a setting where there is a set $X$ of $m$ black nodes, and we want to decrease the balance of each of these nodes by $2$ (i.e., change exactly one white neighbor of each of them to black). A basic recharging system, shown in Figure 5(a), can execute this task while using only $O(\sqrt{m})$ nodes. The gadget is organized into 3 levels: a single node $U$ in the upper level, a group $M$ of $\sqrt{m}+1$ nodes in the middle level, and $\sqrt{m}$ distinct nodes $L_{i}$ in the lower level. Each lower level node is connected to $\sqrt{m}$ different nodes in $X$, thus exactly covering the nodes of $X$.

The gadget operates in a top-to-bottom fashion: once $v$ switches, $U$ turns black, followed by $M$ turning white. Once all nodes in $M$ are switched, the nodes $L_{i}$ all decide to switch, too.

The key idea in the design of the gadget is that each node $L_{i}$ has strictly more neighbors in $M$ than in $X$. This ensures that as long as $M$ is black, the nodes $L_{i}$ always have a positive balance, regardless of the current color of their neighbors in $X$. Therefore, no node in the gadget can ever switch before the node $U$ is triggered.

We can use this insight to create a similar gadget for a more general setting. Assume that we similarly have a set $X$ of $m$ black nodes, but instead of decreasing their balance by 2, we want to decrease the balance of each node in $X$ by some specific (possibly different) even value, denoted by $2x_{1}$, $2x_{2}$, …, $2x_{m}$ (i.e., for the $j^{\text{th}}$ node in $X$, we want to change $x_{j}$ of its white neighbors to black). Let us denote the sum $\sum_{j=1}^{m}x_{j}$ of these values by $\chi$.

We can achieve this using a similar construction, shown in Figure 5(b). In this generalized recharging system, we allow multiple nodes $L_{i}$ to be connected to the same node in $X$: if a node in $X$ has a corresponding value $2x_{j}$, then it has exactly $x_{j}$ neighbors in the lower level of the system. This ensures that once all the nodes $L_{i}$ switch, the new balance of each node in $X$ is exactly as desired. The number of nodes in the gadget can be minimized by placing $\sqrt{\chi}$ nodes $L_{i}$ in the lower level, each with $\sqrt{\chi}$ neighbors in $X$; this way, the overall number of edges going into the set $X$ from the gadget is exactly $\chi$ as required. To ensure that the neighborhood of each $L_{i}$ is dominated by $M$, we choose the size of group $M$ to be $\sqrt{\chi}+1$.

AND gate.

Another ingredient we use is an and gate. As its name suggests, this gadget has $x$ input edges from a set of nodes $X$, and once all nodes in $X$ have switched to the same color (say, white), the gadget triggers a change in another part of the graph.

Note that we could achieve this functionality with a single node, by carefully setting its initial balance such that it switches exactly when all inputs have the desired color. However, and gates are used to “check” the state of specific nodes in the construction, and as such, it is unfortunate that this check also affects the nodes that are being checked: once the node in this simple and gate switches, the balance of all input nodes in $X$ will increase by 2. It would be much better to have a gadget that can perform this task without having any effect on the nodes in $X$.

For this purpose, consider the gadget in Figure 9, which is connected to the nodes in $X$ on the input side and a black node $v$ on the output side. Once all nodes in $X$ are white, node $A$ switches, followed by $B_{1}$ and $B_{2}$, and then by $C$. With $C$ switched, $A$ decides to switch back to its original color white. However, since now both $A$ and $B_{1}$ are white, this finally switches $D$ to black, triggering a change in the output node $v$ (Figure 7). The usefulness of the gadget lies in the fact that once the entire sequence is completed, $A$ is switched back to its original color, and thus the balance of nodes in $X$ is the same at the end of the process as in the beginning.

Join and fork gadgets.

Finally, we need two small gadgets in the construction to fork and join the control sequence at the ends of our main relay chain.

The join gadget of Figure 9 consists of a central node $C$, and an even number of distinct 2-group starter gadgets of alternating color. When an input node $v_{i}$ switches, then so does $A_{i}$ and then $B_{i}$ in the corresponding starter gadget, which also switches $C$ and triggers node $v$. Then when $v_{i+1}$ later switches at some point, the same thing happens to the next starter gadget and $C$ again, only with the two colors swapping roles. Thus if the nodes $v_{1}$, $v_{2}$, … are switched one after another, then each will trigger a new change in the output $v$.

The fork gadget of Figure 9, on the other hand, is responsible for receiving triggers from a given node $v$, and directing the propagation to a new branch every time. This is done through a series of nodes $F_{i}$ of alternating color, each connected to a different output node $v_{i}$, and also to $F_{i-1}$ and $F_{i+1}$. When $v$ first switches in this setting, only $F_{1}$ will become switchable, triggering node $v_{1}$. Similarly, after $v$ is switched for the $i^{\text{th}}$ time, only node $F_{i}$ becomes switchable, and it triggers the $i^{\text{th}}$ branch of output.

Assembling the pieces.

Our final graph construction (shown in Figure 10) has two defining parameters $m$ and $r$. The base of the construction is a chain of $m$ rechargeable relays. The leftmost relay’s base node is the output node in a join gadget of $r$ branches, while the rightmost relay’s base node is an input node in a fork gadget of $r-1$ branches. Finally, for each $i\in\{1,...,r-1\}$, we add a sequence of gadgets (a branch) to connect the $i^{\text{th}}$ output of the fork to the $i+1^{\text{th}}$ input of the join gadget, which is responsible for recharging the relay chain.

Each branch consists of recharging systems connected to our main chain. First let us consider the rechargeable relays where node $U$ is currently white (either the even or the odd ones; relays at positions of the same parity are all in the same state). We first need a recharging system to recharge all these relays, and then we need another system to reset the relays. We need similarly 2 recharging systems for the other half of the relays which are in the opposite color phase.

Finally, we need to force the player to indeed execute these changes on the relays. For that, we insert an and gate after each recharging system, which checks if all switchable nodes have indeed been switched before moving on. The output of the and gate is then used to enable the next recharging systems (or the next input of the join gadget, if this was the last system).

This construction ensures that the player has no other choice than to go through the relay chain, follow the next branch from the fork, recharge and reset all the relays, and start going through the relay chain again. Since the chain consists of $m$ relays and it is traversed $r$ times in this process, the switches in the chain add up to $m\cdot r$ steps altogether.

Of course, one also needs to introduce a starting point (initially switchable node) into the construction. This can be done by replacing $v_{1}$ in the join gadget by a fixed white node.

Now let us consider the number of nodes in the construction. Since rechargeable relays consist of constantly many nodes, the size of the relay chain is $O(m)$. The size of the join and fork gadgets is $O(r)$. Finally, each of the $r-1$ recharging branches consist of constantly many recharging systems, and gates and simple relays; since the latter two have constant size, branch size is dominated by the size of the recharging systems. Each such system is connected to $\frac{m}{2}$ relays, and thus needs to reduce the balance of $O(m)$ nodes by a constant value of 6. This implies that each recharging system needs $O(\sqrt{m})$ nodes.

This shows that we can choose $r=\Theta(\sqrt{m})$ and $m=\Theta(n)$ for our parameters. Our graph then contains $O(m)+O(r)+r\cdot O(\sqrt{m})=O(n)$ nodes, so it is indeed a valid setting with the proper choice of constants.

To investigate runtime, it is enough to consider the switches in the main relay chain. Each of the $\Theta(n)$ relays has a base node that is switched $\Theta(\sqrt{n})$ times, adding up to a total of $\Omega(n^{3/2})$ switches.

Theorem 2**.**

There exists a graph construction with $\Omega(n^{3/2})$ stabilization time in model B.

Note that in the previous construction, whenever any of the base nodes of the relay chain are switchable, there is no other switchable node in the entire graph. This implies that even in the independent benevolent case, the player has no other option than to select this single node, so the number of minimal switches is $\Omega(n^{3/2})$ even if we assume the independent benevolent model.

In fact, one can observe that the construction also ensures that regardless of the choices of the player, the set of switchable nodes is always an independent set at any point in the process. This implies that models C and D are in fact the same in this graph, and thus the lower bound also holds for model D. This then implies the same bound for all the remaining models.

Corollary 3**.**

There is a graph construction with $\Omega(n^{3/2})$ stabilization time in models C–G.

6 Recursive construction

We now briefly outline the modification idea that provides the almost tight lower bound of $\Omega(n^{2-\epsilon})$. A detailed discussion of the construction can be found in Appendix A.

The key idea is to make the recharging systems themselves also rechargeable. Note that once a recharging system has been used, the color of its nodes is exactly that of a recharging system of the opposite color. Thus, if we reset the balance of each node in the system to its initial value, then we can use the system again to recharge the same output nodes repeatedly.

Therefore, we can add a layer of second-level recharging systems to recharge all the original (first-level) systems in the graph after all first-level system have been used (as shown in Figure 11 in the appendix). Recall that decreasing the sum of balances in a set of nodes by $\chi$ requires a recharging system of $O(\sqrt{\chi})$ nodes. We have $\Theta(\sqrt{m})$ first-level systems in our graph, each consisting of $\Theta(\sqrt{m})$ nodes with a balance of $\Theta(\sqrt{m})$ after use; thus to reset each node in these systems to their default balance of 1, with $\chi=\Theta(m^{3/2})$, a second-level system requires $\sqrt{\chi}=\Theta(m^{3/4})$ nodes.

In order to keep the overall number of nodes in second-level systems in $O(m)$, we add $\Theta(m^{1/4})$ distinct second-level systems to our graph. When used, each one of these second-level systems recharges all systems on the first level, which in turn allows us to propagate through the main relay chain $\Theta(m^{1/2})$ times again. Thus together, first and second-level systems allow us to traverse the relay chain $\Theta(m^{1/2})\cdot\Theta(m^{1/4})$ times.

We can continue this technique in a recursive manner. Assume that we have $\Theta(m^{1/(2^{i})})$ distinct $i^{\text{th}}$-level systems in the construction, each consisting of $\Theta(m^{1-1/(2^{i})})$ nodes (which, therefore, all have a balance of $\Theta(m^{1-1/(2^{i})})$ after they have been used). We can then use an $(i+1)^{\text{th}}$-level recharging system to recharge all of these $i^{\text{th}}$-level systems; since we now have $\chi=\Theta(m^{1/(2^{i})})\cdot\Theta(m^{1-1/(2^{i})})\cdot\Theta(m^{1-1/(2^{i})})=\Theta(m^{(2^{i+1}-1)/(2^{i})})$, this requires a next level system of $\sqrt{\chi}=\Theta(m^{(2^{i+1}-1)/(2^{i+1})})$ nodes. In order to keep the nodes in this new level also in $O(m)$, we only add $\Theta(m^{1/(2^{i+1})})$ systems to the $(i+1)^{\text{th}}$ level.

Following this recursive pattern, we obtain a construction that allows us to traverse the main relay chain $\Theta(m^{1/2})\cdot\Theta(m^{1/4})\cdot\Theta(m^{1/8})\cdot...=\Theta(m^{1-\epsilon})$ times altogether. Since the chain consists of $\Theta(m)$ nodes, this leads to a stabilization time of $\Theta(m^{2-\epsilon})$.

With $\Theta(m^{1/(2^{i})})$ recharging systems on the $i^{\text{th}}$ level, the recursive setting allows us to add $\Theta(\log\log m)$ levels until the number of systems on a level decreases to constant. As each level contains $O(m)$ nodes altogether, the resulting graph consists of $\Theta(m\log\log m)$ nodes. This allows for a choice of $m=\Theta(\frac{n}{\log\log n})$, yielding a stabilization time of $\Theta(m^{2-\epsilon})=\Omega(\frac{n^{2-\epsilon}}{(\log\log n)^{2-\epsilon}})$. As we have such a construction for any $\epsilon>0$, the logarithmic factors in this bound can be removed. Similarly to the non-recursive case, this lower bound holds in all of our models, since propagations over the relay chain are still only possible sequentially.

Theorem 4**.**

For any $\epsilon>0$, there exists a graph construction with $\Omega(n^{2-\epsilon})$ stabilization time in models B–G.

Appendix A Discussion of the recursive construction

While the main idea of the recursive construction has been outlined above, there are numerous details worth discussing for completeness.

Given a used recharging system, we need to restore the balance of $M$ and $U$ to 1 in order to obtain a recharging system of the opposite color. Then by triggering $U$ again, we can use the system to recharge the nodes in $X$ once more. Note that on each level, we have used recharging systems in both color variants. Since a second-level system can only be used to recharge nodes of the same color, every time we recharge all the first-level systems, we in fact need two second-level recharging systems, one of each color.

When using one of these second-level systems, it recharges all systems on the first level (of a given color), as shown in Figure 11. This then in turn allows us to propagate through the main relay chain $\Theta(m^{1/2})$ times again. Therefore, with $\Theta(m^{1/4})$ second-level systems in the construction, using only the first two levels, we can already traverse the main chain $\Theta(m^{1/2})\cdot\Theta(m^{1/4})$ times.

Generally, the recursive construction works the following way. Every time when first-level systems have all been used, an extra branch is added to the construction, which uses one of the second-level systems to recharge the entire first level (and does not influence the relay chain). Similarly, whenever we would need such a second-level branch but all of them has been used, a third-level branch is added to recharge all second-level systems, and the required second-level branch is only visited after traversing this third-level branch.

As described in the summary, continuing this in a recursive manner allows us to propagate through the main relay chain $\Theta(m^{1-\epsilon})$ times for any $\epsilon>0$. If there are $\Theta(m^{1/(2^{i})})$ distinct $i^{\text{th}}$-level systems in the graph, and each consist of $\Theta(m^{1-1/(2^{i})})$ nodes (which hence all have a balance of $\Theta(m^{1-1/(2^{i})})$ after they have been used). An $(i+1)^{\text{th}}$-level recharging system that recharges all these will then have $\chi=\Theta(m^{1/(2^{i})})\cdot\Theta(m^{1-1/(2^{i})})\cdot\Theta(m^{1-1/(2^{i})})=\Theta(m^{(2^{i+1}-1)/(2^{i})})$, and therefore needs to consist of $\sqrt{\chi}=\Theta(m^{(2^{i+1}-1)/(2^{i+1})})$ nodes.

As mentioned, we add $\Theta(m^{1/(2^{i+1})})$ such systems in order to keep the nodes on the $(i+1)^{\text{th}}$ level in $O(m)$. The whole recursive construction allows us to go through the main relay chain $\Theta(m^{1/2})\cdot\Theta(m^{1/4})\cdot\Theta(m^{1/8})\cdot...$ times altogether. If the number of levels go to infinity with $m$ increasing, then for any $\epsilon>0$, there is an $m$ large enough that the number of relay chain traversals is at least $\Theta(m^{1-\epsilon})$. With the length of the relay chain being $\Theta(m)$, this implies a stabilization time of $\Theta(m^{2-\epsilon})$.

With an analysis of the constants in the process, one can show that the coefficient in each factor of $\Theta(m^{1/2})\cdot\Theta(m^{1/4})\cdot\Theta(m^{1/8})\cdot...$ can be chosen to be at least 1, and thus these constant do not add up to dividing logarithmic factors when taking the product. However, this is in fact unnecessary, as any such logarithmic factor could also be removed simply by a smaller choice of $\epsilon$.

If we have $\Theta(m^{1/(2^{i})})$ recharging systems on the $i^{\text{th}}$ level, this setting allows us to add $\Theta(\log\log m)$ levels until the number of systems on a level decreases to a constant value.

Now let us analyze the number of nodes in the graph. On each level, the systems contain $\Theta(m)$ nodes altogether, so the number of nodes in recharging systems adds up to $\Theta(m\log\log m)$ over all levels. The size of the graph is dominated by these nodes. The number of branches controlling first-level systems is $\Theta(m^{1/2}\cdot m^{1/4}\cdot m^{1/8}\cdot...)=O(m)$, the number of branches controlling second-level systems is only $\Theta(m^{1/4}\cdot m^{1/8}\cdot...)=O(m^{1/2})$, and so on, the number of $i^{\text{th}}$-level branches is $O(m^{1/2^{i-1}})$. Summing these up, the number of branches altogether is still $O(m)$. Apart from recharging systems, each branch contains constantly many nodes only (in the form of simple relays, and gates, and the corresponding parts of the fork and join gadgets). This shows that the number of nodes outside of the recharging system is only $O(m)$ altogether, thus the number of nodes in the entire graph is indeed $\Theta(m\log\log m)$.

This validates our choice of $m=\Theta(\frac{n}{\log\log n})$, confirming that the stabilization time of the recursive construction is indeed $\Omega(\frac{n^{2-\epsilon}}{(\log\log n)^{2-\epsilon}})$. Since this bound holds for any $\epsilon>0$, we can easily remove the logarithmic factors: a lower bound of $\Omega(n^{2-\epsilon})$ follows from the same construction for any $\widehat{\epsilon}<\epsilon$.

It only remains to discuss some details of the construction. Recall that in addition to the group $M$, the balance of node $U$ also has to be reset between two uses of a recharging system; however, we did not point this out when calculating the necessary size of systems, since besides $M$, a single extra node does not affect the magnitude. Earlier, we have noted that the recharging systems on a certain level consist of two classes of systems of different color; observe that the next level systems that recharge the groups $M$ in one class can simultaneously be used to also recharge the nodes $U$ in the other class. Alternatively (for simpler analysis), we can add an extra recharging system (of the same size) on each branch in order to separately recharge the nodes $U$ on the level below.

Finally, note that in this recursive setting, recharging systems are slightly modified in the sense that they have multiple input nodes from multiple different branches, each connected to node $U$. However, this does not modify the behavior of $U$ as long as its initial balance is readjusted to 1. This also requires a minor modification in the simple relays that are used as input nodes, since relays generally assume that their output node never switches before the relays themselves are triggered. This can be resolved by using a modified relay where the base node has an initial balance of 3, and thus it is enabled by two distinct simple relays on the branch.

Appendix B Detailed analysis of gadgets

Here we provide a more detailed description of the gadgets, and also comment on their behavior and their use in the construction.

Simple relay.

The construction and behavior of the simple relay has already been described above. One thing to note is that in our construction, simple relays are always used only once: after node $B$ switches, propagation never returns to the same part of the graph again, and thus node $B$ will remain unswitchable for the rest of the process.

While we mostly use this original version of the gadget, we occasionally need relays that have multiple output nodes instead of just one. Note that this only requires a simple modification: besides connecting $x$ extra (black) output nodes to node $B$, we also need to add $x$ fixed (white) nodes in order to keep the initial balance of $B$ unchanged.

As mentioned, chains of simple relays are mostly used to connect more complex gadgets in our construction. Note that depending on whether the input and output nodes in these gadgets are supposed to have the same or different initial colors, we only need a chain of length 1 or 2 for this, respectively.

Rechargeable relay.

In a rechargeable relay, node $B$ is connected to an upper node $U$ instead of a fixed node. Node $U$ is connected to a group $C$ of two nodes, which is further connected to nodes $R_{1}$, $R_{2}$. Initially, $C$ has the opposite color as $B$ and $U$, and one of $R_{1}$ and $R_{2}$ is white, the other is black. Node $B$ has the same external neighbors as a simple relay. The recharge nodes can both have any set of external neighbors as long as their initial balance is 3 with $C$ ignored. With $C$ also considered, the initial balance of $R_{1}$ and $R_{2}$ is then 1 and 5, respectively.

Note that since $R_{1}$ and $R_{2}$ have opposite colors, this recharging process can always be executed on a used relay through either $R_{1}$ or $R_{2}$, depending on the current color of the nodes. We only need to select the recharge node that has the current color of $U$, and switch 3 of its neighbors (to $U$’s current color) for the recharging step, and then switch 3 of its neighbors (to the opposite color) for the resetting step.

Recharging system.

In a basic recharging system, the node $U$ is connected to the input node $v$, the group $M$, and to $\sqrt{n}+1$ fixed white nodes. The middle level group $M$ has a further edge to all nodes $L_{i}$, and is balanced by $\sqrt{m}$ fixed black nodes. Finally, each node $L_{i}$ has $\sqrt{m}$ distinct neighbors in $X$, and thus each node in $X$ is connected to exactly one lower-level node. For convenience, we assume that $m$ is a square number.

A generalized recharging system is almost identical to this, except for the nodes $L_{i}$ occasionally being connected to the same node. The connections between the lower level and $X$ are not directly specified: we are free to choose which of the nodes $L_{i}$ to connect to a specific node in $X$. Note, however, that the gadget design implicitly assumes that $x_{j}\leq\sqrt{\chi}$ for all nodes in $X$. This is naturally satisfied whenever we use the gadget in our constructions, since we always have $x_{1}=x_{2}=...=x_{m}$ with $|X|>x_{j}$. Also note that for convenience, we assume $\chi$ to be a square number.

Nodes in the upper and lower levels are initially white, while $M$ and the input node $v$ are initially black. The nodes $X$ may assume any color, and also may switch multiple times before the recharging system is activated. However, the graph construction ensures that at the time when the gadget is activated (that is, when $v$ switches), all nodes in $X$ are currently colored black (i.e., we indeed use the system on rechargeable relays that can currently be recharged). The gadget design ensures that $U$ and $M$ have an initial balance of 1, while the nodes $L_{i}$ have a balance of 1 at least, depending on the current color of their neighbors in $X$.

AND gate.

The and gate consist of 7 nodes, three of which form a group ($C$). The input nodes of $X$ are connected to node $A$, which is further connected to all other nodes in the gadget ($B_{1}$, $B_{2}$, $D$ and the group $C$). Nodes $B_{1}$ and $B_{2}$ are also connected to group $C$, node $B_{1}$ has an edge to node $D$, and node $D$ is connected to some external black node $v$ on the output side. Furthermore, $A$, $B_{1}$ and $B_{2}$ have $x+1$, $4$ and $3$ fixed black neighbors, respectively.

One can check that each node has a positive balance as long as there exists a black node in $X$. Node $A$ gets a balance of $x-1$ from the nodes within the gadget, so it is not switchable unless all nodes in $X$ are white. Nodes $B_{1}$, $B_{2}$, $C$ and $D$ all have an initial balance of 1.

After the gadget reaches its final stage (see Figure 7), no node in the gadget can ever change again, regardless of the states of $X$ or $v$.

Note that for the described behavior of the gadget, we also need the fact that none of the nodes in $X$ switch between the first and second switching of $A$. The switching of $A$ only increases their balance (temporarily), so this is guaranteed if other neighbors of nodes in $X$ do not interfere with the process. In the construction, we only use and gates this way: whenever a node $A$ becomes switchable in a gate, then that is the only switchable node in the entire graph, so no other nodes will switch until the propagation reaches $v$.

As long as this condition is fulfilled, we can connect any number of and gates on a given node of the graph without affecting its behavior; we only have to make sure that we also add fixed node neighbors to restore the node’s balance to the original value.

Join gadget.

A join gadget consists of $p$ distinct starter gadgets, where $p$ is assumed to be an even number. Each starter gadget consists of two groups $A_{i}$ and $B_{i}$, both of size 2 (with $i\in\{1,2,...,p\}$). The two groups are connected to each other, and $A_{i}$ has a further edge to the input node $v_{i}$, and two fixed nodes of the same color as its own. Finally, all $B_{i}$ are connected to a central node $C$, which is in turn connected to an output node $v$. Node $C$ also has two further fixed black connections.

Initially, $A_{i}$ for odd $i$ values, $B_{i}$ for even $i$ values, $v_{i}$ for even $i$ and node $C$ are colored white; the remaining nodes are colored black. Nodes $A_{i}$ have an initial balance of 1, nodes $B_{i}$ have an initial balance of 1 or 3 (depending on parity), and $C$ has an initial balance of 3.

As described, the switching of $v_{i}$ triggers a switch in $A_{i}$, then $B_{i}$, then $C$ and finally $v$. After $v$ switches, the balance of $C$ returns to its initial value of 3, so the switching of the next input node will trigger the same process through the next starter gadget.

Fork gadget.

The fork gadget consist of $q$ nodes $F_{1}$, …, $F_{q}$, where we assume $q$ to be an odd number. All $F_{i}$ are connected to the same input node $v$, and each to a distinct output node $v_{i}$. They are also linked to each other, with $F_{i}$ connected to $F_{i+1}$ for all $i\in\{1,2,...,q-1\}$. Also, node $F_{1}$ and $F_{q}$ have a fixed neighbor colored black and white, respectively (imitating the role of the nonexistent nodes $F_{0}$ and $F_{q+1}$). Finally, each $F_{i}$ has a further fixed neighbor of its original color. Initially, $F_{i}$ is colored black for odd $i$ and white for even $i$ values.

The balance of $F_{1}$ and all white $F_{i}$-s is originally 1 in this setting, while the balance of black $F_{i}$-s (except for $F_{1}$) is 3. Hence when $v$ first switches, only $F_{1}$ will become switchable (and switching it will propagate on through $v_{1}$). The next time $v$ switches, it switches back to white; with $v$ and $F_{1}$ both white, $F_{2}$ can now switch too. The pattern continues all the way to $F_{q}$: as $F_{i-1}$ has already been switched before, as soon as $v$ switches back to the color of $F_{i}$, $F_{i}$ becomes switchable, too, enabling propagation on the next branch. After $v_{i}$ switches (and remains that way), $F_{i}$ is not switchable anymore, since $v_{i}$, $F_{i-1}$ and its fixed neighbor all have the opposite color.

Note that since each switching $F_{i}$ increases the current balance of $v$ from 1 to 3, we need to switch two neighbors of $v$ in each turn to make $v$ switchable again. This is exactly what happens when $v$ is the base node of the rightmost relay in the chain: between every consecutive switches of $v$, we switch both node $U$ (by the recharging step) and node $v_{L}$ (by propagation through the chain) in the relay, and thus $v$ becomes switchable again.

Note that since it is connected to the fork gadget, the rightmost rechargeable relay in the chain is a modified one in the sense that its base node has not one, but $q$ right-side neighbors, colored in alternating fashion. However, this fact does not change its behavior at all. The initial balance of the base node is still 1, and every time after $v$ switches, it has one of its neighbors $F_{i}$ switching in the opposite direction. That has exactly the same effect as if the right neighbor was simply a subsequent relay in the chain, triggered by $v$.

On the whole construction.

For convenience, we assume in the construction that both $m$ and $r$ are even numbers.

Recharging systems and and gates, as all other gadgets, are available in two color variants; in the overview of the construction, we did not discuss which variant is used in which case. However, the current state of each relay in each round is straightforward to calculate, so the necessary color of all recharging systems and and gates can easily be determined.

Also, we have seen that and gates are used to ensure that the given recharging or resetting operations have completely been executed. In order to achieve this, in case of the first systems (which recharge relays), the input edges of the gates can be connected to the upper nodes of the corresponding relays, since that is the last node to switch in the sequence. In case of the systems that reset relays, the aim is only to switch the corresponding recharge node of the relay, so we can connect the gates to the recharge nodes.

However, as each and gate belongs to a certain branch of the construction, we also have to ensure that the and gate is only activated when the propagation reaches this branch, and stays inactive as long as previous branches are being processed. Therefore, besides the specified nodes in the relays, the final input node of the and gate is the node which was used to enable the recharging system in question (node $v$ of Figure 5(a)). This way, the gates ensure that after the recharging system is activated, propagation only continues if all the resulting switches were executed.

Generalization to $\omega(1)$ colors

One can observe that in the construction of Section 5, except for nodes $A$ in the and gates, all nodes in the graph have a degree of $O(\sqrt{n})$. We can slightly modify the construction and replace each of these and gates with two levels of such gates, with $\Theta(\sqrt{n})$ distinct gates on the first level (each with $\Theta(\sqrt{n})$ input nodes), and a final gate that connects the outputs of these first-level gates. This gives us a construction with the same properties, but a maximum degree of $O(\sqrt{n})$.

This allows us to generalize the lower bound of $\Omega(n^{\frac{3}{2}})$ to the case of not only $O(1)$, but up to $O(\sqrt{n})$ colors. The technique for this is the same as in the case of $O(1)$ colors: we add a multipartite graph colored with the additional colors, and connect each of its nodes to each original node. With $\Delta=O(\sqrt{n})$ established, it suffices to have $\Theta(\sqrt{n})$ nodes in each of the color classes. Therefore, using only $\Theta(n)$ additional nodes, we can extend the graph by a multipartite graph on $\Theta(\sqrt{n})$ color classes, each consisting of only $\Theta(\sqrt{n})$ nodes.

Appendix C Notes on simulations

Due to its complexity, we have also verified the correctness of the non-recursive construction of Section 5 through implementing it and running a simulation of the minority process. Note that in general, it is difficult to simulate a minority process in a benevolent model, since all possible switching sequences would have to be examined to find the one with the smallest number of steps.

Fortunately, the task is significantly simpler in our case, due to the properties of the construction. The key observation in our graph is that whenever propagation is split into multiple parallel threads (that is, when there are multiple switchable nodes at the same time), then propagation on any of these threads does not influence propagation on other threads at all. Specifically, the nodes on separate threads do not have common neighbors except for the beginning and end of such threads; i.e. when a switching node splits the propagation to multiple threads, or when threads are joined in an and*-like* fashion, meaning that a common neighbor only becomes switchable when propagation has been finished in all of the threads. This implies that throughout the process, these threads can be handled completely independently from each other, and the order in which they are processed is irrelevant. Note that this is also the property of the construction which ensures that the set of switchable nodes is an independent set in any state.

If we exploit this property, the process can be simulated easily by always choosing an arbitrary one of the switchable nodes in the graph, knowing that the choice of nodes will not influence the outcome. To verify correctness in such a simulation, we only have to check that in each step of the process, the set of nodes that become switchable is exactly the set of nodes determined by the analysis. Note that the opposite does not happen in our construction: the switching of a node never makes another switchable node unswitchable (this would also contradict the property that switchable nodes form an independent step in any state).

When examining concrete instances of our construction, we used the parameter $r$ as the input to determine the size of the instance. For a given input value of $r$ (always an even number), we have chosen $m=2\cdot(r-1)^{2}$, which fits our preconditions on both magnitudes and parity. All other details of the construction are already determined above; the only additional thing to note is that whenever different gadgets are connected through a chain of simple relays, we always use the smallest possible such chain in the implementation.

The simulations verified that the analysis of the construction is correct, and thus stabilization time is indeed $\Omega(n^{3/2})$ in model B. Table 1 illustrates the number of steps for some choices $r$, along with the resulting number of nodes in the construction. One can observe that the number of steps indeed grows superlinearly in $n$.