A chip-firing variation and a new proof of Cayley’s formula

We introduce a variation of chip-ﬁring games on connected graphs. These ‘burn-off’ games incorporate the loss of energy that may occur in the physical processes that classical chip-ﬁring games have been used to model. For a graph G = ( V, E ) , a conﬁguration of ‘chips’ on its nodes is a mapping C : V → N . We study the conﬁgurations that can arise in the course of iterating a burn-off game. After characterizing the ‘relaxed legal’ conﬁgurations for general graphs, we enumerate the ‘legal’ ones for complete graphs K n . The number of relaxed legal conﬁgurations on K n coincides with the number t n +1 of spanning trees of K n +1 . Since our algorithmic, bijective proof of this fact does not invoke Cayley’s Formula for t n , our main results yield secondarily a new proof of this formula.


Introduction
Chip-firing games on graphs by now enjoy a rich literature.This is due not only to their surprising array of mathematical connections but also to their utility in modeling certain kinds of physical systems.For the former, we find ties, e.g., to discrepancy theory [21], the Tutte polynomial [16], critical groups of graphs [5], G-parking functions [3], and stochastic processes [11].For the latter, these games connect to earthquakes [1], sandpiles [10], traffic [19], and the brain [22].
This article continues the published account of [20]-initiated in [15]-where we study a variant of chip-firing in which all games have finite length.These 'burn-off' games incorporate the loss of energy that may occur in the physical processes that classical chip-firing games have been used to model.Whereas, classically, when a node v 'fires', it sends one chip to each of its neighbors, our game modifies this action by additionally eliminating one chip at v; see Section 1.1 for a precise definition of these games.
It's worth noting the analogy between burn-off games and graph pebbling, sometimes used in modeling the movement of expendable resources.Here, 'pebbles' are placed on the nodes of a graph, then moved around subject to the condition that if v contains (at least) two pebbles, then one of them may be moved to a neighbor of v at a cost of permanently removing another from v; see [14] for an early pebbling survey and [13] for a dynamic record of related references.Though we don't make use of the pebbling/burn-off game connection, the recent explosion in pebbling research suggests that our chip-firing approach could also prove to be fruitful.
Björner et al. [7] are generally credited with initiating the study of chip-firing games on general (connected, undirected) graphs, although a subset of these authors in [6] points to antecedents in [11] and [21].It's historically interesting that an early result for general graphs, in [23], predates the purported initiator [7].We offer some of this as evidence that a thorough literature review is beyond our scope and instead point the reader to [17] for a chip-firing survey, to [12] for a textbook account of the algebraic aspects of chip firing, and to [3] for a few more recent related citations.
This paper is organized as follows.Section 2 presents our results for general graphs, while Section 3 focuses on complete graphs.After characterizing the 'relaxed legal' chip configurations ( §2.1), we give an algorithm to check a configuration for 'legality' ( §2.2) and then prove that the set of 'legal' configurations is up-closed in the poset of all configurations on a fixed graph ( §2.3).In §3.1, we enumerate the 'legal' chip configurations for complete graphs K n .The number of relaxed legal configurations on K n coincides with the number t n+1 of spanning trees of K n+1 .Since our algorithmic, bijective proof of this fact ( §3.2) does not invoke Cayley's Formula for t n , our results in Section 3 yield a new proof of this formula.
We are not the first authors to observe a connection between chip-firing games and spanning tree enumeration.Indeed, Biggs and Winkler [4] present bijections between their set of 'critical' configurations and the set of trees spanning their underlying graph.Benson et al. [3], who "present the[ir] article in an expository self-contained form", provide somewhat of a related mini-survey, including a citation to [4].(Their scope also includes connections with parking functions and sandpile models.)Even more recently, Baker and Shokrieh [2] further explore these latter connections and obtain a bijective proof of the Matrix-Tree Theorem.We ourselves, in [15], have even touched on the chip-firing/spanning tree connection.Nevertheless, since burn-off games comprise a non-trivial variation of chip-firing, it seems worthwhile to illuminate this connection in the new context.

Notation and terminology
We generally follow 'standard' graph theory conventions and make attempts to produce a self-contained treatment of our results.For any basics we may have omitted, we point the reader to [8].

Description of the game
The 'game board' is a connected graph G = (V, E).For each node v ∈ V , we begin with a nonnegative number C(v) of chips on v; the function loosely speaking, v sends a chip to each of its neighbors.A configuration in which no node is live is relaxed.Starting with a configuration C on G, a chip-firing game is played as follows.If there exists a live node, fire it; this constitutes a turn of the game.The game proceeds in turns, wherein live nodes are successively chosen and fired.If, at any point in this process, no node is live, the game ends, its length being the number of turns taken starting from C until the end.If C is relaxed, the game has length zero; otherwise, the process of passing from C through a C and eventually to a relaxed configuration on G is relaxing C. Björner et al. [7] took each k v to be the minimum natural value deg G (v).They observed that some chip-firing games may be of infinite length.For example, if the total number of chips on G exceeds twice the number of edges, then, by the pigeonhole principle, one can always find at least one live node.This paper also established, among other results, that if the total number of chips on G is less than |E|, then every chip-firing game on G is of finite length.
Another way to ensure finite game lengths is to decrease the total number of chips at each turn.A 'burn-off game' differs from the chip-firing game of [7] in two ways: first, we take each k v , for v ∈ V , to be deg G (v) + 1; second, we modify the firing rule (1) to notice that when v is fired, one of its chips effectively vanishes.A burn-off game is a chip-firing game with the adjusted critical numbers and following the modified firing rule (2).The game just defined is equivalent to the 'dollar game' of Biggs [5] in the particular case when his 'government' node is adjacent to every other node in the underlying graph; see also [4].In our burn-off games, we call a node v supercritical when C(v) takes a value larger than deg G (v).
During a chip-firing or burn-off game, chips from the neighbors of a node v may cause v to become supercritical.If, during one of these games, several nodes simultaneously become live in this fashion, one may wonder how to decide which node to fire next.The paper [7] established that for the chip-firing game described above, this decision has no bearing on the game length or the final chip configuration.Using a similar approach, this paper's second author showed in [20] that the analogous result for burn-off games also holds.

Reverse-firing and legal configurations
Our primary purpose is to study the configurations that can arise in the course of iterating a burn-off game, i.e., incrementing C at a chosen node, relaxing the resulting configuration, and repeating these two steps indefinitely.Of course, the set of configurations that arise in this way depends on the initial configuration.Though it may seem natural to begin with the empty configuration, C ≡ 0, this configuration will never recur during a burn-off game sequence because each firing event redistributes chips to the neighbors of the firing node.
Instead, we seek to begin with a configuration typical of those that will be encountered in a long sequence of burn-off games.Here, we follow [1], wherein the authors investigated an earthquake model based on chip-firing on a grid.
We define a configuration to be supercritical if every node is supercritical.In the spirit of [1], we shall focus on the configurations that can result from relaxing a supercritical configuration.To understand these, it is instructive to consider what happens when a burn-off game is played in reverse.
A reverse-firing game is defined so as to undo the firing rule of the chip-firing game under consideration.Thus, for burn-off games, considering (2), we see that to reverse-fire a node v (each of whose neighbors u of necessity satisfies C (u) ≥ 1) means to modify C to a configuration C such that Informally, starting from C , when a node v reverse-fires, it pulls one chip from each of its neighbors and one out of thin air.Now a configuration C is legal if there exists a reverse-firing sequence starting with C and ending with a supercritical configuration.A legal configuration containing no live nodes is a relaxed legal configuration.Notice that the empty configuration is relaxed but not legal, while the configuration with We leave it as an (easy) exercise to construct a configuration that is neither legal nor relaxed.
2 Results for general graphs

Characterizing relaxed legal configurations
Our first result characterizes the relaxed legal configurations on general (connected simple) graphs.Its statement uses N G to denote the 'earlier neighbor set'; i.e., given an ordering Proof: Suppose that we have a relaxed legal configuration C. Since C is legal, it can be reverse-fired into a configuration where all nodes are supercritical.Further, since C is relaxed, no node is supercritical.Thus, in any reverse-firing sequence that certifies the legality of C, all nodes must reverse-fire (this being the only way for a node to gain chips during a reverse-firing game).Consider such a reverse-firing sequence.
Listing only the first time each node reverse-fires during the game, suppose that they are reverse-fired in the order w 1 , w 2 , . . ., w n .Any given node w j reverse-fires only after each node w 1 , w 2 , . . ., w j−1 reverse-fires at least once.Each of these nodes which is a neighbor of w j takes a chip from w j when it reverse-fires.Thus, we must have C(w j ) ≥ |N G (w j )|, and (4) follows since j was arbitrary.
To establish the converse, suppose that it is possible to relabel the nodes w 1 , w 2 , . . ., w n so that (4) holds.We claim that reverse-firing the nodes in increasing subscript order results in each node increasing its chip-count by one.
Consider a node w j for some j with 1 ≤ j ≤ n, and define s := |N G (w j )|.Each of the s nodes in N G (w j ) reverse-fires before w j does, and each reverse-firing will pull one chip from w j .This leaves C(w j ) − s ≥ 0 chips on w j .When w j reverse-fires, it pulls a chip from each of its deg(w j ) neighbors and receives one extra chip for the reverse burn-off.Finally, the nodes w j+1 , . . ., w n reverse-fire, and each neighbor of w j in this set (say there are of these) pulls a chip from w j .Therefore, after each node has been reverse-fired once, the number of chips on w j is decreased by s + = deg(w j ) and increased by deg(w j ) + 1 (while never becoming negative), for a net increase of one, as claimed.
Notice that reverse-firing each node once, as described in the preceding paragraph, preserves (4).Thus, this process may be repeated until all nodes become supercritical.That is, if t := max v∈V {deg(v) − C(v)}, then repeating the process t + 1 times will result in every node v containing at least deg(v) + 1 chips.Therefore, the original configuration was legal. 2

Checking the legality of a configuration
Given a configuration C (not necessarily relaxed) on a graph G, we may check if C is legal using the following algorithm.The proof of its efficacy leans on Proposition 2.1.

Algorithm 2.2
INPUT: a graph G = (V, E) and a chip configuration C : V → N on G OUTPUT: an answer to the question 'Is C legal?' In the proof of Proposition 2.4, which asserts that Algorithm 2.2 works correctly, we also need the following lemma.For a configuration C : V (G) → N on G and a subgraph H of G, the notation C| V (H) as usual denotes the configuration restricted to H.
Proof: By Proposition 2.1, the legality of C on G implies that it is possible to relabel the nodes w 1 , . . ., w n so that each w i (considered in G) contains at least as many chips as it has neighbors with smaller subscripts.In H, a node w i may have fewer such neighbors, but it certainly cannot have more.Thus, Second, we show that if Algorithm 2.2 proceeds until all nodes are deleted, then C is legal.Suppose we relabel the nodes so that the algorithm's deletion order is u n , u n−1 , . . ., u 1 .For n ≥ j ≥ 1, let G * (u j ) be the subgraph of G remaining just before the deletion of u j .For u j to be deleted from G * (u j ) by Algorithm 2.2, it must contain at least as many chips as it has neighbors in G * .Thus, the relabeling u n , u n−1 , . . ., u 1 that gives the deletion order also suffices to show that (4) holds for C. Therefore, C is legal. 2

The poset of legal configurations
In the next section, we shall find it useful to consider the set B of all configurations on a fixed graph G as a poset (B, ) whose ordering relates to the numbers of chips on the nodes of G as follows: for P, Q ∈ B and ≤ the usual (total) ordering on N, let Proposition 2.5 If P is a legal configuration, then any Q with P Q is also legal.
Proof: We clearly need only consider those configurations Q with P ≺ Q (i.e., P Q but P = Q).Such a Q has at least as many chips on any given node v as does P , and since P ≺ Q, there exists a node x with P (x) < Q(x).Starting from the configuration P , add one chip to x to create a new configuration P .
Since P is legal, there exists a reverse-firing sequence that results in a supercritical configuration.'Freeze' the new chip on x, and carry out the same reverse-firing sequence starting with P .The frozen chip will not affect the reverse-firing game, and once P is reverse-fired to a supercritical configuration, the chip may be 'thawed'.The resulting supercritical configuration shows that P is legal.
If P = Q, the assertion is proved; if not, the argument above can be repeated with P in the role of P . 2

Results for complete graphs
After specializing Proposition 2.1 to complete graphs, we enumerate certain legal configurations on these graphs.Then we present a pair of algorithms that give a one-to-one correspondence between relaxed legal configurations on K n and spanning trees of K n+1 .These algorithms provide our new proof of Cayley's Formula (see [9] or, e.g., [8]).

Enumerating legal configurations
Lemma 3.1 A relaxed configuration C : V → N on K n is legal if and only if it is possible to relabel the nodes w 1 , w 2 , . . ., w n so that Proof: We simply observe that condition ( 5) is equivalent to condition (4) because in a complete graph, each The following formulation of Lemma 3.1 is needed in Section 3.2.
Corollary 3.2 A relaxed configuration C : V → N on K n is legal if and only if for each ∈ {1, 2, . . ., n}, at least n − nodes contain at least chips.
Now we develop a formula for L(K n ), the number of relaxed legal configurations C on K n .We first count the legal (but not necessarily relaxed) configurations; here our determination includes a parameter to bound the maximum value of C(v) for v ∈ V := V (K n ).For n ≥ 1 and m ≥ n − 1, let L n,m be the number of legal configurations satisfying C(v) ≤ m for each v ∈ V .For convenience, we also define L 0,m := 1 for all m ≥ 0. The proof of the next result makes implicit use of Proposition 2.5.Theorem 3.3 For all n ≥ 1 and m ≥ n − 1, we have Proof: We proceed by induction on n and m.Since L 0,m := 1, this satisfies (6).For each m ≥ 0, we include in our base case L 1,m , which counts the number of legal configurations on K 1 .By ( 5), the single node must contain at least zero chips.Thus, the number of chips occupying this node lies in the set {0, 1, . . ., m}; so L 1,m = m + 1, which satisfies (6).Finally, we observe that for n ≥ 2, the symbol L n,n−2 enumerates the legal configurations in which all n nodes contain at most n − 2 chips; since (5) requires C(w n ) ≥ n − 1, we have L n,n−2 = 0 for all n ≥ 2. This satisfies ( 6), and we include it in our base case.Now fix n ≥ 2 and m ≥ n − 1, and assume that ( 6) is valid for each L n−k,m−1 with k ∈ {0, 1, . . ., n}.To determine L n,m , we let k ∈ {0, 1, . . ., n} count the number of nodes containing exactly m chips; there are n k ways to choose these k nodes.Consider the configuration on the remaining n − k nodes of K n .Focusing on these nodes, we know from Lemma 2.3 that C| V (K n−k ) must be legal on K n−k , with at most m − 1 chips on each node.Since the number of such configurations is Now we apply our inductive hypothesis to simplify the sum: induction gives the result.2 Since L(K n ) = L n,n−1 , we obtain the immediate Thus, in step (10), each score is given to exactly one node.Therefore, "the node" selected in step ( 9) is indeed unique.
Proof that A is well-defined: Algorithm 3.6 will fail if, during any iteration, M i is empty, because no further edges can then be added in step (9).We demonstrate below that no M i is ever empty, but assume for now that this is true.Step ( 9) adds an edge from each v k ∈ M i to a node that is already part of a single growing component of the subgraph of K n+1 being constructed.The algorithm continues until all nodes of K n+1 are members of some M i , so all nodes of K n+1 are eventually connected to the growing component.Note also that exactly n edges are created by step ( 9), one for each node except v 0 .A spanning connected subgraph (of an (n + 1)-node graph G) with n edges is necessarily a spanning tree of G; thus, the algorithm certainly constructs a spanning tree of K n+1 .It remains to prove that no M i is empty.We proceed by induction.It is clear in step (3) that M 0 is not empty; suppose that M i−1 is not empty for some fixed i > 0. (By definition of M i−1 , it is clear that M i−2 is also not empty.)As Algorithm 3.6 proceeds, the scores assigned to the nodes in step (10) descend from n − 1.We must show that at least one value of C(v k ), for 1 ≤ k ≤ n, is large enough to equal the score of one of the nodes in M i−1 .This will guarantee that M i contains at least one element.
When, in step ( 8), the nodes are checked to see if they will be members of M i , the algorithm inspects the scores assigned to the nodes in M i−1 (our induction hypothesis ensures that there are nodes in M i−1 to inspect).These scores were assigned (during the preceding iteration) in the following order: Thus, the lowest score assigned to a node of Since C is a legal configuration on K n , we know that for each ∈ {1, 2, . . ., n}, at least n − nodes contain at least chips (see Corollary 3.2).Substituting n − Q i for , we see that our legal configuration C is such that at least Q i nodes contain at least n − Q i chips.
Since Q i − 1 nodes have been assigned scores (we subtract 1 because v 0 ∈ V (K n )), there is at least one unassigned node v k containing at least n − Q i chips (i.e., C(v k ) ≥ n − Q i ); this number is at least as big as the lowest score found in M i−1 .We also know that C(v k ) is one of the scores assigned to a node in M i−1 , for if C(v k ) exceeded all of those scores, then v k would have already been assigned to an earlier sequence.It follows by induction that no M i is empty and, by our earlier remarks, that A is well-defined. 2 Proof that A is an injection: Let C : V (K n ) → N and C * : V (K n ) → N be two distinct relaxed legal configurations on K n .Let A(C) = T and A(C * ) = T * .We will prove that A is an injection by showing that T and T * must be distinct.
As C = C * , Algorithm 3.6 must encounter C(v i ) = C * (v i ) for some i ∈ {1, 2, . . ., n}.Choose i to index the earliest such encounter; since Algorithm 3.6 assigns the scores in order of decreasing value, i is the index witnessing max{max{C(v j ), C * (v j )} : 1 ≤ j ≤ n and C(v j ) = C * (v j )}.Without loss of generality, we may suppose that C * (v i ) > C(v i ).
We will show that v i has different neighbors in T and T * , so that T = T * .Suppose that as Algorithm 3.6 operates on C, the sequences constructed in step (8) are M 1 , M 2 , . . ., M j , and suppose that as it operates on C * , the corresponding sequences are M * 1 , M * 2 , . . ., M * k .Now suppose that v i ∈ M s (for some s ∈ {1, 2, . . ., j}) and v i ∈ M * t (for some t ∈ {1, 2, . . ., k}).We distinguish two cases.
Our second algorithm injectively maps S to R.
Algorithm 3.7 INPUT: a spanning tree T of K n+1 OUTPUT: a relaxed legal configuration C : Until all v k have been included in some sequence N i , repeat steps ( 4) and ( 5): (4) i ← i + 1.
(5) Define N i = (v i1 , v i2 , . . ., v it ), for t ≥ 1, as the sequence (in increasing subscript order) of all unassigned nodes that are neighbors in T of a node in N i−1 .Let N i = {x : x is an entry of N i }.
(6) Define N = (u k ) n+1 k=1 as the concatenation of all the N i 's, in their natural order.(7) For k = 1, 2, . . ., n, set F (u k ) = n − k (note that the (n + 1) st entry is not assigned a score).(8) a.For each i = 1, 2, . . ., n, the node v i is an entry of some N j , and is thus the neighbor in T of some It's worth noting that in step (5) we are performing a breadth-first search (see, e.g., [8]) from v 0 to determine the N i 's.
Proof that B is well-defined: Step (7) makes it clear that C is relaxed, since the maximum assigned score is n − 1.In order to show that C is legal, we demonstrate that for each ∈ {1, 2, . . ., n}, at least n − nodes contain at least chips (again, see Corollary 3.2).In step (7), a node v k receives the score after (n − 1) − other nodes have been assigned scores.As v k has n neighbors in K n+1 , it will have n − ((n − 1) − ) = + 1 unlabeled neighbors in T .These are the only nodes that can be assigned C-values at most F (v k ) = in step (8b).Thus, for ∈ {0, 1, . . ., n − 1}, at most + 1 nodes of K n are assigned C-values at most .Complementation and Corollary 3.2 imply that C is indeed legal. 2 Proof that B is an injection: Let T and T * be two distinct spanning trees of K n+1 .Let V (K n+1 ) = {v 0 , v 1 , . . ., v n }.Let B(T ) = C and B(T * ) = C * .We will prove that B is an injection by showing that the configurations C and C * must be distinct.For v ∈ V (T ), let Γ T (v) denote the set of neighbors of v that are assigned the value F (v) in step (8b); in other words, Γ T (v) is the set of nodes adjacent to v, and one edge further from v 0 , in T .Define Γ T * (v) analogously.
Since T = T * , we infer that Γ T (v) = Γ T * (v) for some v ∈ V (K n+1 ).With N i , N * i denoting the sequences constructed by step (5) for T , T * respectively, let r := min{i : there exists v ∈ N i ∩ N * i with Γ T (v) = Γ T * (v)}.Choose any v ∈ N r ∩ N * r with Γ T (v) = Γ T * (v).Step (8b) assigns the value F (v) to all x ∈ Γ T (v) and the value F * (v) to all y ∈ Γ T * (v).By the choice of r (as a minimum), we have F (v) = F * (v); by step (7), we know that this score is assigned exclusively to v. To receive this score in step (8b) (as a chip count), a node must be a member of either Γ T (v) or Γ T * (v).Since Γ T (v) = Γ T * (v), we have C = C * ; thus, B is injective. 2 Now that we have demonstrated injections between the set R of relaxed legal configurations on K n and the set S of spanning trees of K n+1 , we have |R| = |S|, which finally completes the proof of Theorem 3.5. 2 As noted at the start of this section, our results yield a new proof of Cayley's Formula, for combining Theorem 3.5 with Corollary 3.4 gives |S| = |R| = L(K n ) = (n + 1) n−1 .We view this as somewhat of a curiosity because it is certainly not the most efficient published proof of this identity (see, e.g., [18]).Nevertheless, it ties our results on burn-off games to spanning tree enumeration much as conventional chip-firing games have been likewise linked.
We intend to present further results on burn-off games from [20] in a future paper, for which the present article will form a foundation.
) Delete v and all incident edges from G * to create a graph G − .(5) If V (G − ) = ∅, then stop.Output 'Yes.' (6) Let G * = G − and go to step 2.

Case 1 :
s = t.Since C(v i ) and C * (v i ) are the earliest unequal entries considered, we haveM s−1 = M * t−1 .Since C(v i ) = C * (v i ),the node v i must be assigned different neighbors, say x, y, from among the nodes of M s−1 and M * t−1 , respectively.Then the edge {v i , x} belongs to E(T ) E(T * ), implying that T = T * .Case 2: s = t.Algorithm 3.6 adds an edge between v i and some node w * in M * t−1 .Since C(v i ) and C * (v i ) are the earliest unequal entries encountered, we know that M t−1 = M * t−1 .But we have assumed that C so (4) holds for each w i (considered now in H).Therefore, Proposition 2.1 shows that C| V (H) is legal on H.2Now we are ready to establish the correctness of Algorithm 2.2.
Proposition 2.4 Given a graph G = (V, E) and a configuration C : V → N on G, Algorithm 2.2 correctly determines whether C is a legal configuration on G.Proof: First, we show that if at any point during the operation of Algorithm 2.2 (say, when we have arrived at a subgraph G * ) every node v contains fewer than deg G * (v) chips, then the original configuration is not legal.Suppose, for a contradiction, that an original configuration C * leading to this situation on G * is legal.By Lemma 2.3, C * | V (G * ) is legal; letting k := |V (G * )|, then by Proposition 2.1 the nodes of G * may be relabeled w 1 , w 2 , . . ., w k so that C(w