Graph Burning: An Overview of Compact Mathematical Programs

Abstract

The Graph Burning Problem (GBP) is a combinatorial optimization problem that has gained relevance as a tool for quantifying a graph’s vulnerability to contagion. Although it is based on a very simple propagation model, its decision version is NP-complete and its optimization version is NP-hard. This paper introduces novel mathematical programs for the GBP. Among the introduced programs are a Mixed-Integer Linear Program (MILP), a Constraint Satisfaction Problem (CSP), two Integer Linear Programs (ILPs), and two Quadratic Unconstrained Binary Optimization (QUBO) problems. Most optimization solvers can handle these, with QUBO problems being of capital interest in quantum computing. Nonetheless, the primary objective of this paper is not to solve instances of the GBP, but rather to deepen our understanding of it by identifying and examining what we believe to be its simplest mathematical formulations, that is, models that use as few variables and constraints as possible (compact mathematical programs). We believe that this collection of programs can provide ideas for modeling variants and related problems. As a marginal result, one of the proposed ILPs, equipped with a row generation technique, allowed a commercial solver to find optimal solutions for some of the largest and most challenging instances for the GBP.

1. Introduction

Propagation phenomena are of significant interest to humanity. For example, by modeling the spread of fires, containment strategies can be developed. The same idea applies to many other processes, including the diffusion of social influence, viruses, rumors, alerts, and news. Since the underlying structure of complex systems is a network, assessing a network’s susceptibility to contagion is crucial. The Graph Burning Problem (GBP) provides a framework for addressing this need.

The optimization version of the GBP receives a graph G as input and seeks a minimum-length burning sequence, namely, a list $(u_1,u_2,...,u_g)\in V{\left(G\right)}^g$ with minimum g such that all vertices are at most at distance $g-i$ to some vertex $u_i$. The length of the optimal burning sequence is known as the burning number and is denoted by $b\left(G\right)$ [1,2]. This number captures how susceptible to contagion a graph is; the smaller the burning number, the more vulnerable the graph. The GBP decision version receives a graph $G=(V,E)$ and a positive integer g as input. Its goal is to determine whether $b\left(G\right)\le g$. This problem is NP-complete, even for trees of a maximum degree of three, spider graphs, and path forests, among others [3].

Figure 1 and Figure 2 illustrate how the GBP is based on a simple propagation process, in which fire propagates to adjacent vertices in discrete time steps. Initially, all vertices are unburned, and once a vertex is burned, it remains in that state. In addition, a new vertex can be burned at each time step even if it does not have burned neighbors. Notice that a vertex can catch fire from multiple fire sources, i.e., it can be at distance $g-i$ from many vertices in the burning sequence (see Figure 2); this will be relevant later when introducing Quadratic Unconstrained Binary Optimization (QUBO) problems.

The goal of this paper is to develop a comprehensive understanding of the GBP optimization version by systematically enumerating and analyzing its various mathematical programs. To the best of our knowledge, all the programs presented in this paper are novel and are the simplest reported in the literature in terms of number of variables and constraints. Similarities between some of the introduced programs and state-of-the-art programs are discussed within each program’s section. We believe that the introduced programs may serve as a basis for modeling variants of the GBP. Marginally, and thanks to optimization algorithms and solvers, the proposed programs let us search for optimal or near-optimal solutions of large and challenging instances for the GBP. Before continuing, let us list some definitions and relationships that will be useful for the remainder of this paper.

2. Materials and Methods

2.1. Basic Definitions

• A graph $G=(V,E)$ is an ordered pair, where V is the set of vertices and E is the set of edges, a set of 2-element subsets of V [4].
• The distance $d(u,v)$ between vertices u and v in a graph is the length of their shortest path.
• The open neighborhood $N\left(v\right)$ of a vertex v is its set of adjacent vertices in G.
• The closed neighborhood $N\left[v\right]$ of a vertex v is $N\left(v\right)\cup \left\{v\right\}$.
• The $r^{th}$ power $G^r$ of a given graph $G=(V,E)$ is obtained by adding an edge between each pair of vertices in V at a distance of up to r.
• The $r^{th}$ open neighborhood $N_r\left(v\right)$ of a vertex v is its set of neighbors in $G^r$.
• The $r^{th}$ closed neighborhood $N_r\left[v\right]$ of a vertex v is $N_r\left(v\right)\cup \left\{v\right\}$.
• A burning sequence of a graph $G=(V,E)$ is an ordered list $(u_1,u_2,...,u_g)\in V^g$ such that the distance from every $v\in V$ to some vertex $u_i$ is at most $g-i$. The length of the burning sequence is g.
• Given an input graph, the GBP seeks a burning sequence of minimum length.
• The length of an optimal solution for the GBP is denoted by $b\left(G\right)$, which is known as the burning number of the graph.

2.2. The GBP as a Coverage Problem

The GBP can be stated as finding the shortest sequence $(u_1,u_2,...,u_g)$ that satisfies Equation (1) [3].

$$N_{g-1}\left[u_1\right]\cup N_{g-2}\left[u_2\right]\cup \dots \cup N_1\left[u_{g-1}\right]\cup N_0\left[u_g\right]=V\left(G\right).$$

(1)

From this equation, it is inferred that the GBP is equivalent to solving up to ${log}_{2}n$ Clustered Maximum Coverage Problems (CMCPs), where n is the number of vertices in the input graph [5]. In more detail, for a given guess $g\ge b\left(G\right)$, Equation (1) can be satisfied by a sequence $(u_1,u_2,...,u_g)$ such that each vertex $u_j$ corresponds to a cluster $\{N_{g-j}\left[v\right]:v\in V\left(G\right)\}$. For example, if the input graph is $P_4$ and $g=b\left(P_4\right)=2$, its corresponding CMCP is shown in Figure 3. As illustrated in this figure, a vertex must be chosen for each available covering radius; this is 0 and 1 in this case. In this way, vertex $v_4$ is selected from the cluster $\{N_0\left[v_1\right],N_0\left[v_2\right],N_0\left[v_3\right],N_0\left[v_4\right]\}$ and vertex $v_2$ is selected from the cluster $\{N_1\left[v_1\right],N_1\left[v_2\right],N_1\left[v_3\right],N_1\left[v_4\right]\}$. Notice that $N_0\left[v_4\right]\cup N_1\left[v_2\right]=V\left(P_4\right)$. Thus, an optimal burning sequence for $P_4$ is $(v_2,v_4)$.

In the case of $g<b\left(G\right)$, Equation (1) cannot be satisfied. Thus, a binary search can be conducted to find an optimal solution (see Algorithm 1). In short, the GBP can be approached by solving up to ${log}_{2}n$ CMCPs, where $n=\left|V\right(G\left)\right|$ and g is a guess on $b\left(G\right)$ (see line 3 of Algorithm 1). If the optimal solution of CMCP $(G,g)$ covers all vertices, the upper bound of the binary search is set to $g-1$ (see line 6 of Algorithm 1); otherwise, the lower bound is set to $g+1$ (see line 8 of Algorithm 1). In this way, in some iteration of the binary search, g equals $b\left(G\right)$. Therefore, the GBP is solved to optimality. Most of the mathematical programs introduced in this paper leverage the relationship between the GBP and the CMCP.

For more details on the CMCP, the reader can refer to [5,6]. In fact, when García-Díaz et al. proposed the CMCP in 2025 [5], they were unaware of this being a special case of the Maximum Coverage Problem with Group Budget Constraints introduced by Chekuri and Kumar in 2004 [6].

Algorithm 1 GBP as a series of CMCPs

Require: A graph $G=(V,E)$ Ensure: An optimal burning sequence   1:  $l,u\Leftarrow 1,\left|V\right|$   2:  while  $l\le u$  do   3:        $g\Leftarrow \lfloor (l+u)/2\rfloor$   4:        $S\Leftarrow \mathrm{Solve}\mathrm{CMCP}(G,g)$   5:        if S burns all vertices then   6:              $u\Leftarrow g-1$   7:        else   8:              $l\Leftarrow g+1$   9:        end if 10:  end while 11:  return the best found burning sequence

2.3. Mathematical Programs

Mathematical programs consist of three main components: an objective function, a set of constraints, and decision variables. Depending on the characteristics of these, a mathematical program belongs to a different category. For instance, a Linear Program (LP) has a linear objective function, linear constraints, and continuous variables, as follows:

$$\min \mathbf{c}\mathbf{x}$$

(2)

$$\mathrm{subject}\mathrm{to}(\mathrm{s}.\mathrm{t}.) \mathbf{Ax}\le \mathbf{b}$$

(3)

$$\mathrm{where} \mathbf{x}\ge \mathbf{0}$$

(4)

The row vector $\mathbf{c}$, the matrix $\mathbf{A}$, and the column vector $\mathbf{b}$ comprise the input data. The column vector $\mathbf{x}$ contains the variables to optimize. If all of these variables are integers, then the program is an Integer Linear Program (ILP). If some variables are integers and some are continuous, then the program is a Mixed-Integer Linear Program (MILP). The mathematical programs listed in this paper include one MILP (see Section 4.1), two ILPs (see Section 4.3 and Section 4.4), and two Quadratic Unconstrained Binary Optimization (QUBO) problems (see Section 4.5 and Section 4.6). A QUBO problem is a mathematical program with a quadratic objective function, binary variables, and no explicit constraints. Interestingly, the proposed QUBO problems result from the Constraint Satisfaction Problem (CSP) introduced in Section 4.2. A CSP is similar to a mathematical program, except that it is not an optimization problem, but rather a satisfaction problem. That is, any set of variables that satisfy the constraints is a valid solution.

Through specialized algorithms based on branch-and-bound, branch-and-cut, branch-and-price, heuristics, and metaheuristics, mathematical programs can be solved or approximated, depending on the difficulty level of each instance. Specialized software known as optimization solvers implement these kinds of algorithms, allowing us to find optimal or near-optimal solutions. Among the most popular optimization solvers are Gurobi [7], CPLEX [8], SCIP [9], and HiGHS [10]. In recent years, quantum-based solvers have emerged as candidates for solving QUBO problems. Therefore, interest in this class of programs has increased. The next section explores this topic.

2.4. QUBO Problems and Quantum Computing

QUBO problems comprise a significant category in mathematical programming because they cover a wide variety of important combinatorial optimization problems [11]. A QUBO problem is characterized as follows by a quadratic objective function of binary variables with no explicit constraints:

$$\min {\mathbf{x}}^T\mathbf{Q}\mathbf{x}=\sum _i{Q}_{ii}{x}_i+\sum _{i<j}{Q}_{ij}{x}_i{x}_j,$$

(5)

where $\mathbf{x}\in {\{0,1\}}^n$ is a vector of n binary decision variables and $\mathbf{Q}$ is an upper triangular $n\times n$ real-valued matrix. $Q_{ii}$ represents the linear coefficients and $Q_{ij}$ represents the quadratic coefficients [12]. A constraint in a QUBO model is implicit within the objective function via penalty terms. For example, the explicit constraint ${\sum }_i{y}_i=1$ is equivalent to the implicit constraint $P{({\sum }_i{y}_i-1)}^2$ if P is sufficiently large. So, by means of penalized implicit constraints, unfeasible solutions are avoided during the search process [13].

As QUBO problems are NP-hard, solving them can be challenging, requiring more specialized approaches. Although optimization solvers such as Gurobi and CPLEX can deal with QUBO problems, they usually struggle to solve large-scale instances [12,14]. Thus, for larger or particularly difficult instances, metaheuristics such as Simulated Annealing, Tabu Search, and Genetic Algorithms are employed to find near-optimal solutions [12]. Beyond classical computing, quantum computing has emerged as a valuable alternative. For instance, quantum annealers are physical processors designed to find low-energy states of Ising models, which are mathematically equivalent to QUBO problems [15]. Similarly, gate-based quantum algorithms, such as the Quantum Approximate Optimization Algorithm (QAOA), are used to approximate QUBO solutions on universal quantum computers [16].

In summary, the significance of QUBO models lies in their versatility and wide applicability. From a classical perspective, they provide a unified and often compact framework for representing combinatorial problems. This enables the application of a diverse range of specialized solvers and metaheuristics [12,13]. Furthermore, the QUBO formulation is of fundamental importance in quantum computing. It serves as the primary interface for most current quantum optimization approaches in the Noisy Intermediate-Scale Quantum (NISQ) era. For example, by expressing a problem such as the GBP as a QUBO problem, it becomes immediately accessible to quantum annealers and quantum–classical hybrid algorithms such as QAOA, paving the way for novel solving techniques [11,17,18].

3. Related Work

Since there is no exact formula for determining the burning number of arbitrary graphs, a significant amount of research has been directed towards finding tighter upper bounds for the burning number in both arbitrary and particular graph families. Bonato et al. [19] proposed the Burning Number Conjecture, which states that for any connected graph G of order n, $b\left(G\right)\le \lceil \sqrt{n}\rceil$. In fact, $b\left(P_n\right)=b\left(C_n\right)=\lceil \sqrt{n}\rceil$, where $P_n$ and $C_n$ are paths and cycles of order n, respectively [2]. This conjecture also holds for spiders [20], caterpillars [21,22], homeomorphically irreducible trees [23], and graphs with a minimum degree $\delta \ge 23$ [24]. Trivial cases include complete graphs $K_n$ and star graphs $K_{1,n}$ where $b\left(K_n\right)=b\left(K_{1,n}\right)=2$. Regarding general upper bounds, the best known bound is due to Bonato and Kamali, who proved $b\left(G\right)\le ⌈{\displaystyle \frac{\sqrt{12n+64}+8}{3}}⌉$ [25], improving earlier results by Land and Lu [26]. Further progress has been made for other graph families, such as generalized Petersen graphs [27], theta graphs [28], random graphs [29], grids [29,30], Q graphs [31], trees [32], and path forests [20,33].

Beyond the classical GBP, several extensions and variations have been proposed over the years to better model and study real-world propagation dynamics. The first extension of the GBP was proposed by Mitsche et al. [29], aimed at exploring the probabilistic aspects of the problem. Subsequently, it was extended to specific graph settings such as geometric graphs [34], hypergraphs [35], temporal graphs [36], and directed graphs [37], as well as to metric spaces, including anywhere burning [38] and Euclidean burning [39]. Regarding variants of the GBP, the first two proposed are k-fast, where the fire can spread at a distance of at most k [40], and k-slow burning, where the fire spreads to at most k neighbors [40]. Subsequent work includes edge burning [41], where the edges are burned instead of the vertices; total burning, where both edges and vertices are burned [41]; generalized burning number, where a vertex can only be burned if at least r neighbors were burned in the previous round [42]; k-burning, where k vertices can be spontaneously ignited in each round [43]; and Constrained Diffusion GBP, where a threshold is assigned to each vertex that limits how many neighbors can be burned [44]. Other variants include game-theoretic formulations such as Burning Game [45] and Adversarial Burning [46], stochastic versions such as the Independent Cascade Model of Graph Burning [47], and color-constrained models such as Chromatic Burning and Edge Chromatic Burning [48].

Given its NP-hard nature, it seems unlikely that the GBP can be solved in polynomial time. Nevertheless, many efficient heuristics, metaheuristics, and approximation algorithms have been designed. Among the most relevant are a 2-approximation algorithm for trees [49], a 1.5-approximation algorithm for graphs with disjoint paths [49], a 2-approximation algorithm for square grids [50], and $(3-2/b(G\left)\right)$-approximation algorithms for arbitrary graphs [49,51]. While most heuristics and metaheuristics are based on centrality measures such as eigenvector and betweenness centrality [52,53,54], a more recent one is based on a 0.5-approximation algorithm for the CMCP [5]. Although these heuristics and metaheuristics are good at finding near-optimal solutions, they do not give any optimality guarantee. Regarding mathematical programs, many have been previously reported [5,55,56]. However, those introduced in this paper are conceptually simpler and consist of fewer variables and constraints, which makes them more useful for finding optimal solutions.

4. Mathematical Programs for the Graph Burning Problem

This section introduces novel mathematical programs for the GBP. These include one MILP (see Section 4.1), one CSP (see Section 4.2), two ILPs (see Section 4.3 and Section 4.4), and two QUBO problems (see Section 4.5 and Section 4.6).

4.1. A MILP Based on the Propagation Process: PROP-MILP

Expressions (6) to (11) define PROP-MILP, a MILP for the GBP with a known upper bound U for $b\left(G\right)$. Assuming that $V\left(G\right)=\{v_1,v_2,...,v_n\}$, the binary variables $s_{i,j}$ and $b_{i,j}$ codify the burning sequence and the burning process, respectively. Vertices cannot be burned in more than z steps (see Expression (9)), a value that is minimized (see Expression (6)). Although z is an integer, for practical purposes, it is better to set it as a real value. Vertices can catch fire only if they are in the sequence or have a previously burned neighbor (see Expression (7)). Finally, exactly one vertex can be added to the sequence in each round of the propagation process (see Expression (8)). Note that the solution is encoded in the variables $s_{i,j}$ and its length is $b\left(G\right)=z+1$ (see Figure 4).

$$\min z$$

(6)

$$\mathrm{s}.\mathrm{t}. b_{i,j}\le s_{i,j}+\sum _{v_k\in N\left[v_i\right]}{b}_{k,j-1} \forall v_i\in V,\forall j\in [1,U]$$

(7)

$$\sum _{v_i\in V}{s}_{i,j}=1 \forall j\in [1,U]$$

(8)

$$\sum _{j\in [1,U]}(1-b_{i,j})\le z \forall v_i\in V$$

(9)

$$\mathrm{where} s_{i,j},b_{i,j}\in \{0,1\},b_{i,0}=0 \forall v_i\in V,\forall j\in [1,U]$$

(10)

$$z\in \mathbb{R},b\left(G\right)\le U$$

(11)

Among all the programs presented in this paper, PROP-MILP has the most variables, $2Un$. However, it is perhaps the most intuitive. Hence, we decided to present it first. As its name suggests, it is based on the propagation process. As Figure 4 and Figure 5 show, the propagation process may not be accurately represented by the variables $b_{i,j}$. However, the optimal burning sequence is correctly encoded in variables $s_{i,j}$. In detail, for the input graph $P_5$ and $U=5$, the optimal solution to PROP-MILP codifies the optimal burning sequence in matrix $\mathbf{S}={\left[s_{i,j}\right]}_{n\times U}$. However, the matrices $\mathbf{B}={\left[b_{i,j}\right]}_{n\times U}$ and ${\mathbf{B}}^{\prime }={\left[b_{i,j}^{\prime }\right]}_{n\times U}$ are equally valid even if only $\mathbf{B}$ correctly codifies the propagation process, i.e., the circled zeros in ${\mathbf{B}}^{\prime }$ should be ones (see Figure 5).

The main drawback of PROP-MILP is its large number of variables. The more variables, the larger the search space, which can significantly increase the execution time of exact algorithms. Fortunately, all subsequent formulations use fewer variables than PROP-MILP, making them more practical alternatives.

Before closing this section, we note that PROP-MILP is similar to ILP-PROP, a state-of-the-art program introduced in 2025 [5]. The main differences are that ILP-PROP has an integer-valued objective function, whereas PROP-MILP has a continuous one, and PROP-MILP uses fewer variables and constraints. For an empirical comparison, we implemented both programs using Gurobi 12.0.3 and observed that their running times were very close on most instances. Hence, we do not report these results. In addition, all the programs discussed in this paper were implemented on Gurobi, and they are available at the link indicated in the data availability statement.

4.2. A CSP Based on the CMCP: COV-CSP

Expressions (12) to (15) define COV-CSP, a CSP for the GBP with a guess g on $b\left(G\right)$. As its name suggests, COV-CSP leverages the reduction from the GBP to the CMCP. This program is basically identical to GBP-IP, a state-of-the-art CSP reported in 2024 [56]. The difference between these two programs is that GBP-IP has n extra optional constraints. In other words, COV-CSP is GBP-IP with no optional constraints. As the reader may notice, in this paper, we are trying to follow a clearer and more systematic naming convention.

First, j represents the available coverage radii, which go from 0 to $g-1$. Specifically, Expression (13) guarantees that only one vertex is selected for each coverage radius, and Expression (14) ensures that every vertex is burned by at least one vertex in the burning sequence. Figure 6 shows an optimal solution for COV-CSP with input graph $P_9$ and $g=b\left(P_9\right)=3$.

$$\begin{array}{cc}\hfill \mathrm{find}& {\left[x_{i,j}\right]}_{n\times g}\hfill \end{array}$$

(12)

$$\begin{array}{ccc}\hfill \mathrm{s}.\mathrm{t}.& \sum _{v_i\in V}{x}_{i,j}=1\hfill & \hfill \forall j\in [1,g]\end{array}$$

(13)

$$\begin{array}{ccc}\hfill & 1\le \sum _{j\in [1,g]}\sum _{v_k\in N_{j-1}\left[v_i\right]}{x}_{k,j}\hfill & \hfill \forall v_i\in V\end{array}$$

(14)

$$\begin{array}{ccc}\hfill \mathrm{where}& x_{i,j}\in \{0,1\}\hfill & \hfill \forall v_i\in V,\forall j\in [1,g]\end{array}$$

(15)

The main advantage of COV-CSP is its reduced number of variables, $gn$. However, it has the disadvantage of requiring $b\left(G\right)$ to be known in advance. To address this issue, it can be integrated into a binary search. That is, lines 4 and 5 from Algorithm 1 can be replaced by

$$S\Leftarrow \mathrm{Solve}\mathrm{COV}-\mathrm{CSP}(G,g)$$

and

$$\mathbf{if} \mathrm{the} \mathrm{problem} \mathrm{is} \mathrm{feasible} \mathbf{then},$$

respectively. Since $g<b\left(G\right)$ makes COV-CSP infeasible, this approach has the disadvantage of requiring an infeasibility test, which could be very time-consuming. To avoid this issue, COV-CSP can be replaced by the ILP presented in Section 4.3.

4.3. An ILP Based on the CMCP: COV-ILP

Expressions (18) to (21) define COV-ILP, an ILP for the GBP. Like COV-CSP, COV-ILP leverages the relationship between the GBP and the CMCP. Expression (19) guarantees that only one vertex is selected for each coverage radius, except 0, which corresponds to $j=1$. Expression (20), along with the objective function (18), seeks to burn as many vertices as possible. Note that the variables $x_{i,1}$ are used to count the number of burned vertices. Thus, if

$$\sum _{v_i\in V}{x}_{i,1}=n,$$

(16)

then any vertex can be selected as the last vertex in the burning sequence. If

$$\sum _{v_i\in V}{x}_{i,1}=n-1,$$

(17)

then the vertex $v_i$, such that $x_{i,1}=0$, must be the last vertex in the burning sequence (see Figure 7).

$$\begin{array}{cc}\hfill \max & \sum _{v_i\in V}{x}_{i,1}\hfill \end{array}$$

(18)

$$\begin{array}{ccc}\hfill \mathrm{s}.\mathrm{t}.& \sum _{v_i\in V}{x}_{i,j}=1\hfill & \hfill \forall j\in [2,g]\end{array}$$

(19)

$$\begin{array}{ccc}\hfill & x_{i,1}\le \sum _{j\in [2,g]}\sum _{v_k\in N_{j-1}\left[v_i\right]}{x}_{k,j}\hfill & \hfill \forall v_i\in V\end{array}$$

(20)

$$\begin{array}{ccc}\hfill \mathrm{where}& x_{i,j}\in \{0,1\}\hfill & \hfill \forall v_i\in V,\forall j\in [1,g]\end{array}$$

(21)

While $g<b\left(G\right)$ makes COV-CSP infeasible, COV-ILP is always feasible regardless of the value of g. Thus, COV-ILP seems to be better suited for solving the GBP within a binary search. To do so, lines 4 and 5 of Algorithm 1 must be replaced by

$$S\Leftarrow \mathrm{Solve}\mathrm{COV}-\mathrm{ILP}(G,g)$$

and

$$\mathbf{if} S \mathrm{is} \mathrm{a} \mathrm{burning} \mathrm{sequence} \mathbf{then},$$

respectively. So far, we have defined three mathematical programs for the GBP: PROP-MILP, COV-CSP, and COV-ILP. Although PROP-MILP is perhaps the most intuitive, it is also the one with the most variables, $2Un$. COV-CSP is simpler and has only $gn$ variables, but requires knowing $b\left(G\right)$ in advance. In addition, if $g<b\left(G\right)$, COV-CSP is infeasible. COV-ILP improves COV-CSP in the sense that it is always feasible regardless of the value of g. To be practical, both COV-CSP and COV-ILP must be solved within a binary search; thus, they must be solved up to ${log}_{2}n$ times. The following ILP, which has $Un$ variables, is better than the previous programs in the sense that it does not require a binary search.

Before closing this section, we note that COV-ILP is similar to ILP-CMCP, a state-of-the-art program reported in 2025 [5]. However, ILP-CMCP has n extra variables, which makes COV-ILP a more compact integer program. In the same way that we found ILP-PROP and PROP-MILP to be similar in practice using Gurobi, we found ILP-CMCP and COV-ILP to be similar too. Therefore, we are not reporting such a comparison.

4.4. An ILP Based on the CMCP with a Known Upper Bound: GBP-ILP

Expressions (22) to (26) define GBP-ILP, an ILP for the GBP. Unlike COV-CSP and COV-ILP, which require a guess g on $b\left(G\right)$, GBP-ILP requires only an upper bound U on $b\left(G\right)$. Expression (23) guarantees that only one vertex for each coverage radius is selected and that these are increasing non-negative numbers starting at 0. Expression (24) guarantees that all vertices are burned. Figure 8 shows an optimal solution for GBP-ILP with input graph $P_9$.

$$\begin{array}{cc}\hfill \min & \sum _{j\in [1,U]}\sum _{v_i\in V}{x}_{i,j}\hfill \end{array}$$

(22)

$$\begin{array}{ccc}\hfill \mathrm{s}.\mathrm{t}.& \sum _{v_i\in V}{x}_{i,j}\le \sum _{v_i\in V}{x}_{i,j-1}\le 1\hfill & \hfill \forall j\in [2,U]\end{array}$$

(23)

$$\begin{array}{ccc}\hfill & 1\le \sum _{j\in [1,U]}\sum _{v_k\in N_{j-1}\left[v_i\right]}{x}_{k,j}\hfill & \hfill \forall v_i\in V\end{array}$$

(24)

$$\begin{array}{ccc}\hfill \mathrm{where}& x_{i,j}\in \{0,1\}\hfill & \hfill \forall v_i\in V,\forall j\in [1,U]\end{array}$$

(25)

$$\begin{array}{cc}\hfill & b\left(G\right)\le U\hfill \end{array}$$

(26)

So far, it seems like PROP-MILP, COV-CSP, and COV-ILP are somehow inferior to GBP-ILP. On the one hand, PROP-MILP involves twice as many variables as GBP-ILP. On the other hand, COV-CSP and COV-ILP need to be solved within a binary search procedure, effectively turning the GBP into a relatively large number of difficult subproblems. In fact, we implemented all the mentioned programs using Gurobi and found GBP-ILP to be the most practical. In more detail, we found Gurobi to be capable of solving GBP-ILP on instances with millions of vertices using a row generation method similar to the one used by Pereira et al. [56] (see Appendix A). However, this does not undermine the potential usefulness of the other programs. For instance, to define the following QUBO problems (see Section 4.5 and Section 4.6), we used COV-CSP as a basis.

Before closing this section, we note that GBP-ILP is similar to ILP-COV, a state-of-the-art program reported in 2025 [5]. However, the latter has n extra variables and two extra constraints, which makes GBP-ILP a more compact integer program. In the same way that we found ILP-PROP and PROP-MILP as well as ILP-CMCP and COV-ILP to be similar in practice using Gurobi, we found ILP-COV and GBP-ILP to be similar too. Therefore, we are not reporting such a comparison.

Summing up, up to this point, we have presented three mathematical programs that are more compact than similar state-of-the-art programs. In the next sections, we introduce two QUBO problems that, to the best of our knowledge, are not similar to any other state-of-the-art formulation for the GBP and are particularly useful in the context of quantum computing.

4.5. A QUBO Problem with Slack Variables: sQUBO

In this section, we define sQUBO, which results from embedding the constraints of COV-CSP into the objective function. For the equality constraints (13), we use the following observation:

$$y_1+y_2=1\iff 1-y_1-y_2+2y_1{y}_2=0,$$

(27)

which generalizes to any number of variables,

$$\sum _{1=1}^m{y}_i=1\iff 1-\sum _{i=1}^m{y}_i+2\sum _{i=1}^{m-1}\sum _{j=i+1}^m{y}_i{y}_j=0.$$

(28)

In more detail, the right part of Expression (28) evaluates to 1 when all variables are set to 0, evaluates to 0 when only one variable is set to 1, and evaluates to a positive number when two or more variables are set to 1. Thus, the minimum value of 0 is achieved by setting exactly one variable to 1.

To incorporate Constraints (14) into the objective function, we used the following observation:

$$\begin{array}{cc}\hfill \sum _{i=1}^m{y}_i\ge 1\iff & {\left(1-\sum _{i=1}^m{y}_i+\sum _{i=1}^{m^{\prime }}{2}^{i-1}{s}_i\right)}^2=0.\hfill \end{array}$$

(29)

By adding slack variables $s_i$, the right part of Expression (29) has a value of 0 when the left part is satisfied. Since the right part is squared, 0 is its minimum value. Using observations (28) and (29), we get the following QUBO problem for GBP, which we refer to as sQUBO:

$$\begin{array}{cc}\hfill \min & \sum _{j\in [1,g]}\left(1-\sum _{v_i\in V}{x}_{i,j}+2\sum _{v_i\in V}\sum _{k\in [i+1,n]}{x}_{i,j}{x}_{k,j}\right)\hfill \end{array}$$

(30)

$$\begin{array}{cc}\hfill & +\sum _{v_i\in V}{\left(1-\sum _{j\in [1,g]}\sum _{v_k\in N_{j-1}\left[v_i\right]}{x}_{k,j}+\sum _{\mathsf{\ell }\in [1,\lceil {log}_{2}g\rceil ]}{2}^{\mathsf{\ell }-1}{s}_{i,\mathsf{\ell }}\right)}^2\hfill \end{array}$$

(31)

$$\begin{array}{cc}\hfill \mathrm{where}& x_{i,j},s_{i,\mathsf{\ell }}\in \{0,1\}\forall v_i\in V,\forall j\in [1,g],\forall \mathsf{\ell }\in [1,\lceil {log}_{2}g\rceil ]\hfill \end{array}$$

(32)

The number of slack variables per vertex, $\lceil {log}_{2}g\rceil$, arises from the fact that exactly one vertex has to be chosen for every possible coverage radius. That is,

$$\sum _{j\in [1,g]}\sum _{v_k\in N_{j-1}\left[v_i\right]}{x}_{k,j}\le g.$$

(33)

Notice that if $g\ge b\left(G\right)$, all vertices must be covered; thus, the value of the optimal solution is 0. In the case of $g<b\left(G\right)$, the optimal solution size must be greater than 0. That is, while $g<b\left(G\right)$ leads to an infeasible COV-CSP problem, sQUBO is feasible regardless of the value of g. In this way, sQUBO can be integrated into a binary search. That is, lines 4 and 5 from Algorithm 1 should be replaced by

$$S\Leftarrow \mathrm{Solve}\mathrm{sQUBO}(G,g)$$

and

$$\mathbf{if}OPT=0\mathbf{then},$$

respectively. Although sQUBO correctly models the GBP, it has the disadvantage of requiring up to $n\lceil {log}_{2}g\rceil$ additional slack variables, which increases the size of the search space. Although these extra variables may not be a very serious problem for a classical optimization solver, they certainly are for a quantum computing one, where qubits are expensive resources. Since QUBO problems are one of the main modeling tools in quantum computing, it is important to avoid having many variables. To address this issue, we used an unbalanced penalization technique in the following section.

4.6. A QUBO Problem with Unbalanced Penalization: uQUBO

The unbalanced penalization technique reported in [57] models inequality constraints of the form

$$h\left(\mathbf{x}\right)=c-\sum _i{\mathsf{\ell }}_i{x}_i\le 0$$

(34)

with the approximation

$$e^{h\left(\mathbf{x}\right)}-1\approx {\lambda }_{a}h\left(\mathbf{x}\right)+{\lambda }_{b}h{\left(\mathbf{x}\right)}^2=f\left(h\left(\mathbf{x}\right)\right),$$

(35)

where ${\lambda }_a$ and ${\lambda }_b$ are penalization terms that can be fine-tuned for each specific problem (see Figure 9). Constraints (14) from COV-CSP can be incorporated into the objective function as Expressions (37) and (38). We refer to the resulting QUBO problem as uQUBO. Thanks to unbalanced penalization, slack variables are no longer required. However, as we show later, there is a price to pay.

$$\begin{array}{cc}\hfill \min & P\sum _{j\in [1,g]}\left(1-\sum _{v_i\in V}{x}_{i,j}+2\sum _{v_i\in V}\sum _{k\in [i+1,n]}{x}_{i,j}{x}_{k,j}\right)\hfill \end{array}$$

(36)

$$\begin{array}{cc}\hfill & +{\lambda }_1\sum _{v_i\in V}\left(1-\sum _{j\in [1,g]}\sum _{v_k\in N_{j-1}\left[v_i\right]}{x}_{k,j}\right)\hfill \end{array}$$

(37)

$$\begin{array}{cc}\hfill & +\sum _{v_i\in V}{\lambda }_{2,i}{\left(1-\sum _{j\in [1,g]}\sum _{v_k\in N_{j-1}\left[v_i\right]}{x}_{k,j}\right)}^2\hfill \end{array}$$

(38)

$$\begin{array}{cc}\hfill \mathrm{where}& x_{i,j}\in \{0,1\}\forall v_i\in V,\forall j\in [1,g]\hfill \end{array}$$

(39)

The penalization terms P, ${\lambda }_1$, and each ${\lambda }_{2,i}$ must be properly tuned. First, we must ensure that having $1,2,$ and up to g fire sources for each vertex is less penalized than any other option, where g is our guess on $b\left(G\right)$. We can accomplish this by setting ${\lambda }_{2,i}={\displaystyle \frac{{\lambda }_1}{g-1}}$ (see Equation (40)), which guarantees that a vertex having $1,2,$ and up to g fire sources contributes to the value of the objective function with a non-positive value $f\left(h\right(\mathbf{x}\left)\right)$ (see Figure 9).

$$f(1-g)={\lambda }_1(1-g)+{\lambda }_{2,i}{(1-g)}^2=0.$$

(40)

Now, Expression (36) must have a sufficiently large penalization P; otherwise, the solution may not be a valid burning sequence. The value of P must be higher than the absolute value of the smallest possible value of Expressions (37) and (38). In this way, the size of the optimal solution to uQUBO must be at most zero, which implies that all constraints modeled by expression (36) are satisfied. Since

$${\displaystyle \frac{d({\lambda }_{1}h\left(\mathbf{x}\right)+{\lambda }_{2,i}h{\left(\mathbf{x}\right)}^2)}{dh\left(\mathbf{x}\right)}}={\lambda }_1+2{\lambda }_{2,i}h\left(\mathbf{x}\right),$$

(41)

the smallest possible value that Expressions (37) and (38) can take for each vertex is $h\left(\mathbf{x}\right)={\displaystyle \frac{-{\lambda }_1}{2{\lambda }_{2,i}}}$. Namely,

$$f_{min}=f\left({\displaystyle \frac{-{\lambda }_1}{2{\lambda }_{2,i}}}\right)=-{\displaystyle \frac{{\lambda }_1^2}{4{\lambda }_{2,i}}}.$$

(42)

Thus, $P>|n{f}_{min}|$ ensures Expression (36) evaluates to zero, which means that one vertex is selected for each available covering radius. Now, notice that Expressions (37) and (38) lead to a situation where many vertices with many fire sources may be better than having all vertices burned. In other words, an optimal uQUBO solution may not even be feasible for the GBP. To solve this issue, we could fine-tune each ${\lambda }_{2,i}$ according to the exact number of fire sources that $v_i$ should have. Unfortunately, this approach requires knowing an optimal solution in advance. Instead, the best we can do is to use some feasible solution to heuristically adjust the values of each ${\lambda }_{2,i}$. In this manner,

$${\lambda }_{2,i}=\left\{\begin{array}{cc}{\displaystyle \frac{{\lambda }_1}{{\mathsf{\ell }}_i-1}}\hfill & \mathrm{if}{\mathsf{\ell }}_i\ge 2\hfill \\ {\lambda }_1\hfill & \mathrm{if}{\mathsf{\ell }}_i=1\hfill \end{array}\right.,$$

(43)

where ${\mathsf{\ell }}_i$ is the number of fire sources for each $v_i\in V\left(G\right)$ in some previously computed burning sequence. Any heuristic or approximated algorithm can be used to efficiently compute such a burning sequence. Notice that this fine-tuning leads to larger values of ${\lambda }_{2,i}$ because ${\mathsf{\ell }}_i\le g$. Thus, the previous tuning of P remains valid. Although this approach does not guarantee optimality, our experiments indicate that it is sufficiently effective for practical purposes. Nevertheless, it is important to emphasize that for arbitrary instances, the optimal solution to uQUBO is not guaranteed to be a valid burning sequence; this is the cost of not having slack variables. Finally, to integrate uQUBO into a binary search, lines 4 and 5 from Algorithm 1 should be replaced by

$$S\Leftarrow \mathrm{Solve}\mathrm{uQUBO}(G,g)$$

and

$$\mathbf{if} S \mathrm{is} \mathrm{a} \mathrm{burning} \mathrm{sequence} \mathbf{then},$$

respectively. To assess how often uQUBO yields optimal burning sequences, we solved it using Gurobi 12.0.3 [7] and tested it on Erdős–Rényi and geometric random graphs. The results are reported in

Table 1. Percentage of optimal burning sequences found by Gurobi using uQUBO within a binary search. One hundred Erdos–Rényi graphs were generated for each pair of parameters $(n,p)$; $\langle c\rangle$ represents the average number of connected components.

p	n	9				12				15
	${\mathit{\lambda }}_{\mathbf{2},\mathbf{i}}$	${\displaystyle \frac{\mathbf{1}}{\mathit{g}-\mathbf{1}}}$	${\displaystyle \frac{\mathbf{1}}{{\mathsf{\ell }}_{\mathbf{i}}-\mathbf{1}}}$	$\langle \mathbf{c}\rangle$		${\displaystyle \frac{\mathbf{1}}{\mathit{g}-\mathbf{1}}}$	${\displaystyle \frac{\mathbf{1}}{{\mathsf{\ell }}_{\mathbf{i}}-\mathbf{1}}}$	$\langle \mathbf{c}\rangle$		${\displaystyle \frac{\mathbf{1}}{\mathit{g}-\mathbf{1}}}$	${\displaystyle \frac{\mathbf{1}}{{\mathsf{\ell }}_{\mathbf{i}}-\mathbf{1}}}$	$\langle \mathbf{c}\rangle$
$1/2n$		13%	100%	7.05		6%	100%	9.10		2%	100%	11.37
$1/n$		14%	100%	5.05		2%	100%	6.73		2%	100%	7.92
$3/2n$		48%	100%	3.49		26%	100%	4.39		15%	100%	5.13
$2/n$		73%	100%	2.38		58%	100%	2.73		42%	100%	3.25
$5/2n$		84%	100%	1.73		79%	100%	1.88		70%	100%	2.20
$3/n$		95%	100%	1.29		90%	100%	1.45		88%	100%	1.63
$7/2n$		98%	100%	1.13		94%	100%	1.25		90%	100%	1.28
$4/n$		100%	100%	1.06		99%	100%	1.11		98%	100%	1.16
$9/2n$		100%	100%	1.02		100%	100%	1.07		98%	100%	1.10
$5/n$		100%	100%	1.01		100%	100%	1.03		100%	100%	1.04

and

Table 2. Percentage of optimal burning sequences found by Gurobi using uQUBO within a binary search. One hundred geometric random graphs were generated for each pair of parameters $(n,r)$; $\langle c\rangle$ represents the average number of connected components.

r	n	9				12				15
	${\mathit{\lambda }}_{\mathbf{2},\mathbf{i}}$	${\displaystyle \frac{\mathbf{1}}{\mathit{g}-\mathbf{1}}}$	${\displaystyle \frac{\mathbf{1}}{{\mathsf{\ell }}_{\mathbf{i}}-\mathbf{1}}}$	$\langle \mathbf{c}\rangle$		${\displaystyle \frac{\mathbf{1}}{\mathit{g}-\mathbf{1}}}$	${\displaystyle \frac{\mathbf{1}}{{\mathsf{\ell }}_{\mathbf{i}}-\mathbf{1}}}$	$\langle \mathbf{c}\rangle$		${\displaystyle \frac{\mathbf{1}}{\mathit{g}-\mathbf{1}}}$	${\displaystyle \frac{\mathbf{1}}{{\mathsf{\ell }}_{\mathbf{i}}-\mathbf{1}}}$	$\langle \mathbf{c}\rangle$
$0.09$		5%	100%	5.77		3%	100%	6.28		6%	100%	5.96
$0.13$		26%	100%	4.48		30%	100%	4.18		37%	100%	3.50
$0.17$		50%	100%	3.39		62%	100%	2.60		69%	100%	2.15
$0.21$		67%	100%	2.61		78%	100%	1.86		89%	100%	1.51
$0.25$		83%	100%	1.97		90%	100%	1.45		98%	100%	1.22
$0.29$		85%	100%	1.63		94%	100%	1.25		97%	100%	1.12
$0.33$		95%	100%	1.30		99%	100%	1.11		100%	100%	1.04
$0.37$		98%	100%	1.15		100%	100%	1.07		100%	100%	1.03
$0.41$		99%	100%	1.08		100%	100%	1.03		100%	100%	1.01
$0.45$		100%	100%	1.05		100%	100%	1.01		100%	100%	1.00

. In both cases, we compared ${\lambda }_{2,i}=1/(g-1)$ and ${\lambda }_{2,i}=1/({\mathsf{\ell }}_i-1)$. For all experiments, we set ${\lambda }_1=1$, and the guiding feasible solution was provided by the polynomial-time greedy algorithm, Gr, from [5]. As these tables show, ${\lambda }_{2,i}=1/(g-1)$ led to poor performance, particularly in graphs with many connected components, whereas ${\lambda }_{2,i}=1/({\mathsf{\ell }}_i-1)$ enabled uQUBO to successfully solve all graph instances. Since QUBO problems are relatively hard to solve in classical optimization solvers, we had to constrain the experiments to small instances.

5. Discussion

The proposed mathematical programs show the versatility with which the GBP can be formulated. Each program highlights different aspects of the problem, and their relative advantages depend on the context in which they are applied. For example, PROP-MILP is intuitive and reflects the propagation process, but at the expense of requiring $2Un$ variables, which makes it less practical for modeling large graphs. In contrast, COV-CSP and COV-ILP are more compact formulations that leverage the relationship between the GBP and the CMCP. While COV-CSP is infeasible when the burning number is underestimated, COV-ILP is always feasible. A more practical program is GBP-ILP, which avoids using binary search and maintains a low number of variables, $Un$. From a classical computing point of view, GBP-ILP is “better” than all other programs. However, that does not undermine the potential of the other programs. For instance, COV-CSP, which stands out as the simplest program, is the basis for sQUBO and uQUBO, which are of interest in the context of quantum computing. Regarding MILP-PROP and GBP-ILP, it is worth noting that having a good upper bound U can drastically reduce the size of the search space and the number of constraints, which is particularly useful for branch-and-bound-based solvers whose running time is highly dependent on the number of vertices of the feasible region. Thus, for practical purposes, PROP-MILP and GBP-ILP must rely on polynomial-time heuristics and approximation algorithms to get a good upper bound. In fact, the same kind of dependence applies to uQUBO, which requires a guess on the number of fire sources for each vertex in the input graph.

Table 3. Main attributes of the proposed mathematical programs. A ✓ symbol indicates that the program requires being solved within a binary search.

Program	Variables	Constraints	Binary Search	Pros	Cons
PROP-MILP	$2Un$	$Un+U+n$	-	Explicit propagation process	Large number of variables and constraints
COV-CSP	$gn$	$g+n$	✓	Simplest program	Can be infeasible
COV-ILP	$gn$	$g+n-1$	✓	Always feasible	Binary search
GBP-ILP	$Un$	$2U+n-1$	-	Straightforward	-
sQUBO	$gn+n\lceil {log}_{2}g\rceil$	-	✓	No penalty tuning	Slack variables
uQUBO	$gn$	-	✓	Few variables	Penalty tuning

reports the main attributes of the proposed mathematical programs.

The proposed QUBO problems, sQUBO and uQUBO, extend the scope of the GBP to quantum computing. sQUBO guarantees correctness at the expense of additional slack variables, whereas uQUBO significantly reduces the search space by eliminating them. However, this simplification introduces the risk of obtaining optimal solutions that are not burning sequences. Nevertheless, our experiments indicate that with a simple adjustment of penalization parameters, uQUBO achieves consistent optimality on Erdős–Rényi and geometric random graphs. This suggests that QUBO formulations may provide a practical avenue for solving the GBP on both classical and quantum hardware.

Finally, in Appendix A, we show that Gurobi can solve challenging instances of GBP-ILP using a row generation method in reasonable amounts of time. For example, it solved a graph with more than 4 million vertices in no more than 19 min. More challenging instances, such as large square grids, were solved in up to 2.6 h.

6. Conclusions

This paper presents an overview of mathematical programs for the GBP. Compared to existing programs in the literature, the proposed ones are conceptually simpler and have fewer variables and constraints, making them attractive for both theoretical analysis and practical computation. In other words, the introduced programs are, to the best of our knowledge, the most compact reported in the literature. Although we implemented and tested all the mentioned programs, we decided not to report such results for the following reason: any comparison between programs would be empirical and biased towards a specific algorithmic technique. Thus, we decided to compare all programs in a more objective manner, i.e., in terms of their number of variables and constraints.

The relevance of the proposed programs lies not only in their immediate applicability, but also in their potential to inspire methods for related contagion and propagation models. In addition, variants of the GBP can be modeled in a similar way. However, limitations remain: large-scale instances continue to challenge exact methods, and tuning of penalization parameters in QUBO models with unbalanced penalization still requires heuristic guidance and thus cannot guarantee optimality for arbitrary instances. Future research should explore hybrid classical–quantum approaches, as well as heuristic, metaheuristic, and matheuristic search. As a by-product, we corroborated the burning number of some large graphs reported by Pereira et al. [56] and found the burning number of some other challenging graphs.