{'fraction_non_alphanumeric': 0.038534271630963825, 'fraction_numerical': 0.00837027621911523, 'mean_word_length': 4.35580275610161, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 3, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Learning chordal extensions

A highly influential ingredient of many techniques designed to exploit sparsity in numerical optimization is the so-called chordal extension of a graph representation of the optimization problem. The definitive relation between chordal extension and the performance of the optimization algorithm that uses the extension is not a mathematically understood task. For this reason, we follow the current research trend of looking at Combinatorial Optimization tasks by using a Machine Learning lens, and we devise a framework for learning elimination rules yielding high-quality chordal extensions. As a first building block of the learning framework, we propose an on-policy imitation learning scheme that mimics the elimination ordering provided by the (classical) minimum degree rule. The results show that our on-policy imitation learning approach is effective in learning the minimum degree policy and, consequently, produces graphs with desirable fill-in characteristics.


Introduction
A simple undirected graph G = (V, E) is chordal if, for every cycle c of length at least four, there exists an edge e ∈ E that connects two non-consecutive vertices of c. A chordal extension of a graph G is a chordal graph H such that G is a sub-graph of H, i.e., one can obtain H by adding edges to G. A practical way of constructing chordal extensions is via graph elimination [1], which consists in sequentially eliminating the nodes of the graph. At each step, a node v is selected, new edges are inserted so as to make the neighbors of v into a clique, then v is removed (i.e., eliminated). This process is repeated until all nodes have been eliminated, and one obtains a chordal extension by adding to the original graph all edges that were inserted in the process. The order in which nodes were eliminated is thereby called an elimination ordering.
This work focuses on the role of chordal extensions and graph elimination within optimization frameworks. Indeed, there is a direct connection between chordal extensions, which are typically computed via graph elimination, and a number of classical sparsity-exploiting techniques [2,1]. In particular, we seek to devise a framework for learning elimination rules that yield high-quality chordal extensions, as we illustrate below.
Our first motivating example is the computation of a fill-reducing ordering for sparse Cholesky factorization, a process that reduces to computing an elimination ordering [3,1]. Crucially, Cholesky factorization underlies most implementations of interior-point algorithms for linear programming [2,4], and the choice of ordering can have a major impact on the method's performance [5]. Similarly, chordal graphs form the basis of chordal decomposition techniques to exploit sparsity in semi-definite programming (SDP) problems, see, e.g., [6,7]. Specifically, a single, dense, semi-definite constraint, can be decomposed into several smaller, yet coupled, semi-definite constraints. This reformulation also reduces to computing a chordal extension, and can dramatically improve the performance of both interior-point and first-order methods on large problems [8,7]. More generally, a similar approach can be leveraged in linear conic optimization and convex optimization, see, e.g., [1].
Historically, efforts have focused on computing minimum chordal extensions, i.e., chordal extensions with a minimum number of additional edges [5,9], which has been proven to be NP-complete [10]. This fostered the development of fast and efficient heuristics such as minimum degree [11] and nested dissection [12] orderings. State-of-the-art implementations of these methods are routinely used in most optimization and sparse linear algebra software, where they tackle problems with up to millions of variables. Nevertheless, which chordal extension is computed can significantly impact the subsequent performance of the optimization algorithm. Therefore, it is natural to seek a "best" chordal extension, i.e., one that maximizes performance.
Recently, the use of Machine Learning (ML) in Combinatorial Optimization (CO) became a popular research area with quite a number of contributions investigating many angles of such a connection. On the one hand, some research has been devoted to solve CO problems by ML, i.e., to devise new heuristic algorithms that perform the end-to-end learning of the solution of a CO problem. On the other hand, ML has been used to tackle some tasks within CO algorithms and software for which modern statistical learning has chances to improve the current performances, either because the known way of performing those tasks is computationally heavy or because they are poorly understood from the mathematical standpoint. The interested reader is referred to [13] for a methodological survey on this new research area.
Our work does not follow the first direction outlined in the previous paragraph. Indeed, the goal of this paper is not to compete with existing state-of-the-art heuristics for graph elimination. First, these heuristics leverage decades of development and clever engineering, and have been optimized for fast runtime and good solution quality. Second, and more importantly, the aim of our work is to eventually gain deeper understanding of the relation between the characteristics of a chordal extension and the behavior of optimization algorithms and software, a topic of interest in its own right and whose mathematical knowledge is currently insufficient. In order to achieve this ultimate goal, our present contributions are 1) to propose a mathematical framework for the problem of learning elimination orderings, and 2) to provide methodological and practical insights on the learning process itself. As a byproduct, a better understanding of what "good" chordal extensions look like (for a specific task) can lead to an easier and more direct customization of elimination orderings to sets of similar graphs.
The rest of the paper is organized as follows. In Section 2, we introduce some relevant definitions and concepts. In Section 3, we present our methodology for learning chordal extensions. In Section 4, we report on numerical experiments. Section 5 gives further discussion and Section 6 concludes the paper.

Basic notations and concepts
In this section, we review some notations and concepts used in the remainder of the paper. Section 2.1 introduces basic notations and definitions of graphs and Section 2.2 introduces a commonly used model for sequential decision problems. In Sections 2.3 and 2.4, we briefly go through some Machine Learning concepts, in order to help the reader be familiar with relevant ML methods and properly locate the methodology we propose in Section 3.
In all that follows, for an arbitrary set S, we use the notation P(S) to denote the set of all probability distributions over S.

Graph-theoretic notations
In this paper, all considered graphs are simple, undirected graphs. A graph is denoted by G = (V, E), where V (resp. E) denotes the set of its nodes (resp. its edges). For an edge e = (v, w), we say that e is incident to v and w, that v, w are the extremities of e, and that v, w are adjacent. The neighborhood of v, denoted by N G (v), is defined as the set of nodes that are adjacent to v.
The degree of node v in G is denoted by δ G (v). We say that node v is of minimum degree if δ G (v) ≤ δ G (w) holds for all nodes w ∈ V . Note that several nodes of minimum degree may exist.
In what follows, we will drop the subscript G whenever context is sufficiently clear, and write for example δ(v) rather than δ G (v).

Markov Decision Processes
Markov Decision Processes (MDPs) [14] are wildly used to formulate sequential decision problems. An MDP is characterized by a set of possible states S, a set of possible actions A, the dynamics of the system, and a cost function.
Formally, an MDP is defined by a tuple (S, A, P, c), where P encodes the system's dynamics, and c encodes the cost function. For any state-action pair (s, a) ∈ S × A, P (s, a) is a probability distribution over the state space S. That is, if one takes action a in state s, the next observed state s will be sampled from the distribution P (s, a) ∈ P(S). Finally, the cost of executing action a in state s is denoted by c(s, a).
Given an MDP (S, A, P, c), a policy is a decision rule for selecting an action a, given a current state s. Specifically, a policy π is a function π : S −→ P(A) (1) and the next action a is sampled from π(s) ∈ P(A). If a policy π maps each state to a single action, i.e., if π(s) is a degenerate distribution for every s ∈ S, then π is called a deterministic policy; otherwise it is called a stochastic policy. For the remainder of this paper, we will only consider stochastic policies, and we define the expected immediate cost for policy π in state s ∈ S as A trajectory is a sequence of state-action pairs (s 0 , a 0 ), (s 1 , a 1 ), ... where s t+1 is sampled from P (s t , a t ). In this paper, all trajectories will always be finite, although they may be of arbitrary length. We say that a trajectory is sampled from a policy π if each action a t is sampled from π(s t ). The total cost along a trajectory is then given by which is always finite since we only consider finite trajectories. Finally, for a distribution of initial states D 0 ∈ P(S), we define the expected total cost of a policy π as where E π denotes that trajectories are sampled from π. Furthermore, D 0 and π induce a stationary distribution over states, which we denote by D π . Thus, we define the expected average cost of policy π as In this work, we assume that the above two expectations are always finite; we make this mild technical assumption to ensure that the learning problems defined in Section 2.4 are well-defined. For ease of reading, we also drop the explicit dependency of C tot π and C avg π on D 0 , since the latter will always be evident from the context.

Standard statistical learning
In statistical learning, the goal is to detect patterns from a set of observed data and make predictions about future data. We can formalize the standard statistical learning problem as follows. Given a variable space Z and a set of examples D Z = {z 1 , z 2 , . . . , z m } from the unknown distribution P(Z), the task is to find a function f over a family of functions F, such that f "performs well" on P(Z). It is assumed that all the observed examples are drawn independent and identically distributed (i.i.d.) from the same distribution P(Z).
If a loss function L : F × Z → R is specified to measure the performance of f , then the goal can be described as findingf ∈ F that minimizes the expected loss with respect to P(Z), i.e., The learned functionf is then used to predict future data. However, the expected loss cannot be computed exactly due to the fact that P(Z) is unknown. In practice, if a subset of examples D Z sampled from P(Z) is available, a number of learning methods turn to minimize the empirical loss on D Z . Then,f is obtained by solvinĝ The differences in forms and contents of Z, F, L result in different learning tasks. Here, we only introduce supervised learning that is the relevant task for the current state of our work.
Supervised learning. In supervised learning, the variable space Z consists of X × Y, where X is the space of input variables and Y is the space of output variables. The family of functions F is a set of mappings f : X → Y. For any sample (x, y) ∈ X × Y , the loss function L measures the discrepancy between f (x) and y. Ideally, the output Y can be in any form or intent. However, most tasks assume that Y is categorical or nominal. The former characterizes the task as classification, whereas the latter induces regression.
In IL, the target policy learns its decision rule from an expert policy. More precisely, given the class of candidate policies Π, we seek to find a target policy π ∈ Π that matches the expert policy π * . The target and expert policy are often referred as the learner and the expert. The cost is defined by a loss function L(π, π * ), a measure of discrepancy between π and π * . If a behavior policy π is set to generate trajectories of states, the goal is to find a policyπ that minimizes the expected loss with respect to the distribution of states induced by π , namelŷ In the literature, depending on the choice of behavior policy, IL algorithms can be divided into two classes: off-policy and on-policy methods. The offpolicy methods are the ones with behavior policy π independent of the learner π. For instance, the supervised approach for imitation learning falls into this class. On the other hand, if the behavior policy depends on the learner, the algorithm becomes an on-policy method. Data Aggregation (DAGGER) [17] and its variants are examples of on-policy methods.
Supervised imitation learning. The supervised approach for IL fixes the behavior policy as the expert, i.e., π = π * . Then the learner is trained under the distribution induced by the expert, given bŷ Data Aggregation. DAGGER is an iterative algorithm that improves the learner by executing a mixed behavior policy combined with the learner and the expert. At each iteration, the collected data will be aggregated into an accumulated dataset and the learner will be trained by all the data collected from previous iterations.

Methodology
In this section, we present our methodology for learning chordal extensions.
In this work, we focus on how to learn elimination rules for graph elimination via imitation learning. More precisely, we propose an on-policy imitation learning scheme that mimics the elimination ordering provided by the ordering heuristic we choose.

MDP formulation
We begin by formulating graph elimination as a Markov decision process. First, the state space S is the set of simple undirected graphs. Then, for a given graph G = (V, E), the corresponding set of possible actions is identified by the nodes of the graph. Transitions are deterministic: if an action a = v is performed in state G, i.e., if node v is eliminated from graph G, then the new state is uniquely defined as the graph obtained from the elimination of node v. Note that the number of nodes decreases by one at each step. Hence, even though the initial graph may be of arbitrary size, trajectories are always finite. Thus, a policy π maps a graph to a probability distribution over its set of nodes V . Therefore, if V = {1, ..., n}, then π(G) is a n-dimensional non-negative vector, whose i-th coordinate denotes the probability that node i be eliminated.
Finally, one may select a cost function according to the problem at hand, for example, the number of additional edges, i.e., fill-in. In that case, finding a policy that minimizes the expected total cost reduces to finding a policy that yields minimum chordal extensions. Rather than trying to minimize fill-in, which is an NP-hard problem for which efficient heuristics already exists, we adopt a more generic imitation learning scheme as discussed below.

On-policy imitation learning
Although the goal of imitation learning is to find a learner that best matches the expert, any parameterized stochastic policy will inevitably have chances to make occasional mistakes by choosing an action different from the expert. In the supervised imitation learning approach, where the learner is only trained under the distribution of states induced by the expert, the learner may not be able to correct its behavior from deviations induced by its bad choice of action.
Moreover, any possible state is observable in our problem setting and the expert is always accessible for querying any state. Therefore, we choose on-policy approach in order to be more robust to alleviate the deviation problem. Specifically, we set the learner as the behavior policy, i.e., π = π. As a result, the goal is to find a policyπ such that Since, in general, the expected loss cannot be computed analytically, we estimate it by sampling trajectories of states from finite dataset using π. Given a dataset G of M graphs, we train the learner with our practical algorithm, namely one-step on-policy imitation learning, as described in Algorithm 1.
Algorithm 1: One-step on-policy imitation learning Input: Initialize π θ to any policy in Π; for i = 1 to N do for each g ∈ G do Initialize s; for j = 1 to T do θ ← θ − α∇ θ L (π θ (s), π * (s)); a ← π θ (s); Take action a, observe next state s; end end end return π θ The training proceeds as follows. At every epoch i (from 1 to N ), each instance G = (V, E) ∈ G is used to generate one complete trajectory (with length T = |V |), and each state (i.e., graph) in this trajectory represents a training data point. The one-step updating is as follows. At every transition, i.e., at every elimination step, the leaner π θ is updated by taking a gradient step with respect to the loss L (π θ (s), π * (s)), where s is the current state. An action a is then sampled from the updated learner π θ , which yields the next state s . Note that, in this setting, the loss is computed by comparing the two distributions π θ (s) and π * (s) directly. We do so because 1) we know analytically both the learner and the expert, and 2) it allows to exploit information from the entire distributions rather than sampling and comparing individual actions.
Expert. We consider the minimum degree heuristic [22,11] as the expert. At each step, the minimum degree selects a node of minimum degree to be eliminated. Ties are broken arbitrarily, i.e., if several nodes have minimum degree, then one is selected uniformly at random among them. Let us note that today's implementations include several additional features, such as smarter tie breaking or the simultaneous elimination of multiple nodes.
In all that follows, we denote π M D the minimum-degree policy, i.e., for a given graph G = (V, E), we have where k is the number of nodes that have minimum degree.
Learner parameterization. Given that states are represented as graphs, with arbitrary size and topology, we propose to use graph neural networks (GNNs) [23,24] to parameterize the learner. Indeed, GNNs is an expressive type of model to process graph-structured data and have been applied to a variety of representation learning tasks on graphs [25,26,27,28,29]. In GNN models, a graph is embedded according to the features of vertices and its topological structure. The encoding of a node is generated by propagating information from its neighborhood. One of the most appealing properties of GNNs is that it is size-and-order invariant to input data, i.e., it can process graphs of arbitrary size, and the ordering of the input elements is irrelevant. In our GNN architecture, the embedding of the graph in the (l+1)-th layer is computed by aggregating, for each node, the features of its neighborhood from the l-th layer, i.e., where A∈R n×n is the adjacency matrix of the graph, I n×1 is the matrix of ones with size of n × 1, d l and d l+1 are the dimension of the features in layer l and (l + 1), H l+1 ∈R n×d l+1 and H l ∈R n×d l are the embeddings of layer (l + 1) and l, W l ∈R d l ×d l+1 and B l ∈R 1×d l+1 are the parameters in layer l, and f (·) specifies the activation function. For f (·), we apply Sof tmax in the output layer and Relu in the rest.
Loss function. Since the expert is the minimum degree heuristic, we can compute the exact π M D (s) given a state s of a graph as shown before. To measure the distance between two distributions given by the learner and the expert respectively, we compute the Kullback-Liebler (KL) divergence [30] between π M D (s) and π(s) as the loss.

Numerical experiments
In this section, we report the details of our computational investigation. More precisely, Section 4.1 specifies the data generation and collection. In Section 4.2, we discuss the experimental setting and, finally, Section 4.3 reports the computational results.

Data collection
We evaluate our approach on four different datasets, which comprise graphs that vary in size and structural characteristics.

Erdos-Renyi graphs
We first build two datasets of Erdos-Renyi graphs, a simple and well-known class of random graphs. We use the notation G(n, p) to denote a (random) Erdos-Renyi graph with n nodes, and such that edges are selected with probability p ∈ [0, 1] independently of each other. Note that, for given n and p, G(n, p) is a random variable whose realizations are graphs of size n. While n controls the size of the graph, p controls its sparsity. We form two datasets of Erdos-Renyi graphs: one of smaller graphs, denoted ER S , and the other one of larger graphs, denoted ER L .
Each graph in ER S , is sampled from G(n, p), where n is drawn uniformly between 100 and 300, and p is sampled between 0.1 and 0.3 with uniform probability. This is done to introduce some variability in size and density in the dataset. Overall, ER S contains 600 graphs. We follow the same methodology for ER L , except that n is drawn uniformly between 300 and 500. Overall, ER L contains 200 graphs.

SuiteSparse matrix collection
The SuiteSparse matrix collection 1 [31] is a dataset of (sparse) matrices collected from a number of real-life applications, and is routinely used as benchmark for numerical linear algebra software. Given a matrix M , we construct a non-oriented graph whose adjacency matrix corresponds exactly to the sparsity structure of M . We only consider square matrices, and any non-symmetric matrix is transferred into symmetric by adding its transpose to it.
First, we select square matrices of size between 50 and 500. This yields a dataset of 278 graphs, which we denote by SS S . Similarly, we select square matrices of size between 1000 and 2000, and obtain a second dataset, denoted by SS L , which contains 295 graphs.

Experimental settings
Our experiments were conducted on a dual Intel Xeon Gold 6126@2.60GHz, 768BG RAM machine running Linux and equipped with Nvidia Tesla V100 GPUs. Our code 2 is written in Python 3.6, and we use Pytorch 0.4 for modeling and training GNNs.
Datasets. We split the ER S dataset into {training, validation, test}, each containing 200 graphs. Our GNN policy is trained and validated only with the training and validation set of ER S , respectively. Then, we test the generalization performance of the trained model with the test set of ER S , ER L , SS S and SS L .
GNN setting. We apply the GNN architecture described in Section 3.2 with 2 layers. As initially the vertices of the graphs have no attribute, we initialize the feature of each vertex with the same value. Specifically, we take h 0 v = 1, ∀v ∈ V . As a result, the encoding of each vertex only depends on the topological structure of its neighborhoods. The dimension of features in all layers is the same. For each layer, the weights are initialized from Xavier normal distribution [32] and we initialize the bias with zero.
Performance metrics. For a finite dataset G, the first metric computes the average KL loss, given bŷ where n g is the size of each graph g ∈ G and L KL (·) specifies the KL divergence between π θ (s i ) and π M D (s i ) in state s i of g.
To measure the fill-in of a policy, the second metric computes the average number of fill-in per graph. For each graph g ∈ G, we denote the total number of fill-in by c g f illin . Then, the average fill-in per graph is given bŷ Training and validation. We train our GNN policy with Algorithm 1.
At each epoch, we randomly shift the training set and sample single-graph mini batches. For learning rate tuning, we experiment different learning rates from 10 −5 to 10 −3 . The validation result is shown by plotting the average KL loss and the average fill-in per graph in Figure 1. Observing that 10 −4 yields fast and smooth convergence, we train the model with the learning rate of 10 −4 for 20 epochs. Moreover, we also observe a plateau effect for larger step size in Figure 1, notably, sudden decrease with larger step size. This effect will be discussed in Section 5. Test. We test the generalization performance of trained GNN with four test sets as specified before. Addtionally, to evaluate the performance of GNN models at different stages of training, we first save the trained model at the end of each epoch. Then, we test the performance of each saved model on four test sets.

Results
In this section, we compare the predictive performance of GNN with the two metrics introduced in the previous section. The results on the training set and four test sets are shown in Figure 2. Specifically, we plot the curves of two metrics over the entire training period (20 epochs), in order to compare the performance of GNN models at different stages of training. From the results of the training set (shown in the first row of Figure 2), we observe that the loss significantly decreases and stabilizes after about 15 epochs of training. Moreover, for fill-in, the GNN also matches the minimum degree heuristic.
Comparing the results of different test sets, we observe that our GNN generalizes well, both to larger size graphs and to different distributions. First of all, loss curves of all datasets show same decreasing tendency over the entire training period, although the magnitude of values can be different across datasets. In terms of fill-in, we have similar and consistent results. Moreover, by comparing the curves in each row, we also observe a strong correlation between KL loss (i.e., how good we replicate the minimum degree expert), and the actual fill-in (which is only observed, we never learn anything from it).
It is worth noting that, although the initial graphs can be i.i.d., the other states in the trajectory always depend on previous states and actions, which indicates the induced distribution of states depends on the behavior policy itself.
Since we use the on-policy imitation learning approach, the loss is measured under the distribution of states induced by our GNN policy. As GNN model changes during training, this metric is actually measured under different distributions. As a result, the decrease of loss over the training period (shown on the left side of Figure 2) only shows a tendency that the GNN replicates the minimum degree expert better on an evolutionary distribution induced by itself. The predictive performance of the GNN still needs to be validated by the actual fill-in, which is precisely done on the right side of Figure 2.

Further discussion
We now seek to further explain the sharp drops in loss that were observed during training, e.g., in Figure 1, and the stark correlation between imitation loss and fill-in.
To do so, we consider the following GNN with two layers: where w 1 , w 2 ∈ R are the only two scalar parameters of the GNN, and x 0 , h 1 , x 1 , h 2 , x 2 are vectors of size |V |. The input vector is x 0 with all coordinates equal to one and, by definition of Sof tmax, the coordinates of the output vector x 2 are all non-negative and sum to one. Also note that, for every node i, since x 0 i = 1, we have h 1 i = w 1 δ(i). It follows that, by setting w 1 = 0, we get x 1 i = Relu(1 + 0) = 1, and then h 2 i = w 2 × δ(i). Therefore, as w 2 approaches −∞, x 2 becomes arbitrarily close to a minimum degree distribution.

Landscape of the loss function
We begin by plotting the landscape of the expected average KL loss, evaluated on the training set. This landscape is represented in Figure 3. Although this corresponds to a simpler model than the one that yielded the results in Section 4.3, it gives several insights into the behavior during training.
First, as expected, the average loss is minimized when w 1 = 0 and w 2 goes to −∞.
Second, we observe that in the w 1 ≤ −1 region, the average loss is flat. This region actually corresponds to the Relu of the first layer being inactive. Indeed, we have h 1 i = w 1 δ(i), therefore, when w 1 ≤ −1, we automatically get 1 + h 1 i ≤ 0, which yields x 1 i = 0. Consequently, the output of the GNN is a uniform distribution on the nodes of the graph, i.e., we obtain x 2 i = 1 n for each node i ∈ {1, ..., n}.
Third, observe that the landscape of the loss function displays fairly flat regions, which tend to be separated by sharp drops in the objective, e.g., around the w 1 = 0 region. This landscape most likely explains the shapes of the training curves in Figure 1, which displayed flat progression followed by sharp drops in the loss. Whether such behavior would carry out in larger dimensions remains an open question.

Landscape of the fill-in
We then plot the landscape of the expected total fill-in in Figure 4, also evaluated on the training set. While this gives us an insight into how fill-in correlates with the KL loss, let us formally restate that fill-in is never used during the training process. In particular, no gradient information is ever inferred from fill-in.
Fist, unsurprisingly, similar to Figure 3, here we observe a flat landscape in the w 1 ≤ −1 region. Recall indeed that setting w 1 ≤ −1 means the GNN's output reduces to a uniform policy. Second, the region w 1 ≥ 0, w 2 ≥ 0 displays high fill-in. This is not surprising either since this region essentially yields policies that select nodes with high degree, which is naturally detrimental to fill-in.
A third and more remarkable observation is the flat valley in the region w 1 ≥ 0, w 2 ≤ 0. While we know that the GNN policy converges to minimum degree when w 1 = 0 and w 2 takes large negative values, the plots in Figure 4 show that, when it comes to fill-in, the magnitude of w 2 does not matter as much.
Fourth and last, the minimum degree policy appears to be a minimizer of the expected total fill-in, among the set of policies that are representable by the class of GNN at hand. Although we cannot extrapolate to larger classes of models, nor to other datasets of graphs, this last observation has Figure 4: Landscape of the normalized total fill-in. For each (w 1 , w 2 ), we plot the average total fill-in of the corresponding GNN policy, divided by the expected total fill-in of the minimum degree heuristic. Both expectations are estimated over the training set.
consequences if one were to train a GNN to minimize fill-in. Specifically, one would need models with higher representation power to achieve better fill-in than the minimum degree algorithm.

Conclusion
In this work, we have considered chordal extensions and graph elimination as major factors for devising sparsity-exploiting techniques for optimization algorithms. We have argued that, although effective heuristics to perform graph elimination (an NP-complete task) exist, there is no definitive understanding of the effect of the obtained chordal extension on the optimization algorithm using the final graph representation.
For this reason, we have followed the current research trend of looking at Combinatorial Optimization tasks by using a Machine Learning lens and we have devised a framework for learning elimination rules yielding high-quality chordal extensions. As a first building block of the learning framework, we have proposed an on-policy imitation learning scheme that mimics the elimination ordering provided by the (classical) minimum degree rule.
The results have shown that our on-policy imitation learning approach is effective in learning the minimum degree policy and, consequently, produces graphs with desirable fill-in characteristics. In addition, the learned policy displays remarkable generalization performance, a desirable behavior since it allows to speed-up the learning process by training on smaller problems.
Finally, we identify two main research avenues for subsequent developments. On one hand, while GNNs are a good model prior for combinatorial problems over graphs, enlarging their representation power, for instance to represent hypernodes or to model multiple eliminations, will likely be key to handling practical tasks. On the other hand, the next logical step will be to learn elimination rules that explicitly address the performance of practical optimization algorithms, in conjunction with reinforcement learningbased approaches. In that regard, our future work will investigate chordal decomposition specially tailored to SDP optimization problems.