Sandpile Prediction on Undirected Graphs

TL;DR

The paper studies the sandpile prediction problem on undirected graphs, aiming to determine termination and compute the terminal configuration efficiently. For structured graphs, it achieves $O(n\log n)$ time on trees, $O(n)$ on paths, and fast linear-time results on cliques and $O(n\log^2 n)$ on pseudotrees through a bottom-up/bottom-up firing-number approach and splittable binary search trees. For general graphs, it delivers a simulation-based algorithm with a favorable $\log N$ dependency and introduces a reduction framework via vertex removal to decompose problems into tractable subinstances, with strong performance on regular, expander, and hypercube graphs. A central contribution is the data-structure toolkit built around splay trees and a pop-up mechanism to track firing counts and delta contributions in near-linear time, enabling scalable handling of large chip counts and complex graph topologies. These results advance practical sandpile prediction by moving beyond simulation to direct computation of firing numbers and offer broader applicability to load balancing and distributed dynamics on networks.

Abstract

The $\textit{Abelian Sandpile}$ model is a well-known model used in exploring $\textit{self-organized criticality}$. Despite a large amount of work on other aspects of sandpiles, there have been limited results in efficiently computing the terminal state, known as the $\textit{sandpile prediction}$ problem. On graphs with special structures, we present algorithms that compute the terminal configurations for sandpile instances in $O(n \log n)$ time on trees and $O(n)$ time on paths, where $n$ is the number of vertices. Our algorithms improve the previous best runtime of $O(n \log^5 n)$ on trees [Ramachandran-Schild SODA '17] and $O(n \log n)$ on paths [Moore-Nilsson '99]. To do so, we move beyond the simulation of individual events by directly computing the number of firings for each vertex. The computation is accelerated using splittable binary search trees. In addition, we give algorithms in $O(n)$ time on cliques and $O(n \log^2 n)$ time on pseudotrees. On general graphs, we propose a fast algorithm under the setting where the number of chips $N$ could be arbitrarily large. We obtain a $\log N$ dependency, improving over the $\mathtt{poly}(N)$ dependency in purely simulation-based algorithms. Our algorithm also achieves faster performance on various types of graphs, including regular graphs, expander graphs, and hypercubes. We also provide a reduction that enables us to decompose the input sandpile into several smaller instances and solve them separately.

Figures (4)

• Figure 1: A sandpile instance with sinks. The sinks in the figure are all marked as blue.
• Figure 2: A firing operation on a full vertex. The chips transferred to a sink vertex are ignored, and no firing operation can happen on a sink vertex.
• Figure 3: A vertex removal with $T=\{u,v\}$. The blue vertices are sinks, and the gray vertices are normal vertices.
• Figure 4: This figure shows the life cycle of $D_u$ where arrows describe the calling order and blocks contain the current maintained information. Blue ones are called in $\textsc{SolvePartial}(u,G,\sigma')$ and red ones are in $\textsc{SolveComplete}(u, G)$.

Theorems & Definitions (97)

• Theorem 1.0: Sandpile Prediction on Trees
• Theorem 1.0: Sandpile Prediction on Paths
• Theorem 1.0: Sandpile Prediction on General Graphs
• Theorem 2.1: bjorner1991chip
• Definition 2.2: Firing number
• Definition 2.3: Local terminal configuration
• Lemma 2.4: Unique local terminal configuration
• Definition 2.5: Local finalize operation
• Lemma 2.6
• Lemma 2.7