Dhar's Burning Algorithm Overview

• Dhar’s Burning Algorithm is a graph-theoretic procedure that propagates a ‘fire’ from a distinguished vertex to certify chip-firing configurations and determine reducedness or effectivity.
• It includes classical sink-based tests, iterated burning for q-reduced divisors, weighted generalizations, and a depth-first variant linking parking functions with rooted spanning trees.
• The algorithm is pivotal for applications in chip-firing, graph gonality computations, and spanning tree enumeration, offering polynomial-time performance across various formulations.

Searching arXiv for the cited papers to ground the article in published sources. Dhar's burning algorithm is a family of graph-theoretic procedures built around the propagation of a “fire” from a distinguished vertex and used to certify reducedness, effectivity, or failure thereof in chip-firing configurations, and, in a depth-first search variant, to construct a bijection between graph parking functions and rooted spanning trees. In the sources considered here, the term encompasses the classical sink-based test for the Dollar Game, the iterated reduction algorithm for computing $q$-reduced divisors, a modified form adapted to higher gonalities, a weighted-graph generalization, and a depth-first burning process tied to inversion statistics on labeled trees [(Beougher et al., 2024); (Aidun et al., 2020); (Doyle, 2023); (Perkinson et al., 2013)].

1. Classical sink-based formulation

In the chip-firing setting, one fixes a finite connected graph $G=(V,E)$ and a distinguished vertex $q\in V$, often called the sink. A divisor is an integer vector $D\in\mathbb{Z}^V$, with $D(v)$ interpreted as the number of chips at $v$; negative entries represent debt. Dhar’s burning algorithm is applied to divisors satisfying $D(v)\ge 0$ for all $v\neq q$, with $D(q)$ possibly negative. Its purpose is to decide whether the Dollar Game at $q$ is winnable, equivalently whether there exists a sequence of chip-firing moves that makes $G=(V,E)$0 as well (Beougher et al., 2024).

A single burning phase begins with the burning set $G=(V,E)$1. Repeatedly, one burns all edges incident to vertices in $G=(V,E)$2, and for each vertex $G=(V,E)$3 counts the number $G=(V,E)$4 of burning edges incident to $G=(V,E)$5. If $G=(V,E)$6, then $G=(V,E)$7 is added to $G=(V,E)$8 and remains there permanently. This continues until no new vertex can be added. If eventually $G=(V,E)$9, then “the whole graph burns” and the algorithm declares “LOSS.” If instead $q\in V$0, then the unburned complement $q\in V$1 is nonempty, and one fires every vertex of $q\in V$2 simultaneously:

$q\in V$3

where $q\in V$4 is the graph Laplacian and $q\in V$5 is the indicator of $q\in V$6 (Beougher et al., 2024).

The key correctness statement is Dhar’s criterion: for a divisor $q\in V$7 with $q\in V$8 for $q\in V$9, the Dollar Game at $D\in\mathbb{Z}^V$0 is winnable if and only if Dhar’s burning algorithm terminates with “WIN.” Equivalently, “WIN” means that eventually $D\in\mathbb{Z}^V$1 becomes nonnegative, while “LOSS” means that in some burning phase one obtains $D\in\mathbb{Z}^V$2 (Beougher et al., 2024).

The primer on chip-firing for Platonic solids gives a complete run on the tetrahedron graph $D\in\mathbb{Z}^V$3. With sink $D\in\mathbb{Z}^V$4 and divisor

$D\in\mathbb{Z}^V$5

the first burning phase yields $D\in\mathbb{Z}^V$6 while $D\in\mathbb{Z}^V$7 remains unburned, so one set-fires $D\in\mathbb{Z}^V$8. The new divisor is

$D\in\mathbb{Z}^V$9

and now $D(v)$0, so the algorithm returns “WIN” (Beougher et al., 2024).

2. $D(v)$1-reduced divisors and iterated burning

A closely related formulation is expressed in terms of $D(v)$2-reduced divisors. For a finite (multi-)graph $D(v)$3, a divisor $D(v)$4 is $D(v)$5-semi-reduced if $D(v)$6 for all $D(v)$7. It is $D(v)$8-reduced if, in addition, for every nonempty $D(v)$9 there exists a vertex $v$0 such that

$v$1

where $v$2 is the number of edges from $v$3 to $v$4 (Aidun et al., 2020).

In this formulation, Dhar’s algorithm computes the unique $v$5-reduced representative $v$6 in the linear-equivalence class of a $v$7-semi-reduced divisor. One initializes

$v$8

If there exists $v$9 with $D(v)\ge 0$0, then $D(v)\ge 0$1 burns and is removed from $D(v)\ge 0$2. If no such vertex exists, one fires all of $D(v)\ge 0$3 at once by replacing $D(v)\ge 0$4 with $D(v)\ge 0$5, then restarts with $D(v)\ge 0$6. When finally $D(v)\ge 0$7, the whole graph has burned and the resulting divisor is $D(v)\ge 0$8-reduced (Aidun et al., 2020).

This perspective is integrated into the Baker–Norine theory of divisors on graphs through the criterion

$D(v)\ge 0$9

where $v\neq q$0 is the rank of the divisor. Consequently, testing rank at least one reduces to computing reduced representatives at each sink vertex (Aidun et al., 2020).

Termination is proved via a lexicographic potential. Fixing a distance partition $v\neq q$1 of the vertex set, one defines

$v\neq q$2

Each time a nonempty set $v\neq q$3 is fired, one chip moves strictly closer to $v\neq q$4 in the lexicographic order on $v\neq q$5, so $v\neq q$6 increases. Because this vector is bounded above by the total number of chips and the distance parameter $v\neq q$7, the process terminates (Aidun et al., 2020).

3. Modified burning for higher gonalities

For higher-rank questions, the classical approach is indirect because testing whether $v\neq q$8 requires checking $v\neq q$9 for every effective divisor $D(q)$0 of degree $D(q)$1 and, in the standard formulation, repeating semi-reduction and burning for different sinks. The modified version introduced for gonality sequences is designed to decide whether an arbitrary divisor class contains an effective representative in a single pass, and is described as better suited to testing rank $D(q)$2 and hence higher gonalities (Aidun et al., 2020).

Write an arbitrary divisor as

$D(q)$3

with $D(q)$4. The fire is initialized not at a single sink but on the support of the debt, $D(q)$5. The initial safe set is

$D(q)$6

As in the classical algorithm, one removes vertices $D(q)$7 satisfying $D(q)$8. If no such vertex exists, one fires the entire safe set:

$D(q)$9

If at any point $q$0, the algorithm returns an effective divisor $q$1; if instead the whole graph burns while some vertex remains in debt, it returns None (Aidun et al., 2020).

Three structural differences from the original formulation are explicit. There is no choice of sink $q$2; the initial fire is placed on exactly those vertices in debt. There is no separate semi-reduction step, because whenever the algorithm fires the entire safe set $q$3, one has $q$4, so no new debt is introduced. Finally, the algorithm stops early as soon as an effective representative is reached (Aidun et al., 2020).

The paper’s worked example uses the 8-vertex path

$q$5

and the divisor

$q$6

In the first iteration, burning from $q$7 leaves only $q$8 unburned, so $q$9 is fired, producing

$G=(V,E)$00

In the second iteration, burning from $G=(V,E)$01 leaves $G=(V,E)$02 unburned, and firing that set produces

$G=(V,E)$03

which is effective. The algorithm therefore returns $G=(V,E)$04 after two passes (Aidun et al., 2020).

The performance bounds recorded in the source are explicit. Each pass through the fire-loop takes $G=(V,E)$05 time in the worst case, there are at most $G=(V,E)$06 passes, and the total time is

$G=(V,E)$07

The paper notes that, even though the worst-case asymptotic matches the standard algorithm, in practice the modified version is somewhat faster when computing higher gonalities (Aidun et al., 2020).

4. Weighted-graph generalization

Dhar’s burning algorithm has also been generalized to finite, connected weighted multigraphs with no loops and no legs. In this setting one has positive integer vertex weights $G=(V,E)$08 and edge weights $G=(V,E)$09, subject to the divisibility condition that whenever an edge $G=(V,E)$10 has endpoints $G=(V,E)$11, the weight $G=(V,E)$12 divides both $G=(V,E)$13 and $G=(V,E)$14. The weighted valency is

$G=(V,E)$15

A firing at $G=(V,E)$16 removes $G=(V,E)$17 chips from $G=(V,E)$18 and sends along each incident edge $G=(V,E)$19 exactly $G=(V,E)$20 chips to $G=(V,E)$21 (Doyle, 2023).

The corresponding weighted Laplacian $G=(V,E)$22 has entries

$G=(V,E)$23

and linear equivalence is defined by $G=(V,E)$24 for an integer firing script $G=(V,E)$25. A divisor is $G=(V,E)$26-effective if $G=(V,E)$27 for all $G=(V,E)$28. It is $G=(V,E)$29-reduced if it is $G=(V,E)$30-effective, has the largest possible value at $G=(V,E)$31 among all linearly equivalent $G=(V,E)$32-effective divisors, and, when another $G=(V,E)$33-effective representative has the same value at $G=(V,E)$34, any nontrivial firing script from $G=(V,E)$35 to that representative must fire $G=(V,E)$36 at least once (Doyle, 2023).

The weighted algorithm introduces the charge vector. Let

$G=(V,E)$37

The script $G=(V,E)$38 with $G=(V,E)$39 lies in $G=(V,E)$40 and generates it. The generalized burning algorithm starts by setting $G=(V,E)$41 for each $G=(V,E)$42, then loops over $G=(V,E)$43, setting $G=(V,E)$44. At each stage one computes $G=(V,E)$45 and declares that a vertex $G=(V,E)$46 burns precisely when

$G=(V,E)$47

Burning reduces $G=(V,E)$48 by $G=(V,E)$49, and after all such reductions stabilize, the algorithm records the resulting candidate. Among the $G=(V,E)$50 candidates, it chooses the one maximizing the residual value at $G=(V,E)$51 (Doyle, 2023).

Termination follows because the outer loop runs at most $G=(V,E)$52 times, while in the inner loop each coordinate $G=(V,E)$53 begins at $G=(V,E)$54 and can be decreased only finitely many times. The overall bound stated in the paper is $G=(V,E)$55 burning steps, and with the cost of computing $G=(V,E)$56 this yields time complexity

$G=(V,E)$57

where $G=(V,E)$58 (Doyle, 2023).

The weighted formulation also changes the structural picture. The source emphasizes that the Laplacian is generally not symmetric, that the outer loop of size $G=(V,E)$59 is needed to search for the script leaving the maximum possible number of chips at $G=(V,E)$60, and that there can be more than one $G=(V,E)$61-reduced representative in a single linear-equivalence class when $G=(V,E)$62 (Doyle, 2023).

5. Depth-first burning, parking functions, and tree inversions

A different but closely related procedure appears in the study of $G=(V,E)$63-parking functions and labeled spanning trees. Here $G=(V,E)$64 is a finite, connected, simple graph with distinguished root $G=(V,E)$65, and a $G=(V,E)$66-parking function is a map

$G=(V,E)$67

such that for every nonempty $G=(V,E)$68 there exists $G=(V,E)$69 with

$G=(V,E)$70

where $G=(V,E)$71 is the number of edges joining $G=(V,E)$72 to a vertex outside $G=(V,E)$73 (Perkinson et al., 2013).

The depth-first search version of Dhar’s burning algorithm lights the root $G=(V,E)$74 on fire and lets the fire spread according to a depth-first rule. Each nonroot vertex $G=(V,E)$75 carries $G=(V,E)$76 drops of water. When the fire arrives at $G=(V,E)$77 along an edge $G=(V,E)$78, two cases occur. If $G=(V,E)$79, one uses one drop of water, replaces $G=(V,E)$80 by $G=(V,E)$81, dampens $G=(V,E)$82, and immediately backtracks. If $G=(V,E)$83, then $G=(V,E)$84 is permanently burnt, the edge $G=(V,E)$85 is recorded as a tree edge, and the search continues from $G=(V,E)$86, always choosing the largest-labeled unburnt neighbor next (Perkinson et al., 2013).

This process yields a dichotomy. If every vertex burns, then exactly $G=(V,E)$87 edges burn through, forming a spanning tree $G=(V,E)$88 rooted at $G=(V,E)$89, and the number of dampened edges is $G=(V,E)$90. If instead some set $G=(V,E)$91 never burns, then each $G=(V,E)$92 has every edge to a burnt vertex dampened, so $G=(V,E)$93, certifying that $G=(V,E)$94 is not a parking function (Perkinson et al., 2013).

The inverse procedure starts from a rooted spanning tree $G=(V,E)$95 and runs the same depth-first skeleton, dampening every non-tree edge encountered in the same order and incrementing $G=(V,E)$96 whenever $G=(V,E)$97 is the head of a dampened edge. The two procedures are inverse to one another, producing a bijection

$G=(V,E)$98

The central enumerative statement is the degree–inversion correspondence. If

$G=(V,E)$99

is the circuit rank, and $q\in V$00 denotes the number of $q\in V$01-inversions of the rooted spanning tree $q\in V$02, then

$q\in V$03

or equivalently

$q\in V$04

The paper states this as its main theorem and notes that, when specialized to the complete graph, it answers a problem posed by R. Stanley (Perkinson et al., 2013).

The worked “house” example takes the root $q\in V$05 and the parking function $q\in V$06 on vertices $q\in V$07. The burn produces the rooted spanning tree with edges

$q\in V$08

with a single dampened edge $q\in V$09. Hence $q\in V$10. Since the graph has $q\in V$11, one checks that $q\in V$12, in accordance with $q\in V$13 (Perkinson et al., 2013).

6. Applications, scope, and algorithmic significance

The applications recorded in these sources are concentrated in chip-firing, graph gonality, and spanning-tree enumeration. In the primer on Platonic solids, Dhar’s burning algorithm is one of the main tools used alongside independent sets, treewidth, and scramble number; that work presents the first proofs that the dodecahedron graph has gonality $q\in V$14 and that the icosahedron graph has gonality $q\in V$15 (Beougher et al., 2024).

Within gonality computations, the algorithm serves both as a decision procedure and as a source of lower-bound arguments. The primer explicitly refers to “Dharguments,” meaning variations on Dhar’s algorithm used to obtain quick lower bounds on gonality by showing that any small-degree divisor will trigger a full burn from a suitable choice of sink. The modified version for gonality sequences extends this role from rank at least one to higher-rank questions by solving the general “dollar-game” problem of deciding effectivity in one pass (Beougher et al., 2024, Aidun et al., 2020).

Algorithmically, the formulations represented here range from linear-time depth-first search on simple graphs to polynomial-time chip-firing procedures on divisors and more elaborate weighted variants. The DFS-burning bijection runs in $q\in V$16, the classical burning phase can be implemented in $q\in V$17 time, the iterated set-firing process is polynomial in the graph size and chip magnitudes, and the weighted version has complexity governed by the charge parameters $q\in V$18 induced by the vertex weights [(Perkinson et al., 2013); (Beougher et al., 2024); (Doyle, 2023)].

Taken together, these formulations show that “Dhar’s burning algorithm” is not a single fixed routine but a coherent method family. In every version, a burn from a distinguished source exposes whether a configuration can resist propagation. What changes across the literature is the object being tested—Dollar Game solvability, $q\in V$19-reducedness, existence of an effective divisor in a linear-equivalence class, or membership in a parking-function class—and the output, which may be a win/loss certificate, a reduced divisor, a legal firing script, or a rooted spanning tree endowed with inversion statistics [(Beougher et al., 2024); (Aidun et al., 2020); (Doyle, 2023); (Perkinson et al., 2013)].