Original: L EARNING C OMBINATORIAL N ODE L ABELING A LGORITHMS
Revised: L EARNING C OMBINATORIAL N ODE L ABELING A LGORITHMS

Original: Anonymous authors
Revised: Anonymous authors

Original: Paper under double-blind review
Revised: Paper under double-blind review

Original: A BSTRACT
Revised: A BSTRACT

Original: We present the combinatorial node labeling framework, which generalizes many prior approaches to solving hard graph optimization problems by supporting problems where solutions consist of arbitrarily many node labels, such as graph coloring.
Revised: We present the combinatorial node labeling framework, which generalizes many prior approaches to solving hard graph optimization problems by supporting problems where solutions consist of arbitrarily many node labels, such as graph coloring.

Original: We then introduce a neural network architecture to implement this framework.
Revised: We then introduce a neural network architecture to implement this framework.

Original: Our architecture builds on a graph attention network with several inductive biases to improve solution quality and is trained using policy gradient reinforcement learning.
Revised: Our architecture builds on a graph attention network with several inductive biases to improve solution quality and is trained using policy gradient reinforcement learning.

Original: We demonstrate our approach on both graph coloring and minimum vertex cover.
Revised: We demonstrate our approach on both graph coloring and minimum vertex cover.

Original: Our learned heuristics match or outperform classical hand-crafted greedy heuristics and machine learning approaches while taking only seconds on large graphs.
Revised: Our learned heuristics match or outperform classical hand-crafted greedy heuristics and machine learning approaches while taking only seconds on large graphs.

Original: We conduct a detailed analysis of the learned heuristics and architecture choices and show that they successfully adapt to different graph structures.
Revised: We conduct a detailed analysis of the learned heuristics and architecture choices and show that they successfully adapt to different graph structures.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Graph problems have numerous real-world applications, ranging from scheduling problems (Marx, 2004) and register allocation (Chaitin, 1982; Smith et al., 2004), to computational biology (Abukhzam et al., 2004).
Revised: Graph problems have numerous real-world applications, ranging from scheduling problems (Marx, 2004) and register allocation (Chaitin, 1982; Smith et al., 2004), to computational biology (Abukhzam et al., 2004).

Original: However, many useful graph optimizations problems are NP-hard to solve (Karp, 1972).
Revised: However, many useful graph optimizations problems are NP-hard to solve (Karp, 1972).

Original: This has spurred a variety of approaches, from greedy heuristics (Brélaz, 1979; Papadimitriou & Steiglitz, 1982; Matula & Beck, 1983; Avis & Imamura, 2007; Delbot & Laforest, 2008) to integer linear programming (Graver, 1975).
Revised: This has spurred a variety of approaches, from greedy heuristics (Brélaz, 1979; Papadimitriou & Steiglitz, 1982; Matula & Beck, 1983; Avis & Imamura, 2007; Delbot & Laforest, 2008) to integer linear programming (Graver, 1975).

Original: More recently, machine learning approaches have shown increasing promise (Dai et al., 2017; Kool et al., 2019; Li et al., 2018; Karalias & Loukas, 2020).
Revised: More recently, machine learning approaches have shown increasing promise (Dai et al., 2017; Kool et al., 2019; Li et al., 2018; Karalias & Loukas, 2020).

Original: From a structural point of view, many graph problems fall into one of three classes depending on the type of their solution: Problems that ask for (1) subsets of vertices, (2) permutations of vertices, or (3) partitions of vertices into two or more sets.
Revised: From a structural point of view, many graph problems fall into one of three classes depending on the type of their solution: Problems that ask for (1) subsets of vertices, (2) permutations of vertices, or (3) partitions of vertices into two or more sets.

Original: Most work has focussed on either the ﬁrst two (Dai et al., 2017), or just one of the three (Bello et al., 2017;
Revised: Most work has focussed on either the ﬁrst two (Dai et al., 2017), or just one of the three (Bello et al., 2017;

Original: Li et al., 2018; Kool et al., 2019; Karalias & Loukas, 2020; Manchanda et al., 2020; Cappart et al., 2020; Drori et al., 2020; Ma et al., 2020).
Revised: Li et al., 2018; Kool et al., 2019; Karalias & Loukas, 2020; Manchanda et al., 2020; Cappart et al., 2020; Drori et al., 2020; Ma et al., 2020).

Original: Existing machine learning methods for the ﬁrst two types of problems, such as S2V-DQN (Dai et al., 2017), do not easily generalize to cases where the number of labels is not known in advance.
Revised: Existing machine learning methods for the ﬁrst two types of problems, such as S2V-DQN (Dai et al., 2017), do not easily generalize to cases where the number of labels is not known in advance.

Original: Many important and challenging problems, such as graph coloring (Marx, 2004; Myszkowski, 2008; Bandh et al., 2009), require that vertices be partitioned into an unkown number of sets .
Revised: Many important and challenging problems, such as graph coloring (Marx, 2004; Myszkowski, 2008; Bandh et al., 2009), require that vertices be partitioned into an unkown number of sets .

Original: To address this, we present the combinatorial node labeling framework (§2), which generalizes prior approaches (Fig. 1), and supports many problems, including minimum vertex cover (Onak et al., 2012; Bhattacharya et al., 2017;
Revised: To address this, we present the combinatorial node labeling framework (§2), which generalizes prior approaches (Fig. 1), and supports many problems, including minimum vertex cover (Onak et al., 2012; Bhattacharya et al., 2017;

Original: Ghaffari et al., 2020), traveling salesman (Dantzig et al., 1954;
Revised: Ghaffari et al., 2020), traveling salesman (Dantzig et al., 1954;

Original: Garey & Johnson, 1990), maximum cut (Karp, 1972), and list coloring (Jensen et al., 1995).
Revised: Garey & Johnson, 1990), maximum cut (Karp, 1972), and list coloring (Jensen et al., 1995).

Original: These, and many other (§D), problems can all be framed as iteratively assigning a label to nodes, in some order.
Revised: These, and many other (§D), problems can all be framed as iteratively assigning a label to nodes, in some order.

Original: We then introduce a neural architecture, GAT-CNL, to learn greedy-inspired heuristics for such problems (§3).
Revised: We then introduce a neural architecture, GAT-CNL, to learn greedy-inspired heuristics for such problems (§3).

Original: We use policy gradient reinforcement learning (Sutton & Barto, 2018; Kool et al., 2019) to learn a node ordering and combine this with a ﬁxed label rule to label each node according to the ordering.
Revised: We use policy gradient reinforcement learning (Sutton & Barto, 2018; Kool et al., 2019) to learn a node ordering and combine this with a ﬁxed label rule to label each node according to the ordering.

Original: We show that for the chosen label rules, there still exists an order that guarantees an optimal solution.
Revised: We show that for the chosen label rules, there still exists an order that guarantees an optimal solution.

Original: By using policy gradients, we can construct both a deterministic greedy policy, as well as a probabilistic policy where sampling boosts the solution quality.
Revised: By using policy gradients, we can construct both a deterministic greedy policy, as well as a probabilistic policy where sampling boosts the solution quality.

Original: To improve performance, we incorporate two inductive biases: spatial locality , where labeling a node only impacts the weights of its neighbors; and temporal locality , where node selection is conditioned only on the previously labeled node, a summary of prior labelings, and a global graph context (Figs. 2 and 3).
Revised: To improve performance, we incorporate two inductive biases: spatial locality , where labeling a node only impacts the weights of its neighbors; and temporal locality , where node selection is conditioned only on the previously labeled node, a summary of prior labelings, and a global graph context (Figs. 2 and 3).

Original: [Figure]
Revised: [Figure]

Original: Label
Revised: Label

Original: [Figure]
Revised: [Figure]

Original: Graph
Revised: Graph

Original: Ours: GAT-CNL m/
Revised: Ours: GAT-CNL m/

Original: [Figure]
Revised: [Figure]

Original: We evaluate our approach (§4) and demonstrate signiﬁcantly improved performance for neural graph coloring (GC) and ﬁnd near-optimal solutions for minimum vertex cover (MVC).
Revised: We evaluate our approach (§4) and demonstrate signiﬁcantly improved performance for neural graph coloring (GC) and ﬁnd near-optimal solutions for minimum vertex cover (MVC).

Original: We additionally study the runtime of our models, conduct comprehensive ablation studies
Revised: We additionally study the runtime of our models, conduct comprehensive ablation studies

Original: [Figure]
Revised: [Figure]

Original: and provide qualitative analyses of the learned heuristics, showing they adapt to the properties of the input graph.
Revised: and provide qualitative analyses of the learned heuristics, showing they adapt to the properties of the input graph.

Original: Related work.
Revised: Related work.

Original: We now review key related works.
Revised: We now review key related works.

Original: Figure 1 (left) provides a comparison of node labeling with other frameworks.
Revised: Figure 1 (left) provides a comparison of node labeling with other frameworks.

Original: Supervised learning.
Revised: Supervised learning.

Original: The fundamental downsides of supervised learning for combinatorial optimization are twofold: First, it can be difﬁcult to formulate a problem in a supervised manner, since it might have many optimal solutions (e.g., GC).
Revised: The fundamental downsides of supervised learning for combinatorial optimization are twofold: First, it can be difﬁcult to formulate a problem in a supervised manner, since it might have many optimal solutions (e.g., GC).

Original: Second, even if the problem admits a direct supervised formulation, we still need labeled data for training, which can be hard to generate and relies on an existing solver.
Revised: Second, even if the problem admits a direct supervised formulation, we still need labeled data for training, which can be hard to generate and relies on an existing solver.

Original: In particular, supervised learning cannot easily be used for problems that have not been studied before.
Revised: In particular, supervised learning cannot easily be used for problems that have not been studied before.

Original: Advantages of supervised learning are its sample efﬁciency and that it can lead to overall better results.
Revised: Advantages of supervised learning are its sample efﬁciency and that it can lead to overall better results.

Original: Recent approaches like Joshi et al.
Revised: Recent approaches like Joshi et al.

Original: and Manchanda et al.
Revised: and Manchanda et al.

Original: (2020) obtain good results for inﬂuence maximization (IM) and the traveling salesman problem (TSP), respectively.
Revised: (2020) obtain good results for inﬂuence maximization (IM) and the traveling salesman problem (TSP), respectively.

Original: Both approaches use supervised learning.
Revised: Both approaches use supervised learning.

Original: For IM, the approach of Manchanda et al.
Revised: For IM, the approach of Manchanda et al.

Original: (2020) shows promising results on graphs much larger than those seen in training.
Revised: (2020) shows promising results on graphs much larger than those seen in training.

Original: For TSP, the approach of Joshi et al.
Revised: For TSP, the approach of Joshi et al.

Original: (2019) is very efﬁcient but does not generalize well to graphs larger than those seen in training.
Revised: (2019) is very efﬁcient but does not generalize well to graphs larger than those seen in training.

Original: Li et al.
Revised: Li et al.

Original: (2018) also use supervised learning and produce good results on minimum vertex cover (MVC), maximum independent set, and maximal clique.
Revised: (2018) also use supervised learning and produce good results on minimum vertex cover (MVC), maximum independent set, and maximal clique.

Original: Unsupervised Learning.
Revised: Unsupervised Learning.

Original: To apply unsupervised learning, it is necessary to formulate a differentiable surrogate loss.
Revised: To apply unsupervised learning, it is necessary to formulate a differentiable surrogate loss.

Original: There have been approaches for several speciﬁc combinatorial optimization problems (Nazi et al., 2019; Amizadeh et al., 2019; Tönshoff et al., 2019; Yao et al., 2019) and there has been progress to create a framework for the derivation of trainable losses (Karalias & Loukas, 2020).
Revised: There have been approaches for several speciﬁc combinatorial optimization problems (Nazi et al., 2019; Amizadeh et al., 2019; Tönshoff et al., 2019; Yao et al., 2019) and there has been progress to create a framework for the derivation of trainable losses (Karalias & Loukas, 2020).

Original: Still, signiﬁcant insight into a problem is required to design suitable loss functions.
Revised: Still, signiﬁcant insight into a problem is required to design suitable loss functions.

Original: Reinforcement learning (RL) .
Revised: Reinforcement learning (RL) .

Original: Using RL only requires a way to represent partial solutions and a way to score the cost of a (partial or ﬁnal) solution.
Revised: Using RL only requires a way to represent partial solutions and a way to score the cost of a (partial or ﬁnal) solution.

Original: Dai et al.
Revised: Dai et al.

Original: (2017) provide S2V-DQN, a general framework for learning problems like MVC and TSP that is trained with RL.
Revised: (2017) provide S2V-DQN, a general framework for learning problems like MVC and TSP that is trained with RL.

Original: It shows good results across different graph sizes for the covered problems, but is not fast enough to replace existing approaches nor does it handle arbitrary node labels (see Fig. 1).
Revised: It shows good results across different graph sizes for the covered problems, but is not fast enough to replace existing approaches nor does it handle arbitrary node labels (see Fig. 1).

Original: Kool et al.
Revised: Kool et al.

Original: (2019) focus on routing problems like TSP and the vehicle routing problem.
Revised: (2019) focus on routing problems like TSP and the vehicle routing problem.

Original: They outperform Dai et al.
Revised: They outperform Dai et al.

Original: on TSP instances of the training size.
Revised: on TSP instances of the training size.

Original: Unfortunately, their approach does not seem to generalize to graph sizes that are very different from those used for training.
Revised: Unfortunately, their approach does not seem to generalize to graph sizes that are very different from those used for training.

Original: Several other RL approaches have been proposed and evaluated for TSP (Bello et al., 2017; Cappart et al., 2020; Drori et al., 2020; Ma et al., 2020).
Revised: Several other RL approaches have been proposed and evaluated for TSP (Bello et al., 2017; Cappart et al., 2020; Drori et al., 2020; Ma et al., 2020).

Original: Barrett et al.
Revised: Barrett et al.

Original: (2020) consider the maximum cut (MaxCut) problem.
Revised: (2020) consider the maximum cut (MaxCut) problem.

Original: Huang et al.
Revised: Huang et al.

Original: (2019) present a Monte
Revised: (2019) present a Monte

Original: Carlo search tree approach specialized only for graph coloring.
Revised: Carlo search tree approach specialized only for graph coloring.

Original: These methods do not address the general node labeling framework, but instead model the solution as a permutation of vertices (e.g.,
Revised: These methods do not address the general node labeling framework, but instead model the solution as a permutation of vertices (e.g.,

Original: TSP, vehicle routing) or a set of nodes or edges (e.g., MVC, MaxCut).
Revised: TSP, vehicle routing) or a set of nodes or edges (e.g., MVC, MaxCut).

Original: Instead, we can represent solutions where vertices are assigned to an unknown and unbounded number of partitions, which is crucial for solving tasks such as graph coloring.
Revised: Instead, we can represent solutions where vertices are assigned to an unknown and unbounded number of partitions, which is crucial for solving tasks such as graph coloring.

Original:  C OMBINATORIAL N ODE L ABELING
Revised:  C OMBINATORIAL N ODE L ABELING

Original: Many graph heuristics can be phrased as a greedy process, where vertices get assigned a problemdependent label one after the other.
Revised: Many graph heuristics can be phrased as a greedy process, where vertices get assigned a problemdependent label one after the other.

Original: For example, this label could indicate if the vertex is part of the solution set, its position in a permutation, or its membership in one of many sets.
Revised: For example, this label could indicate if the vertex is part of the solution set, its position in a permutation, or its membership in one of many sets.

Original: We introduce combinatorial node labeling , which frames many hard graph optimization problems, such as graph coloring (see §D for a list), as a greedy process.
Revised: We introduce combinatorial node labeling , which frames many hard graph optimization problems, such as graph coloring (see §D for a list), as a greedy process.

Original: This generalizes previous work (Kool et al., 2019;
Revised: This generalizes previous work (Kool et al., 2019;

Original: Dai et al., 2017; Ma et al., 2020; Drori et al., 2020), to encompass problems where the number of labels is not known in advance and is unbounded (see Fig. 1).
Revised: Dai et al., 2017; Ma et al., 2020; Drori et al., 2020), to encompass problems where the number of labels is not known in advance and is unbounded (see Fig. 1).

Original: Every node labeling problem can be formulated as a (ﬁnite) Markov decision process (MDP), during which nodes are successively added to a so-called partial node labeling until a termination criterion is met.
Revised: Every node labeling problem can be formulated as a (ﬁnite) Markov decision process (MDP), during which nodes are successively added to a so-called partial node labeling until a termination criterion is met.

Original: In §3, we will present a graph learning approach to optimizing such node labeling MDPs.
Revised: In §3, we will present a graph learning approach to optimizing such node labeling MDPs.

Original: 2. P RELIMINARIES
Revised: 2. P RELIMINARIES

Original: We consider an undirected, unweighted, and simple graph G =
Revised: We consider an undirected, unweighted, and simple graph G =

Original: ( V, E ) with n nodes in V and m edges in E .
Revised: ( V, E ) with n nodes in V and m edges in E .

Original: We denote the neighbors of a node v by N ( v ) .
Revised: We denote the neighbors of a node v by N ( v ) .

Original: We assume w.l.o.g. that the graph is connected and hence m = Ω( n ) .
Revised: We assume w.l.o.g. that the graph is connected and hence m = Ω( n ) .

Original: A node labeling is a function c : V → L , where L ⊆ { 0 , . . . , n } .
Revised: A node labeling is a function c : V → L , where L ⊆ { 0 , . . . , n } .

Original: A partial node labeling is a function c (cid:48) : V (cid:48)
Revised: A partial node labeling is a function c (cid:48) : V (cid:48)

Original: → L (cid:48) for a subset of nodes V (cid:48) ⊆
Revised: → L (cid:48) for a subset of nodes V (cid:48) ⊆

Original: V and labels L (cid:48) ⊆
Revised: V and labels L (cid:48) ⊆

Original: L .
Revised: L .

Original: A node labeling problem is subject to a feasibility condition and a real-valued cost function f .
Revised: A node labeling problem is subject to a feasibility condition and a real-valued cost function f .

Original: The cost function maps a node labeling c to a real-valued cost f ( c ) .
Revised: The cost function maps a node labeling c to a real-valued cost f ( c ) .

Original: We require that the feasibility condition be expressed in terms of an efﬁcient (polynomial-time computable) extensibility test T : P ( V × L ) × V × L → { 0 , 1 } , where P denotes the powerset.
Revised: We require that the feasibility condition be expressed in terms of an efﬁcient (polynomial-time computable) extensibility test T : P ( V × L ) × V × L → { 0 , 1 } , where P denotes the powerset.

Original: We say the extensibility test passes when it returns 1 .
Revised: We say the extensibility test passes when it returns 1 .

Original: Intuitively, given a partial node labeling c (cid:48) , a node v (cid:54)∈ V (cid:48) , and label (cid:96) , the extensibility test passes if and only if c (cid:48) can be extended by labeling node v with (cid:96) such that c (cid:48) can be extended into a node labeling.
Revised: Intuitively, given a partial node labeling c (cid:48) , a node v (cid:54)∈ V (cid:48) , and label (cid:96) , the extensibility test passes if and only if c (cid:48) can be extended by labeling node v with (cid:96) such that c (cid:48) can be extended into a node labeling.

Original: Formally, the extensibility test characterizes the set of feasible solutions :
Revised: Formally, the extensibility test characterizes the set of feasible solutions :

Original: Deﬁnition 2.1.
Revised: Deﬁnition 2.1.

Original: A node labeling c is feasible if and only if there exists a sequence of nodelabel pairs ( v 1 , (cid:96) 1 ) , . . .
Revised: A node labeling c is feasible if and only if there exists a sequence of nodelabel pairs ( v 1 , (cid:96) 1 ) , . . .

Original: , ( v n , (cid:96) n ) such that for all i ≥ 

Revised: , ( v n , (cid:96) n ) such that for all i ≥

Original: the extensibility test T satisﬁes
Revised: the extensibility test T satisﬁes

Original: T ( { ( v 1 , (cid:96) 1 ) , . . .
Revised: T ( { ( v 1 , (cid:96) 1 ) , . . .

Original: , ( v i , (cid:96) i ) } , v i +1 , (cid:96) i +1 )
Revised: , ( v i , (cid:96) i ) } , v i +1 , (cid:96) i +1 )

Original: = 1 .
Revised: = 1 .

Original: The goal of the node labeling problem is to minimize the value of the cost function among the feasible node labelings.
Revised: The goal of the node labeling problem is to minimize the value of the cost function among the feasible node labelings.

Original: For consistency, an infeasible node labeling has inﬁnite cost.
Revised: For consistency, an infeasible node labeling has inﬁnite cost.

Original: Next, we present the two node labeling problems on which we focus in our evaluation.
Revised: Next, we present the two node labeling problems on which we focus in our evaluation.

Original: Deﬁnition 2.2.
Revised: Deﬁnition 2.2.

Original: A k -coloring of a graph G =
Revised: A k -coloring of a graph G =

Original: ( V, E ) is a node labeling c : V → { 1 , 2 , . .
Revised: ( V, E ) is a node labeling c : V → { 1 , 2 , . .

Original: . , k } such that no two neighbors have the same label, i.e., ∀{ u, v } ∈ E : c ( u ) (cid:54) =
Revised: . , k } such that no two neighbors have the same label, i.e., ∀{ u, v } ∈ E : c ( u ) (cid:54) =

Original: c ( v ) .
Revised: c ( v ) .

Original: The cost function for GC is the number of distinct labels (or colors) k .
Revised: The cost function for GC is the number of distinct labels (or colors) k .

Original: Given a partial node labeling c (cid:48) : V (cid:48)
Revised: Given a partial node labeling c (cid:48) : V (cid:48)

Original: → { 1 , . . . , k } and any vertex-label pair ( v, (cid:96) ) , the extensibility test passes for ( c (cid:48) , v, (cid:96) ) if and only if the extended partial node labeling c (cid:48) ∪ ( v, (cid:96) ) is a k - or ( k + 1) -coloring of the induced subgraph G [ V (cid:48) ∪ { v } ] .
Revised: → { 1 , . . . , k } and any vertex-label pair ( v, (cid:96) ) , the extensibility test passes for ( c (cid:48) , v, (cid:96) ) if and only if the extended partial node labeling c (cid:48) ∪ ( v, (cid:96) ) is a k - or ( k + 1) -coloring of the induced subgraph G [ V (cid:48) ∪ { v } ] .

Original: In particular, the test does not pass when (cid:96) > k + 1 .
Revised: In particular, the test does not pass when (cid:96) > k + 1 .

Original: The smallest k for which there is a k -coloring of G is the chromatic number χ ( G ) of G .
Revised: The smallest k for which there is a k -coloring of G is the chromatic number χ ( G ) of G .

Original: Deﬁnition 2.3.
Revised: Deﬁnition 2.3.

Original: A vertex cover of a graph G =
Revised: A vertex cover of a graph G =

Original: ( V, E ) is a node labeling c : V → { 0 , 1 } such that every edge is incident to at least one node with label 1 , i.e., ∀{ u, v } ∈ E : c ( u )
Revised: ( V, E ) is a node labeling c : V → { 0 , 1 } such that every edge is incident to at least one node with label 1 , i.e., ∀{ u, v } ∈ E : c ( u )

Original: = 1 ∨ c ( v ) = 1 .
Revised: = 1 ∨ c ( v ) = 1 .

Original: The cost function for MVC is the number of nodes with label 1 .
Revised: The cost function for MVC is the number of nodes with label 1 .

Original: Given a partial node labeling c (cid:48) : V (cid:48)
Revised: Given a partial node labeling c (cid:48) : V (cid:48)

Original: → { 0 , 1 } the extensibility test passes for ( c (cid:48) , v, (cid:96) ) if and only if the extended partial node labeling c (cid:48) ∪ ( v, (cid:96) ) is a vertex cover of the induced subgraph G [ V (cid:48) ∪ { v } ] .
Revised: → { 0 , 1 } the extensibility test passes for ( c (cid:48) , v, (cid:96) ) if and only if the extended partial node labeling c (cid:48) ∪ ( v, (cid:96) ) is a vertex cover of the induced subgraph G [ V (cid:48) ∪ { v } ] .

Original: 2. N ODE LABELING MDP
Revised: 2. N ODE LABELING MDP

Original: We show how to construct an MDP that models a given combinatorial node labeling problem.
Revised: We show how to construct an MDP that models a given combinatorial node labeling problem.

Original: Minimizing the cost of the combinatorial node labeling problem is equivalent to maximizing the return of this MDP.
Revised: Minimizing the cost of the combinatorial node labeling problem is equivalent to maximizing the return of this MDP.

Original: In the vast majority of reinforcement learning approaches to solve combinatorial graph optimization problems (Kool et al., 2019; Dai et al., 2017; Ma et al., 2020; Drori et al., 2020), a state corresponds to a set or sequence of nodes that are already added to a solution set.
Revised: In the vast majority of reinforcement learning approaches to solve combinatorial graph optimization problems (Kool et al., 2019; Dai et al., 2017; Ma et al., 2020; Drori et al., 2020), a state corresponds to a set or sequence of nodes that are already added to a solution set.

Original: Instead, in our setting the state represents a partial node labeling.
Revised: Instead, in our setting the state represents a partial node labeling.

Original: This is why in addition to problems like MVC and TSP, we can also model problems with more than two labels (even when the number of labels is not known in advance).
Revised: This is why in addition to problems like MVC and TSP, we can also model problems with more than two labels (even when the number of labels is not known in advance).

Original: Graph coloring is such a problem.
Revised: Graph coloring is such a problem.

Original: Lemma 2.4.
Revised: Lemma 2.4.

Original: For any node labeling problem, there is an MDP whose terminal states correspond to the feasible solutions with a cost equal to the negative return.
Revised: For any node labeling problem, there is an MDP whose terminal states correspond to the feasible solutions with a cost equal to the negative return.

Original: We embed the cost function f
Revised: We embed the cost function f

Original: and the extensibility test into the MDP.
Revised: and the extensibility test into the MDP.

Original: Note that we do not require a way to measure the cost of partial node labelings.
Revised: Note that we do not require a way to measure the cost of partial node labelings.

Original: Here, we formulate the state space, action space, transition function, and reward.
Revised: Here, we formulate the state space, action space, transition function, and reward.

Original: In §C.1, we ﬁnish the proof of Lemma 2.4.
Revised: In §C.1, we ﬁnish the proof of Lemma 2.4.

Original: State space.
Revised: State space.

Original: A state S represents a partial node labeling.
Revised: A state S represents a partial node labeling.

Original: It is a set of pairs S = V (cid:48)
Revised: It is a set of pairs S = V (cid:48)

Original: × L for a subset of nodes V (cid:48) ⊆
Revised: × L for a subset of nodes V (cid:48) ⊆

Original: V and a subset of labels L ⊆ { 0 , . .
Revised: V and a subset of labels L ⊆ { 0 , . .

Original: . , n } .
Revised: . , n } .

Original: A state is terminal if V (cid:48)
Revised: A state is terminal if V (cid:48)

Original: =
Revised: =

Original: V .
Revised: V .

Original: Hence, the set of states is the powerset P ( V × { 0 , . . . , n } ) of the Cartesian product of the vertices and labels.
Revised: Hence, the set of states is the powerset P ( V × { 0 , . . . , n } ) of the Cartesian product of the vertices and labels.

Original: Action space.
Revised: Action space.

Original: In state S , the set of legal actions are the pairs ( v, (cid:96) ) for nodes v and labels (cid:96) which pass the extensibility test of the problem for the partial node labeling given by S (i.e., T ( S, v, l ) = 1 ).
Revised: In state S , the set of legal actions are the pairs ( v, (cid:96) ) for nodes v and labels (cid:96) which pass the extensibility test of the problem for the partial node labeling given by S (i.e., T ( S, v, l ) = 1 ).

Original: Transition function.
Revised: Transition function.

Original: In our case, the transition function T is deterministic.
Revised: In our case, the transition function T is deterministic.

Original: That is, given the current state S t and an action ( v, (cid:96) ) , T ( S t , ( v, (cid:96) )) yields the next state S t
Revised: That is, given the current state S t and an action ( v, (cid:96) ) , T ( S t , ( v, (cid:96) )) yields the next state S t

Original: +1 =
Revised: +1 =

Original: S t ∪ { ( v, (cid:96) ) } .
Revised: S t ∪ { ( v, (cid:96) ) } .

Original: Reward .
Revised: Reward .

Original: For a terminal state S representing the node labeling c , the reward is − f ( c ) .
Revised: For a terminal state S representing the node labeling c , the reward is − f ( c ) .

Original: For all other states, the reward is 0 .
Revised: For all other states, the reward is 0 .

Original: A policy is a mapping from states to probabilities for each action.
Revised: A policy is a mapping from states to probabilities for each action.

Original: Note that we can turn a probabilistic policy into a deterministic greedy policy by choosing the action with largest probability.
Revised: Note that we can turn a probabilistic policy into a deterministic greedy policy by choosing the action with largest probability.

Original: Next, we present how to train such a policy end-to-end using policy gradients.
Revised: Next, we present how to train such a policy end-to-end using policy gradients.

Original:  G RAPH LEARNING APPROACH
Revised:  G RAPH LEARNING APPROACH

Original: We present a graph learning approach to node labeling, which is inspired by greedy algorithms.
Revised: We present a graph learning approach to node labeling, which is inspired by greedy algorithms.

Original: A greedy node labeling algorithm assigns a label in { 0 , . .
Revised: A greedy node labeling algorithm assigns a label in { 0 , . .

Original: . , n } to one node after another based on a problem-speciﬁc heuristic.
Revised: . , n } to one node after another based on a problem-speciﬁc heuristic.

Original: Hence, it can be seen as providing (1) an order on the nodes and (2) a rule to label the next selected node.
Revised: Hence, it can be seen as providing (1) an order on the nodes and (2) a rule to label the next selected node.

Original: We focus on learning an order on the nodes and pick a label that passes the extensibility test according to a ﬁxed rule.
Revised: We focus on learning an order on the nodes and pick a label that passes the extensibility test according to a ﬁxed rule.

Original: The following two lemmas show there exists a label assignment rule that ensures the optimal solution can be found for GC and MVC (see §C.2 for the proofs):
Revised: The following two lemmas show there exists a label assignment rule that ensures the optimal solution can be found for GC and MVC (see §C.2 for the proofs):

Original: Lemma 3.1.
Revised: Lemma 3.1.

Original: For every graph G , there exists an ordering of vertices for which choosing the smallest color that passes the extensibility test colors G optimally.
Revised: For every graph G , there exists an ordering of vertices for which choosing the smallest color that passes the extensibility test colors G optimally.

Original: Lemma 3.2.
Revised: Lemma 3.2.

Original: For every graph G , there exists an ordering of vertices for which choosing the labeluntil every edge in G has one of its endpoints labeled with 1 produces a minimum vertex cover of G .
Revised: For every graph G , there exists an ordering of vertices for which choosing the labeluntil every edge in G has one of its endpoints labeled with 1 produces a minimum vertex cover of G .

Original: We expect similar results can be obtained for most other node labeling problems.
Revised: We expect similar results can be obtained for most other node labeling problems.

Original: Instead of a handcrafted ordering heuristic, we learn to assign weights to each node and choose the nodes according to their weights.
Revised: Instead of a handcrafted ordering heuristic, we learn to assign weights to each node and choose the nodes according to their weights.

Original: To compute these weights, we introduce a novel spatial locality inductive bias inspired by the greedy heuristics: labeling a node should only affect the weights of its neighbors.
Revised: To compute these weights, we introduce a novel spatial locality inductive bias inspired by the greedy heuristics: labeling a node should only affect the weights of its neighbors.

Original: As we will show in §4.3, this leads to better test scores compared to the alternatives of updating all or none of the weights when a node is labeled.
Revised: As we will show in §4.3, this leads to better test scores compared to the alternatives of updating all or none of the weights when a node is labeled.

Original: This spatial locality bias is inspired by successful greedy heuristics: The ListRight heuristic for MVC (Delbot & Laforest, 2008) assigns a node to the vertex cover based on the assignment of its neighbors.
Revised: This spatial locality bias is inspired by successful greedy heuristics: The ListRight heuristic for MVC (Delbot & Laforest, 2008) assigns a node to the vertex cover based on the assignment of its neighbors.

Original: For GC, the DSATUR strategy selects nodes according to their saturation degree (Brélaz, 1979).
Revised: For GC, the DSATUR strategy selects nodes according to their saturation degree (Brélaz, 1979).

Original: If a new node is selected, only the saturation degree of its neighborhood can change; the others remain unchanged.
Revised: If a new node is selected, only the saturation degree of its neighborhood can change; the others remain unchanged.

Original: 3. P OLICY OPTIMIZATION
Revised: 3. P OLICY OPTIMIZATION

Original: We train our node labeling model by policy gradients, speciﬁcally R EINFORCE (Bello et al., 2017) with a greedy rollout baseline (Kool et al., 2019).
Revised: We train our node labeling model by policy gradients, speciﬁcally R EINFORCE (Bello et al., 2017) with a greedy rollout baseline (Kool et al., 2019).

Original: The advantage of policy gradients over Q-learning is that is has stronger convergence guarantees (Sutton & Barto, 2018).
Revised: The advantage of policy gradients over Q-learning is that is has stronger convergence guarantees (Sutton & Barto, 2018).

Original: At a high level, the algorithm works as follows.
Revised: At a high level, the algorithm works as follows.

Original: We begin by initializing two models, the current model and the baseline model.
Revised: We begin by initializing two models, the current model and the baseline model.

Original: For each graph in the batch, the algorithm performs a probabilistic rollout of the policy.
Revised: For each graph in the batch, the algorithm performs a probabilistic rollout of the policy.

Original: The baseline
Revised: The baseline

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: model performs a greedy rollout.
Revised: model performs a greedy rollout.

Original: The difference between the two costs determines the policy gradient update.
Revised: The difference between the two costs determines the policy gradient update.

Original: After every epoch, we perform a (one-sided) paired t -test over the cost on a challenge dataset to check if the baseline model should be replaced with the current model.
Revised: After every epoch, we perform a (one-sided) paired t -test over the cost on a challenge dataset to check if the baseline model should be replaced with the current model.

Original: See §A.2 for more details.
Revised: See §A.2 for more details.

Original: 3. GAT-CNL A RCHITECTURE
Revised: 3. GAT-CNL A RCHITECTURE

Original: Our architecture, GAT-CNL, consists of an encoder and a decoder to learn a policy speciﬁc to the node labeling problem.
Revised: Our architecture, GAT-CNL, consists of an encoder and a decoder to learn a policy speciﬁc to the node labeling problem.

Original: The encoder learns the local structural information that is important for the problem in the form of a node embedding
Revised: The encoder learns the local structural information that is important for the problem in the form of a node embedding

Original: The state embedding encapsulates information about the graph itself (enabling the network to adapt its actions to the graph), the last node that was labeled and its label and a summary of prior actions (with pooling).
Revised: The state embedding encapsulates information about the graph itself (enabling the network to adapt its actions to the graph), the last node that was labeled and its label and a summary of prior actions (with pooling).

Original: This enables the state embedding to have constant size; adding additional nodes provided no beneﬁt (see §4.3).
Revised: This enables the state embedding to have constant size; adding additional nodes provided no beneﬁt (see §4.3).

Original: This also serves as a temporal locality bias; however, note that the decoder is not Markovian, as it depends on more than just the previous decision.
Revised: This also serves as a temporal locality bias; however, note that the decoder is not Markovian, as it depends on more than just the previous decision.

Original: The decoder uses the node embeddings and the state embedding to select the next node based on attention weights between the node embeddings and the state embedding.
Revised: The decoder uses the node embeddings and the state embedding to select the next node based on attention weights between the node embeddings and the state embedding.

Original: After the decoder picks the next node v , the label rule (see Lemmas 3.1 and 3.2) assigns the label (cid:96) for the node.
Revised: After the decoder picks the next node v , the label rule (see Lemmas 3.1 and 3.2) assigns the label (cid:96) for the node.

Original: The policy then takes the action ( v, (cid:96) ) .
Revised: The policy then takes the action ( v, (cid:96) ) .

Original: Then, the state embedding is updated and the decoder is invoked again until all nodes are labeled.
Revised: Then, the state embedding is updated and the decoder is invoked again until all nodes are labeled.

Original: Figure 1 (right) overviews our architecture.
Revised: Figure 1 (right) overviews our architecture.

Original: Node features.
Revised: Node features.

Original: Each node v is associated with an input feature vector x v .
Revised: Each node v is associated with an input feature vector x v .

Original: Our input features consist of a combination of sine and cosine functions of the node degree, similar to positional embeddings (Vaswani et al., 2017).
Revised: Our input features consist of a combination of sine and cosine functions of the node degree, similar to positional embeddings (Vaswani et al., 2017).

Original: This representation ensures that input features are bounded in magnitude even for larger graphs.
Revised: This representation ensures that input features are bounded in magnitude even for larger graphs.

Original: We subtract the mean node degree from the degrees on the synthetic dense graph instances.
Revised: We subtract the mean node degree from the degrees on the synthetic dense graph instances.

Original: GAT encoder.
Revised: GAT encoder.

Original: We use a hidden dimension of size d (unless stated otherwise, d = 64 ).
Revised: We use a hidden dimension of size d (unless stated otherwise, d = 64 ).

Original: The input features are ﬁrst linearly transformed and then fed into a GNN, which produces, for each node v , a node embedding h v ∈ R d .
Revised: The input features are ﬁrst linearly transformed and then fed into a GNN, which produces, for each node v , a node embedding h v ∈ R d .

Original: We use a three-layer Graph Attention Network (GAT) (Vaswani et al., 2017; Velickovic et al., 2018; Lee et al., 2019), additive multi-head attention with four heads, batch normalization (Ioffe & Szegedy, 2015) with a skip connection (He et al., 2016) at each encoder layer, and leaky ReLU activations (Maas et al., 2013).
Revised: We use a three-layer Graph Attention Network (GAT) (Vaswani et al., 2017; Velickovic et al., 2018; Lee et al., 2019), additive multi-head attention with four heads, batch normalization (Ioffe & Szegedy, 2015) with a skip connection (He et al., 2016) at each encoder layer, and leaky ReLU activations (Maas et al., 2013).

Original: State embedding.
Revised: State embedding.

Original: The state embedding allows the decoder to condition its choice based on the graph instance and the partial node labeling.
Revised: The state embedding allows the decoder to condition its choice based on the graph instance and the partial node labeling.

Original: For computational reasons, we ensure it is of constant size.
Revised: For computational reasons, we ensure it is of constant size.

Original: Denote the node labeled in step t by v ( t ) and its label by (cid:96) ( t ) .
Revised: Denote the node labeled in step t by v ( t ) and its label by (cid:96) ( t ) .

Original: Then the state embedding consists of three components concatenated together: (1) The graph embedding h G , a max-pooling over all node embeddings.
Revised: Then the state embedding consists of three components concatenated together: (1) The graph embedding h G , a max-pooling over all node embeddings.

Original: The node embedding h v ( t − 1) of the last labeled node v ( t − 1) .
Revised: The node embedding h v ( t − 1) of the last labeled node v ( t − 1) .

Original: The label embedding h (cid:96) ( t − 1) of the last labeled node’s label (cid:96) ( t − 1) , a max-pooling over the embeddings of all nodes with that label.
Revised: The label embedding h (cid:96) ( t − 1) of the last labeled node’s label (cid:96) ( t − 1) , a max-pooling over the embeddings of all nodes with that label.

Original: In the ﬁrst iteration, we use a learned parameter h (0) for (2) and (3).
Revised: In the ﬁrst iteration, we use a learned parameter h (0) for (2) and (3).

Original: We considered including more than just the last labeled node, but found that this led to worse performance (§4.3).
Revised: We considered including more than just the last labeled node, but found that this led to worse performance (§4.3).

Original: Hence, this induces a temporal bias by focusing on the prior node and nodes with the same label as the last labeled node.
Revised: Hence, this induces a temporal bias by focusing on the prior node and nodes with the same label as the last labeled node.

Original: See Figure 3 for an illustration of the state embedding.
Revised: See Figure 3 for an illustration of the state embedding.

Original: Local attention decoder.
Revised: Local attention decoder.

Original: The decoder takes as input the node embeddings generated by the encoder and the state embedding and outputs the next node to label.
Revised: The decoder takes as input the node embeddings generated by the encoder and the state embedding and outputs the next node to label.

Original: In each time step t , an attention mechanism between the state embedding g t and each node embedding h v produces attention weights a ( t ) v .
Revised: In each time step t , an attention mechanism between the state embedding g t and each node embedding h v produces attention weights a ( t ) v .

Original: Here, we introduce a spatial locality bias: labeling a node can only affect the attention scores of its neighbors in the next time step.
Revised: Here, we introduce a spatial locality bias: labeling a node can only affect the attention scores of its neighbors in the next time step.

Original: Let V (cid:48) be the set of nodes already labeled.
Revised: Let V (cid:48) be the set of nodes already labeled.

Original: The attention weight a ( t ) v for node v in time step t is given by the local decoding .
Revised: The attention weight a ( t ) v for node v in time step t is given by the local decoding .

Original: For a node v / ∈ V (cid:48) :
Revised: For a node v / ∈ V (cid:48) :

Original: [Equation]
Revised: [Equation]

Original: If v ∈ V (cid:48) , then the attention weight is a ( t ) v = −∞ .
Revised: If v ∈ V (cid:48) , then the attention weight is a ( t ) v = −∞ .

Original: In the ﬁrst iteration of the decoder, we calculate the coefﬁcients for each node in the graph.
Revised: In the ﬁrst iteration of the decoder, we calculate the coefﬁcients for each node in the graph.

Original: As in Bello et al.
Revised: As in Bello et al.

Original: (2017), we clip the attention coefﬁcients within a constant range [ − C, C ] .
Revised: (2017), we clip the attention coefﬁcients within a constant range [ − C, C ] .

Original: In our experiments we set C = 10 .
Revised: In our experiments we set C = 10 .

Original: The learnable parameter matrices are Θ 1 ∈ R d × 3 d and Θ
Revised: The learnable parameter matrices are Θ 1 ∈ R d × 3 d and Θ

Original: 2 ∈ R d × d .
Revised: 2 ∈ R d × d .

Original: We use scaled dot-product attention (Vaswani et al., 2017)
Revised: We use scaled dot-product attention (Vaswani et al., 2017)

Original: (instead of additive attention) to speed up the decoding.
Revised: (instead of additive attention) to speed up the decoding.

Original: Finally, for each node v we apply a softmax over all attention weights to obtain the probability p v that node v is labeled next.
Revised: Finally, for each node v we apply a softmax over all attention weights to obtain the probability p v that node v is labeled next.

Original: See Figure 2 for a visualization of the attention weight computation during decoding.
Revised: See Figure 2 for a visualization of the attention weight computation during decoding.

Original: During inference, our greedy policy selects the vertices with maximum probability.
Revised: During inference, our greedy policy selects the vertices with maximum probability.

Original: Our sampling policy (for k samples) runs the greedy policy once, then evaluates the learned probabilistic policy k times (selecting a node v with the learned probability p v ), returning the best result.
Revised: Our sampling policy (for k samples) runs the greedy policy once, then evaluates the learned probabilistic policy k times (selecting a node v with the learned probability p v ), returning the best result.

Original: 3. N UMBER OF OPERATIONS
Revised: 3. N UMBER OF OPERATIONS

Original: We express the number of operations (arithmetic operations and comparisons) of the model during inference parameterized by the embedding dimension d , the number of nodes n and the number of edges m .
Revised: We express the number of operations (arithmetic operations and comparisons) of the model during inference parameterized by the embedding dimension d , the number of nodes n and the number of edges m .

Original: The encoder uses O ( dm + d 2 n ) arithmetic operations and the decoder uses O ( d 2 m ) arithmetic operations, resulting in O ( dm + d 2 n + d 2 m ) arithmetic operations, which is linear in the size of the graph .
Revised: The encoder uses O ( dm + d 2 n ) arithmetic operations and the decoder uses O ( d 2 m ) arithmetic operations, resulting in O ( dm + d 2 n + d 2 m ) arithmetic operations, which is linear in the size of the graph .

Original: To select the action of maximum probability (or sample a node), the decoder additionally needs O ( n 2 ) comparison operations (although this could be reduced to O ( m log n ) with an appropriate data structure).
Revised: To select the action of maximum probability (or sample a node), the decoder additionally needs O ( n 2 ) comparison operations (although this could be reduced to O ( m log n ) with an appropriate data structure).

Original: We empirically study the runtime in §§4.1 and 4.2; in practice, the d 2 m term dominates the runtime for the evaluated graphs until 5000 vertices.
Revised: We empirically study the runtime in §§4.1 and 4.2; in practice, the d 2 m term dominates the runtime for the evaluated graphs until 5000 vertices.

Original: In contrast, updating all attention weights after every labeling scales as O ( n 3 ) (see §B.5).
Revised: In contrast, updating all attention weights after every labeling scales as O ( n 3 ) (see §B.5).

Original:  E XPERIMENTS
Revised:  E XPERIMENTS

Original: We evaluate our approach on established benchmarks for graph coloring and minimum vertex cover, including greedy baselines and machine learning approaches.
Revised: We evaluate our approach on established benchmarks for graph coloring and minimum vertex cover, including greedy baselines and machine learning approaches.

Original: We focus on other heuristic approaches that return an approximation in polynomial time.
Revised: We focus on other heuristic approaches that return an approximation in polynomial time.

Original: Training.
Revised: Training.

Original: We use three different synthetic graph distributions to generate instances for training and validation (Albert & Barabási, 2002; Erd˝os & Rényi, 1960; Watts & Strogatz, 1998).
Revised: We use three different synthetic graph distributions to generate instances for training and validation (Albert & Barabási, 2002; Erd˝os & Rényi, 1960; Watts & Strogatz, 1998).

Original: We generate 20 , 000 graphs for training.
Revised: We generate 20 , 000 graphs for training.

Original: The graphs have between 20 and 100 nodes.
Revised: The graphs have between 20 and 100 nodes.

Original: We use Adam with learning rate α = 10 − 4 (Kingma & Ba, 2015).
Revised: We use Adam with learning rate α = 10 − 4 (Kingma & Ba, 2015).

Original: The effective batch size is B = 320 , which comes from using batches of 64 graphs for each node count n and accumulating their gradients.
Revised: The effective batch size is B = 320 , which comes from using batches of 64 graphs for each node count n and accumulating their gradients.

Original: We clip the L2 norm of the gradient to 1 , as done in Bello et al.
Revised: We clip the L2 norm of the gradient to 1 , as done in Bello et al.

Original: We selected these hyperparameters after initial experiments on the validation set.
Revised: We selected these hyperparameters after initial experiments on the validation set.

Original: Each model took 15–20 CPU compute node hours to train on a cluster with Intel Xeon E5-2695 v4 and 64 GB memory per node.
Revised: Each model took 15–20 CPU compute node hours to train on a cluster with Intel Xeon E5-2695 v4 and 64 GB memory per node.

Original: The overall time spent training was
Revised: The overall time spent training was

Original: [Table] [Table]
Revised: [Table] [Table]

Original: 1        1113 (a) Erd˝os-Rényi graph.
Revised: 1        1113 (a) Erd˝os-Rényi graph.

Original: 1   6  10    (b) Watts-Strogatz graph.
Revised: 1   6  10    (b) Watts-Strogatz graph.

Original: (c) Barabási-
Revised: (c) Barabási-

Original: [Figure]
Revised: [Figure]

Original: graph. was less than 2500 CPU node hours and the time spent on validation and testing was less than
Revised: graph. was less than 2500 CPU node hours and the time spent on validation and testing was less than

Original: CPU node hours.
Revised: CPU node hours.

Original: We train each model for 200 epochs with ﬁve random seeds and report the standard deviation σ of cost w.r.t.
Revised: We train each model for 200 epochs with ﬁve random seeds and report the standard deviation σ of cost w.r.t.

Original: the random seeds as ± σ . See §A for more details.
Revised: the random seeds as ± σ . See §A for more details.

Original: Test Scores.
Revised: Test Scores.

Original: In addition to mean cost, we report the ratio of the solution cost to the optimal solution cost ( approximation ratio ).
Revised: In addition to mean cost, we report the ratio of the solution cost to the optimal solution cost ( approximation ratio ).

Original: For large graphs, this cannot be computed exactly in a timely manner.
Revised: For large graphs, this cannot be computed exactly in a timely manner.

Original: In this case, we use the best solution found by an ILP solver within a compute time of one hour.
Revised: In this case, we use the best solution found by an ILP solver within a compute time of one hour.

Original: To compare with baselines which return infeasible solutions (and hence have ill-deﬁned cost), we report the percentage of wins (ties for ﬁrst place count as wins) and the percentage of instances solved optimally .
Revised: To compare with baselines which return infeasible solutions (and hence have ill-deﬁned cost), we report the percentage of wins (ties for ﬁrst place count as wins) and the percentage of instances solved optimally .

Original: We refer to these metrics as “Wins” and “Optimal”, respectively.
Revised: We refer to these metrics as “Wins” and “Optimal”, respectively.

Original: We use the model with the lowest cost to compute these percentages.
Revised: We use the model with the lowest cost to compute these percentages.

Original: Runtime.
Revised: Runtime.

Original: We benchmark on a c2d-standard-4 Google Cloud instance with 4 vCPUs and 16 GB RAM.
Revised: We benchmark on a c2d-standard-4 Google Cloud instance with 4 vCPUs and 16 GB RAM.

Original: 4. G RAPH C OLORING
Revised: 4. G RAPH C OLORING

Original: Greedy baselines.
Revised: Greedy baselines.

Original: Largest-First greedily colors nodes in decreasing order of degree.
Revised: Largest-First greedily colors nodes in decreasing order of degree.

Original: SmallestLast (Matula & Beck, 1983) colors the nodes in reverse degeneracy order, which guarantees that when a node is colored, it will have the smallest possible number of neighbors that have been already colored.
Revised: SmallestLast (Matula & Beck, 1983) colors the nodes in reverse degeneracy order, which guarantees that when a node is colored, it will have the smallest possible number of neighbors that have been already colored.

Original: Smallest-Last guantees a constant number of colors for certain families of graphs, such as Barabási-Albert graphs (Albert & Barabási, 2002) and planar graphs (Matula & Beck, 1983).
Revised: Smallest-Last guantees a constant number of colors for certain families of graphs, such as Barabási-Albert graphs (Albert & Barabási, 2002) and planar graphs (Matula & Beck, 1983).

Original: DSATUR (Brélaz, 1979) selects nodes based on the largest number of distinct colors in its neighborhood.
Revised: DSATUR (Brélaz, 1979) selects nodes based on the largest number of distinct colors in its neighborhood.

Original: DSATUR is exact on certain families of graphs, e.g., bipartite graphs (Brélaz, 1979).
Revised: DSATUR is exact on certain families of graphs, e.g., bipartite graphs (Brélaz, 1979).

Original: We use the implementations from NetworkX (Hagberg et al., 2008).
Revised: We use the implementations from NetworkX (Hagberg et al., 2008).

Original: Machine learning baseline.
Revised: Machine learning baseline.

Original: We compare our approach with the chromatic number estimator of
Revised: We compare our approach with the chromatic number estimator of

Original: Lemos et al.
Revised: Lemos et al.

Original: It does not guarantee that the solution is feasible, meaning that it can both underand overestimate the chromatic number.
Revised: It does not guarantee that the solution is feasible, meaning that it can both underand overestimate the chromatic number.

Original: We use the values reported by the original paper.
Revised: We use the values reported by the original paper.

Original: Note that
Revised: Note that

Original: S2V-DQN (Dai et al., 2017) cannot solve GC because of the way it embeds the state.
Revised: S2V-DQN (Dai et al., 2017) cannot solve GC because of the way it embeds the state.

Original: COLOR benchmark (Table 1) .
Revised: COLOR benchmark (Table 1) .

Original: We evaluate on the same subset of the COLOR02/03 benchmark (Col, 2002) as Lemos et al.
Revised: We evaluate on the same subset of the COLOR02/03 benchmark (Col, 2002) as Lemos et al.

Original: (2019), consisting of 20 instances of size between 25 and 561 nodes.
Revised: (2019), consisting of 20 instances of size between 25 and 561 nodes.

Original: Our greedy policy outperforms both Largest-First and Smallest-Last and is tied with DSATUR for the most graphs solved optimally.
Revised: Our greedy policy outperforms both Largest-First and Smallest-Last and is tied with DSATUR for the most graphs solved optimally.

Original: When sampling ( 100 samples) to evaluate the policy, our model outperforms all baselines in both mean cost and win percentage and is tied for the most graphs solved optimally.
Revised: When sampling ( 100 samples) to evaluate the policy, our model outperforms all baselines in both mean cost and win percentage and is tied for the most graphs solved optimally.

Original: The approximation ratio is 1.25 and 1.13 for our greedy and sampling policies, resp.
Revised: The approximation ratio is 1.25 and 1.13 for our greedy and sampling policies, resp.

Original: Results on classic graphs.
Revised: Results on classic graphs.

Original: We also trained our model on four families of sparse graphs: cycles, wheels, random trees, and stars.
Revised: We also trained our model on four families of sparse graphs: cycles, wheels, random trees, and stars.

Original: We trained on graphs up to 400 nodes and evaluated on graphs up to 10,000 nodes.
Revised: We trained on graphs up to 400 nodes and evaluated on graphs up to 10,000 nodes.

Original: The produced colorings are optimal or extremely close to optimal for all four families (Table 3).
Revised: The produced colorings are optimal or extremely close to optimal for all four families (Table 3).

Original: As our model works perfectly on cycles and wheels we conclude that the model learns to leverage local graph structure and works even when all nodes have the same degree and are completely symmetrical.
Revised: As our model works perfectly on cycles and wheels we conclude that the model learns to leverage local graph structure and works even when all nodes have the same degree and are completely symmetrical.

Original: Table 4 shows the validation cost for varying instance size on Watts-Strogatz graphs, which grows only slowly with instance size.
Revised: Table 4 shows the validation cost for varying instance size on Watts-Strogatz graphs, which grows only slowly with instance size.

Original: See §B.2 for additional results.
Revised: See §B.2 for additional results.

Original: Qualitative results.
Revised: Qualitative results.

Original: Figure 4 presents typical examples of the learned coloring heuristic on the training distribution graphs.
Revised: Figure 4 presents typical examples of the learned coloring heuristic on the training distribution graphs.

Original: See §E.1 for more examples.
Revised: See §E.1 for more examples.

Original: We can observe that the heuristic generally
Revised: We can observe that the heuristic generally

Original: [Table]
Revised: [Table]

Original: picks higher degree, centrally located nodes ﬁrst.
Revised: picks higher degree, centrally located nodes ﬁrst.

Original: However, if several nodes have the same degree, it favors coloring neighboring nodes subsequently.
Revised: However, if several nodes have the same degree, it favors coloring neighboring nodes subsequently.

Original: This happens in the WS graphs, see Figure 4b.
Revised: This happens in the WS graphs, see Figure 4b.

Original: The learned heuristic can consistently color the WS graphs with 4 colors, which matches the Smallest-Last heuristic.
Revised: The learned heuristic can consistently color the WS graphs with 4 colors, which matches the Smallest-Last heuristic.

Original: We conclude that the learned heuristic captures complex aspects of the graph extending beyond simple degree-based decisions and considers the graph’s local neighborhood structure.
Revised: We conclude that the learned heuristic captures complex aspects of the graph extending beyond simple degree-based decisions and considers the graph’s local neighborhood structure.

Original: Runtime (Figure 6) .
Revised: Runtime (Figure 6) .

Original: We compare the runtime of our approach with the classical baselines.
Revised: We compare the runtime of our approach with the classical baselines.

Original: As we did not have access to the code of Lemos et al.
Revised: As we did not have access to the code of Lemos et al.

Original: (2019), we could not compare the runtime directly.
Revised: (2019), we could not compare the runtime directly.

Original: Our approach is faster than DSATUR for graphs larger than 640 nodes and scales much better.
Revised: Our approach is faster than DSATUR for graphs larger than 640 nodes and scales much better.

Original: As expected from §3.3, the runtime of our algorithm grows linearly with the size of the graph, similar to the simpler baselines such as Largest First and Smallest Last, which have better constant factors.
Revised: As expected from §3.3, the runtime of our algorithm grows linearly with the size of the graph, similar to the simpler baselines such as Largest First and Smallest Last, which have better constant factors.

Original: 4. M INIMUM V ERTEX C OVER
Revised: 4. M INIMUM V ERTEX C OVER

Original: Classic baselines.
Revised: Classic baselines.

Original: We compare with two classic algorithms.
Revised: We compare with two classic algorithms.

Original: First, we use the endpoints of a maximal matching, which produces a 2 -approximation Papadimitriou & Steiglitz (1982).
Revised: First, we use the endpoints of a maximal matching, which produces a 2 -approximation Papadimitriou & Steiglitz (1982).

Original: Second, we compare with list-right Delbot & Laforest (2008), a √ ∆2 + 32 approximation algorithm for maximum degree ∆ .
Revised: Second, we compare with list-right Delbot & Laforest (2008), a √ ∆2 + 32 approximation algorithm for maximum degree ∆ .

Original: Machine learning baselines.
Revised: Machine learning baselines.

Original: S2V-DQN is a Q -learning based approach (Dai et al., 2017).
Revised: S2V-DQN is a Q -learning based approach (Dai et al., 2017).

Original: We use the values reported in the original paper.
Revised: We use the values reported in the original paper.

Original: Li et al.
Revised: Li et al.

Original: (2018) present a tree-search based approach trained in a supervised way.
Revised: (2018) present a tree-search based approach trained in a supervised way.

Original: In contrast to S2V-DQN, it samples multiple solutions, then veriﬁes if they are feasible.
Revised: In contrast to S2V-DQN, it samples multiple solutions, then veriﬁes if they are feasible.

Original: The time to construct a feasible solution varies depending on the instance.
Revised: The time to construct a feasible solution varies depending on the instance.

Original: We use the publicly available code and pretrained model from the authors.
Revised: We use the publicly available code and pretrained model from the authors.

Original: We run Li et al.
Revised: We run Li et al.

Original: ’s code until it ﬁnds a feasible solution, and sample more solutions if it is below the time budget of 30 seconds per graph.
Revised: ’s code until it ﬁnds a feasible solution, and sample more solutions if it is below the time budget of 30 seconds per graph.

Original: Results on in-distribution graphs.
Revised: Results on in-distribution graphs.

Original: We evaluate and compare our approach for MVC with S2VDQN (Dai et al., 2017) and Li et al.
Revised: We evaluate and compare our approach for MVC with S2VDQN (Dai et al., 2017) and Li et al.

Original: (2018) on the same dataset of generated graphs as Dai et al.
Revised: (2018) on the same dataset of generated graphs as Dai et al.

Original: It consists of 16,000 graphs from two distributions, Erd ˝ os-Rényi (ER) (Erd ˝ os & Rényi, 1960) and Barabási-Albert (BA) (Albert & Barabási, 2002), of sizes varying from 20 to 600 nodes.
Revised: It consists of 16,000 graphs from two distributions, Erd ˝ os-Rényi (ER) (Erd ˝ os & Rényi, 1960) and Barabási-Albert (BA) (Albert & Barabási, 2002), of sizes varying from 20 to 600 nodes.

Original: We use the results reported by Dai et al.
Revised: We use the results reported by Dai et al.

Original: (2017) on their model trained on 40–50 nodes, except for the graphs with less than 40 nodes, for which no data is available for this model.
Revised: (2017) on their model trained on 40–50 nodes, except for the graphs with less than 40 nodes, for which no data is available for this model.

Original: Hence we use their model trained on 20–40 nodes on these smaller graphs.
Revised: Hence we use their model trained on 20–40 nodes on these smaller graphs.

Original: See Table 2 for the results on ER graphs and §B.3 for results on additional graphs.
Revised: See Table 2 for the results on ER graphs and §B.3 for results on additional graphs.

Original: On ER graphs, our model achieves the closest average approximation ratio, followed by Li et al.
Revised: On ER graphs, our model achieves the closest average approximation ratio, followed by Li et al.

Original: Li et al.
Revised: Li et al.

Original: (2018) has the lowest average cost.
Revised: (2018) has the lowest average cost.

Original: Note that the lowest approximation ratio and lowest cost need not coincide because the cost grows quickly with graph size, whereas the approximation ratio does not.
Revised: Note that the lowest approximation ratio and lowest cost need not coincide because the cost grows quickly with graph size, whereas the approximation ratio does not.

Original: Our model and Li et al.
Revised: Our model and Li et al.

Original: (2018) outperform the greedy baseline, while S2V-DQN is slightly outperformed by List Right.
Revised: (2018) outperform the greedy baseline, while S2V-DQN is slightly outperformed by List Right.

Original: In Table 4, we show how the approximation ratio and cost depend on the instance size.
Revised: In Table 4, we show how the approximation ratio and cost depend on the instance size.

Original: As shown in §B.3, on the BA graphs, our model is about 2 .
Revised: As shown in §B.3, on the BA graphs, our model is about 2 .

Original: 3% away from optimal.
Revised: 3% away from optimal.

Original: The two machine learning baselines are slightly less than 1% away from optimal.
Revised: The two machine learning baselines are slightly less than 1% away from optimal.

Original: The greedy baselines are 9% − 45% away from optimal.
Revised: The greedy baselines are 9% − 45% away from optimal.

Original: Qualitative Results.
Revised: Qualitative Results.

Original: Figure 5 shows typical results of our learned MVC heuristics.
Revised: Figure 5 shows typical results of our learned MVC heuristics.

Original: See §E.2 for more examples.
Revised: See §E.2 for more examples.

Original: On the ER graphs, we can see that the heuristic does not always start with the highest degree node.
Revised: On the ER graphs, we can see that the heuristic does not always start with the highest degree node.

Original: In contrast, on the BA graphs, the heuristic has a strong preference to start with the highest degree node.
Revised: In contrast, on the BA graphs, the heuristic has a strong preference to start with the highest degree node.

Original: Unlike the classic greedy heuristics (and our learned graph coloring heuristic), the learned MVC heuristics seldomly pick neighboring nodes subsequently.
Revised: Unlike the classic greedy heuristics (and our learned graph coloring heuristic), the learned MVC heuristics seldomly pick neighboring nodes subsequently.

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: Runtime.
Revised: Runtime.

Original: As shown in §B.5, our approach takes less than 1 second to ﬁnd a cover on the test graphs with 1 , 000 nodes on a CPU per sample, and around 9 seconds for 10 samples.
Revised: As shown in §B.5, our approach takes around 0 . 5 second to ﬁnd a cover on the test graphs with 1 , 000 nodes on a CPU per sample, and around 5 seconds for 10 samples.

Original: This is about the same as Dai et al.
Revised: This is comparable to what Dai et al.

Original: (2017) reported on a GPU on a similar graph ( 11 seconds).
Revised: (2017) reported on a GPU on a similar graph ( 11 seconds).

Original: Note that the time budget for Li et al.
Revised: Note that the time budget for Li et al.

Original: (2018) was 30 seconds and the time budget for the combinatorial solver was 1 hour.
Revised: (2018) was 30 seconds and the time budget for the combinatorial solver was 1 hour.

Original: 4. A BLATION S TUDIES
Revised: 4. A BLATION S TUDIES

Original: Spatial locality.
Revised: Spatial locality.

Original: We test the inductive biases we made regarding locality of the decoder by comparing against a decoder variant that never updates the attention weights ( static decoding ) and a variant that always updates all of the attention weights ( global decoding ).
Revised: We test the inductive biases we made regarding locality of the decoder by comparing against a decoder variant that never updates the attention weights ( static decoding ) and a variant that always updates all of the attention weights ( global decoding ).

Original: Static decoding never recomputes the attention weights.
Revised: Static decoding never recomputes the attention weights.

Original: For node a node i that is not yet labeled, its weight is:
Revised: For node a node i that is not yet labeled, its weight is:

Original: [Equation]
Revised: [Equation]

Original: (cid:17) .
Revised: (cid:17) .

Original: Static decoding uses O ( d 2 n + m + n 2 ) operations, which are fewer than those of local update decoding when m (cid:29) d 2 n .
Revised: Static decoding uses O ( d 2 n + m + n 2 ) operations, which are fewer than those of local update decoding when m (cid:29) d 2 n .

Original: With static decoding, the model is essentially a GNN with a special node-readout function.
Revised: With static decoding, the model is essentially a GNN with a special node-readout function.

Original: Global decoding recomputes the attention weights in each time step t .
Revised: Global decoding recomputes the attention weights in each time step t .

Original: For a node i that is not yet labeled, its weight is: a ( t ) i =
Revised: For a node i that is not yet labeled, its weight is: a ( t ) i =

Original: C · tanh
Revised: C · tanh

Original: [Equation]
Revised: [Equation]

Original: (cid:17) .
Revised: (cid:17) .

Original: Global decoding uses O ( d 2 n 2 ) operations, which is at least a d 2 factor more than local update decoding for not too dense graphs ( m (cid:28) n 2 /d 2 ) .
Revised: Global decoding uses O ( d 2 n 2 ) operations, which is at least a d 2 factor more than local update decoding for not too dense graphs ( m (cid:28) n 2 /d 2 ) .

Original: When there are only two labels (as for MVC), global decoding is very similar to the Kool et al.
Revised: When there are only two labels (as for MVC), global decoding is very similar to the Kool et al.

Original: (2019) model.
Revised: (2019) model.

Original: The difference to Kool et al.
Revised: The difference to Kool et al.

Original: (2019) is that they use additional attention layer to compute a new state embedding in each step.
Revised: (2019) is that they use additional attention layer to compute a new state embedding in each step.

Original: We train graph coloring models with both static and global decoding on the Lemos et al.
Revised: We train graph coloring models with both static and global decoding on the Lemos et al.

Original: (2019) subset of the COLOR challenge graphs (following §4.1).
Revised: (2019) subset of the COLOR challenge graphs (following §4.1).

Original: Static and global decoding achieve a mean cost of 10.74 ± 0 .
Revised: Static and global decoding achieve a mean cost of 10.74 ± 0 .

Original: 12 and 10.71 ± 0 .
Revised: 12 and 10.71 ± 0 .

Original: 05 , respectively, both worse than when using our inductive bias (Table 1).
Revised: 05 , respectively, both worse than when using our inductive bias (Table 1).

Original: Architecture Parameters.
Revised: Architecture Parameters.

Original: We varied the size of the context embedding (i.e., the number of nodes and their labels that contribute to it).
Revised: We varied the size of the context embedding (i.e., the number of nodes and their labels that contribute to it).

Original: Increasing the context size does not signiﬁcantly improve the test score on graph coloring.
Revised: Increasing the context size does not signiﬁcantly improve the test score on graph coloring.

Original: For graph coloring, a context of size two and three results in a mean cost of 10 . 49 ± 0 .
Revised: For graph coloring, a context of size two and three results in a mean cost of 10 . 49 ± 0 .

Original: 12 and 10 .
Revised: 12 and 10 .

Original: 42 ± 0 .
Revised: 42 ± 0 .

Original: 12 , respectively, for the greedy policy.
Revised: 12 , respectively, for the greedy policy.

Original: We varied the number of attention heads (among 1, 2, 4) with a per-head dimension of 16.
Revised: We varied the number of attention heads (among 1, 2, 4) with a per-head dimension of 16.

Original: For graph coloring, this results in a mean validation cost of 5 .
Revised: For graph coloring, this results in a mean validation cost of 5 .

Original: 29 ± 0 .
Revised: 29 ± 0 .

Original: 98 ± 0 . 01 , and 4 .
Revised: 98 ± 0 . 01 , and 4 .

Original: 95 ± 0 . 02 , respectively.
Revised: 95 ± 0 . 02 , respectively.

Original: We therefore use 4 attention heads (hidden dimension 64).
Revised: We therefore use 4 attention heads (hidden dimension 64).

Original: In §B.4, we provide additional ablation studies for the encoder.
Revised: In §B.4, we provide additional ablation studies for the encoder.

Original:  C ONCLUSION
Revised:  C ONCLUSION

Original: We introduced combinatorial node labeling , a framework that generalizes existing approaches to many hard graph problems, and presented a neural network architecture for it, which demonstrates excellent results on both graph coloring and minimum vertex cover problems.
Revised: We introduced combinatorial node labeling , a framework that generalizes existing approaches to many hard graph problems, and presented a neural network architecture for it, which demonstrates excellent results on both graph coloring and minimum vertex cover problems.

Original: This serves as an important step toward replacing hand-crafted heuristics in graph algorithms with learned heuristics tailored to a particular problem and graph structure.
Revised: This serves as an important step toward replacing hand-crafted heuristics in graph algorithms with learned heuristics tailored to a particular problem and graph structure.

Original: There are many avenues for future research.
Revised: There are many avenues for future research.

Original: While the nodel labeling framework is very general, other graph problems may require adjustments to the neural architecture or inductive biases for good performance.
Revised: While the nodel labeling framework is very general, other graph problems may require adjustments to the neural architecture or inductive biases for good performance.

Original: In particular, handling weighted graphs and edge labeling problems would be valuable.
Revised: In particular, handling weighted graphs and edge labeling problems would be valuable.

Original: E THICS S TATEMENT
Revised: E THICS S TATEMENT

Original: The combinatorial node labeling framework and our neural network architecture target a broad class of graph problems, and hence are very general-purpose.
Revised: The combinatorial node labeling framework and our neural network architecture target a broad class of graph problems, and hence are very general-purpose.

Original: Downstream tasks of such problems range from compiler passes to logistics optimization to graph data mining.
Revised: Downstream tasks of such problems range from compiler passes to logistics optimization to graph data mining.

Original: Hence, it is hard to identify speciﬁc cases of beneﬁt or harm from our work, as it depends on the speciﬁc application of the downstream tasks.
Revised: Hence, it is hard to identify speciﬁc cases of beneﬁt or harm from our work, as it depends on the speciﬁc application of the downstream tasks.

Original: We nevertheless urge careful consideration of the implications of improving performance on tasks using our methods, especially ones with privacy implications (e g., data mining).
Revised: We nevertheless urge careful consideration of the implications of improving performance on tasks using our methods, especially ones with privacy implications (e g., data mining).

Original: R EPRODUCIBILITY S TATEMENT
Revised: R EPRODUCIBILITY S TATEMENT

Original: We detail the combinatorial node labeling framework in §2, and describe the neural network architecture and training process we use in §3.
Revised: We detail the combinatorial node labeling framework in §2, and describe the neural network architecture and training process we use in §3.

Original: We note that the node labeling framework is very general and alternative architectures could be used to solve it.
Revised: We note that the node labeling framework is very general and alternative architectures could be used to solve it.

Original: Proofs of our theoretical claims are provided in §C and we give details of our training setup in §4 and §A. We additionally include our source code in the supplementary material to aid reproducibility
Revised: Proofs of our theoretical claims are provided in §C and we give details of our training setup in §4 and §A. We additionally include our source code in the supplementary material to aid reproducibility

Original: A T RAINING A. D ATA G ENERATION
Revised: A T RAINING A. D ATA G ENERATION

Original: We use four different synthetic graph distributions to generate instances for training and validation.
Revised: We use four different synthetic graph distributions to generate instances for training and validation.

Original: All graphs are generated via the Python N ETWORKX library (Hagberg et al., 2008).
Revised: All graphs are generated via the Python N ETWORKX library (Hagberg et al., 2008).

Original: Barabási-Albert Model (Albert & Barabási, 2002)
Revised: Barabási-Albert Model (Albert & Barabási, 2002)

Original: The Barabási-Albert (BA) Model generates random scale-free networks.
Revised: The Barabási-Albert (BA) Model generates random scale-free networks.

Original: Similar to real-world networks BA graphs grow by preferential attachment, i.e., a new node is more likely to link to more connected nodes.
Revised: Similar to real-world networks BA graphs grow by preferential attachment, i.e., a new node is more likely to link to more connected nodes.

Original: The model is parameterized by one parameter δ , which dictates the average degree.
Revised: The model is parameterized by one parameter δ , which dictates the average degree.

Original: Erd˝os-Rényi Model (Erd˝os & Rényi, 1960)
Revised: Erd˝os-Rényi Model (Erd˝os & Rényi, 1960)

Original: An Erd˝os-Rényi (ER) graph G ( n, p ) has n nodes and each edge exists independently with probability p .
Revised: An Erd˝os-Rényi (ER) graph G ( n, p ) has n nodes and each edge exists independently with probability p .

Original: The expected number of edges is (cid:0) n 2 (cid:1) p .
Revised: The expected number of edges is (cid:0) n 2 (cid:1) p .

Original: Watts-Strogatz Model (Watts & Strogatz, 1998)
Revised: Watts-Strogatz Model (Watts & Strogatz, 1998)

Original: Watts-Strogatz (WS) graphs were developed to overcome the shortcomings of ER graphs when modeling real world graphs.
Revised: Watts-Strogatz (WS) graphs were developed to overcome the shortcomings of ER graphs when modeling real world graphs.

Original: In real networks we see the formation of local clusters, i.e., the neighbors of a node are more likely to be neighbors.
Revised: In real networks we see the formation of local clusters, i.e., the neighbors of a node are more likely to be neighbors.

Original: For parameters k and q , a WS graph is built as follows: build a ring of n nodes.
Revised: For parameters k and q , a WS graph is built as follows: build a ring of n nodes.

Original: Next, connect each node to its k nearest neighbors.
Revised: Next, connect each node to its k nearest neighbors.

Original: Finally, replace each edge { u, v } by a new edge { u, w } (chosen uniformly at random) with probability q .
Revised: Finally, replace each edge { u, v } by a new edge { u, w } (chosen uniformly at random) with probability q .

Original: A.1. T RAINING SET PARAMETERS
Revised: A.1. T RAINING SET PARAMETERS

Original: See Table 5 for the parameters of the graph distributions used during training.
Revised: See Table 5 for the parameters of the graph distributions used during training.

Original: Note that for BA and ER graphs, the parameters match those used in the Dai et al.
Revised: Note that for BA and ER graphs, the parameters match those used in the Dai et al.

Original: (2017) test set (see Table 2 and
Revised: (2017) test set (see Table 2 and

Original: Table 10).
Revised: Table 10).

Original: We also consider sparse ER graphs (S-ER), for we set the edge probability such that graphs have expected average degree close to ∆ = 7 . 5 when n is small but remain connected with high probability when n is large.
Revised: We also consider sparse ER graphs (S-ER), for we set the edge probability such that graphs have expected average degree close to ∆ = 7 . 5 when n is small but remain connected with high probability when n is large.

Original: This means that p s − er = min (cid:18) 1 , max (cid:18) ∆ n ,
Revised: This means that p s − er = min (cid:18) 1 , max (cid:18) ∆ n ,

Original: (1 + (cid:15) )ln n n (cid:19)(cid:19)
Revised: (1 + (cid:15) )ln n n (cid:19)(cid:19)

Original: [Equation]
Revised: [Equation]

Original: for a small (cid:15) , which we set to 0 .
Revised: for a small (cid:15) , which we set to 0 .

Original: 2 in our experiments.
Revised: 2 in our experiments.

Original: The formula is derived from the connectivity threshold of ER graphs (Erd˝os & Rényi, 1960).
Revised: The formula is derived from the connectivity threshold of ER graphs (Erd˝os & Rényi, 1960).

Original: For graph coloring, we train on a hybrid dataset consisting of an equal proportion of BA, S-ER, and WS graphs.
Revised: For graph coloring, we train on a hybrid dataset consisting of an equal proportion of BA, S-ER, and WS graphs.

Original: For minimum vertex cut, we train on a dataset consisting of BA graphs, a dataset consisting of ER graphs, and a hybrid dataset consisting on a combination of the two (in equal proportion).
Revised: For minimum vertex cut, we train on a dataset consisting of BA graphs, a dataset consisting of ER graphs, and a hybrid dataset consisting on a combination of the two (in equal proportion).

Original: We use the in-distribution models for the evaluation on the synthetic test instances and the hybrid model for the memetracker graph.
Revised: We use the in-distribution models for the evaluation on the synthetic test instances and the hybrid model for the memetracker graph.

Original: During training, we use an equal proportion of graphs with n ∈ { 20 , 40 , 50 , 70 , 100 } nodes.
Revised: During training, we use an equal proportion of graphs with n ∈ { 20 , 40 , 50 , 70 , 100 } nodes.

Original: For the results on simple graphs in Table 3, we use graphs with sizes n ∈ { 10 , . . .
Revised: For the results on simple graphs in Table 3, we use graphs with sizes n ∈ { 10 , . . .

Original: , 51 , 60 , 61 , 70 , 71 , 80 , 81 , 90 , 91 , 99 , 100 , 200 , 201 , 300 , 301 , 400 , 401 } and validate on 1000 or 1001 nodes.
Revised: , 51 , 60 , 61 , 70 , 71 , 80 , 81 , 90 , 91 , 99 , 100 , 200 , 201 , 300 , 301 , 400 , 401 } and validate on 1000 or 1001 nodes.

Original: A. P OLICY O PTIMIZATION
Revised: A. P OLICY O PTIMIZATION

Original: We train our model with R EINFORCE with a greedy rollout baseline Kool et al.
Revised: We train our model with R EINFORCE with a greedy rollout baseline Kool et al.

Original: The details follow.
Revised: The details follow.

Original: We denote the cost of labeling the graph G i in the order given by the sequence of nodes π by L ( π, G i ) .
Revised: We denote the cost of labeling the graph G i in the order given by the sequence of nodes π by L ( π, G i ) .

Original: A model M is parameterized by parameters θ .
Revised: A model M is parameterized by parameters θ .

Original: On a graph G i , the model returns a sequence of nodes π and an associated probability p θ .
Revised: On a graph G i , the model returns a sequence of nodes π and an associated probability p θ .

Original: The probability p θ is the product of all action probabilities that led to the sequence of nodes π .
Revised: The probability p θ is the product of all action probabilities that led to the sequence of nodes π .

Original: We write p θ , π ← M θ ( G i ) when the policy is evaluated deterministically and p θ , π ∼ M θ
Revised: We write p θ , π ← M θ ( G i ) when the policy is evaluated deterministically and p θ , π ∼ M θ

Original: ( G i ) when the policy is evaluated probabilistically.
Revised: ( G i ) when the policy is evaluated probabilistically.

Original: [Table]
Revised: [Table]

Original: δ =p = 0 .p
Revised: δ =p = 0 .p

Original: = p s − er k = 5 , q = 0 .
Revised: = p s − er k = 5 , q = 0 .

Original: 1: Input number
Revised: 1: Input number

Original: E , batch
Revised: E , batch

Original: D train 2: Initialize baseline
Revised: D train 2: Initialize baseline

Original: 3: D challenge ← sample new challenge dataset 4: for epoch = 1 , . . .
Revised: 3: D challenge ← sample new challenge dataset 4: for epoch = 1 , . . .

Original: , E do 5: for batch in D train do 6: [ p θ,i , π i ∼ M θ ( G i ) for G i in batch ]
Revised: , E do 5: for batch in D train do 6: [ p θ,i , π i ∼ M θ ( G i ) for G i in batch ]

Original: (cid:46) Sample from policy 7: [ p BLθ,i , π BLi ← M θ BL ( G i ) for G i in batch ] (cid:46)
Revised: (cid:46) Sample from policy 7: [ p BLθ,i , π BLi ← M θ BL ( G i ) for G i in batch ] (cid:46)

Original: Greedy baseline 8: ∇ θ J ( θ ) = 1 B (cid:80) Bi
Revised: Greedy baseline 8: ∇ θ J ( θ ) = 1 B (cid:80) Bi

Original: =

Revised: =

Original: ( L ( π i | G i ) − L ( π BLi | G i )) ∇ θ log( p θ,i ) (cid:46) Policy Gradient 9: θ ← A DAM ( θ, ∇ θ J ( θ )) 10: end for 11: if OneSidedPairedTTest( M θ , M BLθ , D challenge ) < 0 .
Revised: ( L ( π i | G i ) − L ( π BLi | G i )) ∇ θ log( p θ,i ) (cid:46) Policy Gradient 9: θ ← A DAM ( θ, ∇ θ J ( θ )) 10: end for 11: if OneSidedPairedTTest( M θ , M BLθ , D challenge ) < 0 .

Original: then (cid:46) Challenge the baseline 12: θ BL ← θ 13:
Revised: then (cid:46) Challenge the baseline 12: θ BL ← θ 13:

Original: D challenge ← sample new challenge dataset 14: end if 15: end for
Revised: D challenge ← sample new challenge dataset 14: end if 15: end for

Original: The complete training procedure is given in Algorithm 1.
Revised: The complete training procedure is given in Algorithm 1.

Original: Algorithm 1 follows from the textbook
Revised: Algorithm 1 follows from the textbook

Original: R EINFORCE with a baseline (Sutton & Barto, 2018) by factoring the probability of reaching a terminal state and using that the rewards are 0 in our MDP except when reaching a terminal state.
Revised: R EINFORCE with a baseline (Sutton & Barto, 2018) by factoring the probability of reaching a terminal state and using that the rewards are 0 in our MDP except when reaching a terminal state.

Original: Unlike Kool et al.
Revised: Unlike Kool et al.

Original: (2019), we do not use warmup epochs where training starts out with an exponential moving average baseline.
Revised: (2019), we do not use warmup epochs where training starts out with an exponential moving average baseline.

Original: B A DDITIONAL R ESULTS B. V ALIDATION R ESULTS
Revised: B A DDITIONAL R ESULTS B. V ALIDATION R ESULTS

Original: We compare the cost of the learned heuristic for different parameters of the training.
Revised: We compare the cost of the learned heuristic for different parameters of the training.

Original: The validation set consists of 600 graphs with n nodes for n ∈ { 20 , 50 , 100 , 200 , 400 , 600 } .
Revised: The validation set consists of 600 graphs with n nodes for n ∈ { 20 , 50 , 100 , 200 , 400 , 600 } .

Original: B.1. G RAPH COLORING
Revised: B.1. G RAPH COLORING

Original: Table 6 shows the validation cost on the three training distribution for all evaluated conﬁgurations.
Revised: Table 6 shows the validation cost on the three training distribution for all evaluated conﬁgurations.

Original: With a larger learning rate of α = 10 − 3 , the mean validation cost for graph coloring is signiﬁcantly worse, namely 5 .
Revised: With a larger learning rate of α = 10 − 3 , the mean validation cost for graph coloring is signiﬁcantly worse, namely 5 .

Original: 22 ± 0 .
Revised: 22 ± 0 .

Original: A smaller learning rate of α = 10 − 5 leads to a mean validation cost of 5 .
Revised: A smaller learning rate of α = 10 − 5 leads to a mean validation cost of 5 .

Original: 02 ± 0 .
Revised: 02 ± 0 .

Original: 001 , which is slightly worse than the cost of 4 .
Revised: 001 , which is slightly worse than the cost of 4 .

Original: 95 ± 0 .
Revised: 95 ± 0 .

Original: for α = 10 − 4 .
Revised: for α = 10 − 4 .

Original: B.1. M INIMUM VERTEX COVER
Revised: B.1. M INIMUM VERTEX COVER

Original: Table 7 shows the validation results for training on either only one distribution and evaluating on ER and BA graphs.
Revised: Table 7 shows the validation results for training on either only one distribution and evaluating on ER and BA graphs.

Original: Training on a mixture ER and BA graphs leads to worse validation cost on BA graphs compared to training only on BA graphs.
Revised: Training on a mixture ER and BA graphs leads to worse validation cost on BA graphs compared to training only on BA graphs.

Original: Training on ER graphs exclusively without BA graphs leads to a slight cost improvement on ER graphs.
Revised: Training on ER graphs exclusively without BA graphs leads to a slight cost improvement on ER graphs.

Original: B. R ESULTS BY S IZE
Revised: B. R ESULTS BY S IZE

Original: Table 8 shows how the cost and approximation ratio of our MVC approach varies with the instance size (on the ER test graphs).
Revised: Table 8 shows how the cost and approximation ratio of our MVC approach varies with the instance size (on the ER test graphs).

Original: Although the approximation ratio grows slightly with instance size, it remains within ca 5.5% of optimal for graphs with 500-600 nodes.
Revised: Although the approximation ratio grows slightly with instance size, it remains within ca 5.5% of optimal for graphs with 500-600 nodes.

Original: Table 9 shows how the cost of GC varies on two synthetic distributions of graphs, S-ER and BA.
Revised: Table 9 shows how the cost of GC varies on two synthetic distributions of graphs, S-ER and BA.

Original: For
Revised: For

Original: BA and ER graphs, the cost grows by about one color on the larger graphs.
Revised: BA and ER graphs, the cost grows by about one color on the larger graphs.

Original: B. A DDITIONAL R ESULTS FOR MVC
Revised: B. A DDITIONAL R ESULTS FOR MVC

Original: Results on BA graphs See Table 10 for the MVC results on BA graphs.
Revised: Results on BA graphs See Table 10 for the MVC results on BA graphs.

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: l a ss .
Revised: l a ss .

Original: [Table] [Table]
Revised: [Table] [Table]

Original: Li et al.
Revised: Li et al.

Original: [Table]
Revised: [Table]

Original: N/A
Revised: N/A

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: B. A BLATION S TUDIES FOR THE E NCODER
Revised: B. A BLATION S TUDIES FOR THE E NCODER

Original: We varied the number of layers in the encoder, removed the shortcut connections, and removed the normalization.
Revised: We varied the number of layers in the encoder, removed the shortcut connections, and removed the normalization.

Original: The results are summarized in Table 6.
Revised: The results are summarized in Table 6.

Original: We can see that removing the shortcut connections has a very strong detrimental effect on the validation cost.
Revised: We can see that removing the shortcut connections has a very strong detrimental effect on the validation cost.

Original: Removing both shortcuts and normalization deteriorates the cost further.
Revised: Removing both shortcuts and normalization deteriorates the cost further.

Original: Using 2 layers results in a small, but noticeable increase in cost, whereas a single layer has a signiﬁcantly worse cost
Revised: Using 2 layers results in a small, but noticeable increase in cost, whereas a single layer has a signiﬁcantly worse cost

Original: [Figure]
Revised: [Figure]

Original: B. R UNTIME S CALABILITY
Revised: B. R UNTIME S CALABILITY

Original: We evaluated the inference runtime on a c2d-highmem-4 (4 vCPUs, 32 GB RAM)
Revised: We evaluated the inference runtime on a c2d-highmem-4 (4 vCPUs, 32 GB RAM)

Original: Google Cloud machine (Environment M94 with PyTorch 1.11).
Revised: Google Cloud machine (Environment M94 with PyTorch 1.11).

Original: Figure 7 show the runtime scaling of our approach on GC and MVC together with a linear least squares ﬁt.
Revised: Figure 7 show the runtime scaling of our approach on GC and MVC together with a linear least squares ﬁt.

Original: In Figure 7b, we see that for graphs up to around 5000 vertices the runtime of GC inference very closely follows a linear trend.
Revised: In Figure 7b, we see that for graphs up to around 5000 vertices the runtime of GC inference very closely follows a linear trend.

Original: For larger graphs, the runtime grows slightly faster than linear, as shown in Figure 7a.
Revised: For larger graphs, the runtime grows slightly faster than linear, as shown in Figure 7a.

Original: Similar results hold for MVC: it takes less than 0 .
Revised: Similar results hold for MVC: it takes less than 0 .

Original: 5 seconds to compute a vertex cover for a graph with 1 , 000 nodes.
Revised: 5 seconds to compute a vertex cover for a graph with 1 , 000 nodes.

Original: Figure 7d and Figure 7c show the distribution of MVC runtimes of up to 5120 nodes.
Revised: Figure 7d and Figure 7c show the distribution of MVC runtimes of up to 5120 nodes.

Original: B. D ISCUSSION .
Revised: B. D ISCUSSION .

Original: It is not surprising that our machine learning approach performs best on in-distribution graphs.
Revised: It is not surprising that our machine learning approach performs best on in-distribution graphs.

Original: Whilst it is desirable to have an approach that generalizes well, if a representative sample of graphs is available for a target applications, this does not pose an issue.
Revised: Whilst it is desirable to have an approach that generalizes well, if a representative sample of graphs is available for a target applications, this does not pose an issue.

Original: Moreover, we have shown that the quality degrades gradually when the test distribution differs from the training distribution.
Revised: Moreover, we have shown that the quality degrades gradually when the test distribution differs from the training distribution.

Original: C A DDITIONAL P ROOFS C. T HE NODE LABELING MDP
Revised: C A DDITIONAL P ROOFS C. T HE NODE LABELING MDP

Original: Proof of Lemma 2.4.
Revised: Proof of Lemma 2.4.

Original: Consider a sequence of actions ( v 1 , (cid:96) 1 ) , . .
Revised: Consider a sequence of actions ( v 1 , (cid:96) 1 ) , . .

Original: , ( v n , (cid:96) n ) ending in a terminal state.
Revised: , ( v n , (cid:96) n ) ending in a terminal state.

Original: For all t , the preﬁx ( v 1 , (cid:96) 1 ) , . . .
Revised: For all t , the preﬁx ( v 1 , (cid:96) 1 ) , . . .

Original: , ( v t , (cid:96) t ) of this sequence corresponds to a partial node labeling c (cid:48)
Revised: , ( v t , (cid:96) t ) of this sequence corresponds to a partial node labeling c (cid:48)

Original: (by viewing the sequence of node-label pairs as describing a function from nodes to labels).
Revised: (by viewing the sequence of node-label pairs as describing a function from nodes to labels).

Original: By construction of the MDP, labeling node v i +1 with (cid:96) t +1 passes the extensibility test for c (cid:48) .
Revised: By construction of the MDP, labeling node v i +1 with (cid:96) t +1 passes the extensibility test for c (cid:48) .

Original: Hence the node labeling c represented by ( v 1 , (cid:96) 1 ) , . .
Revised: Hence the node labeling c represented by ( v 1 , (cid:96) 1 ) , . .

Original: , ( v n , (cid:96) n ) is feasible.
Revised: , ( v n , (cid:96) n ) is feasible.

Original: By construction, the return of the episode is − f ( c ) , where f ( c ) is the cost of node labeling c .
Revised: By construction, the return of the episode is − f ( c ) , where f ( c ) is the cost of node labeling c .

Original: Conversely, consider a feasible solution c with cost f ( c ) .
Revised: Conversely, consider a feasible solution c with cost f ( c ) .

Original: Then, by deﬁnition of feasibility (§4.3), there is a sequence ( v 1 , (cid:96) 1 ) , . . .
Revised: Then, by deﬁnition of feasibility (§4.3), there is a sequence ( v 1 , (cid:96) 1 ) , . . .

Original: , ( v n , (cid:96) n ) of node-label pairs such that for all t ≥ 

Revised: , ( v n , (cid:96) n ) of node-label pairs such that for all t ≥

Original: the partial node labeling given by ( v 1 , (cid:96) 1 ) , . .
Revised: the partial node labeling given by ( v 1 , (cid:96) 1 ) , . .

Original: , ( v t , (cid:96) t ) passes the extensibility test for node v t +1 and label (cid:96) t +1 .
Revised: , ( v t , (cid:96) t ) passes the extensibility test for node v t +1 and label (cid:96) t +1 .

Original: Hence, the sequence of node-label pairs is also a sequence of actions in the MDP leading to a terminal state.
Revised: Hence, the sequence of node-label pairs is also a sequence of actions in the MDP leading to a terminal state.

Original: The return for this episode is − f ( c ) .
Revised: The return for this episode is − f ( c ) .

Original: Note that since our tasks are episodic, the return equals the sum of the rewards (speciﬁcally the reward received in the terminal state).
Revised: Note that since our tasks are episodic, the return equals the sum of the rewards (speciﬁcally the reward received in the terminal state).

Original: In particular, we do not use discounting.
Revised: In particular, we do not use discounting.

Original: C. O PTIMALITY OF THE LABELING RULE
Revised: C. O PTIMALITY OF THE LABELING RULE

Original: Proof of Lemma 3.1.
Revised: Proof of Lemma 3.1.

Original: Let G be some graph with chromatic number χ ( G )
Revised: Let G be some graph with chromatic number χ ( G )

Original: =
Revised: =

Original: k and c ∗ be a mapping that colors G optimally.
Revised: k and c ∗ be a mapping that colors G optimally.

Original: We partition V into color classes C i
Revised: We partition V into color classes C i

Original: = { v | c ∗ ( v )
Revised: = { v | c ∗ ( v )

Original: =
Revised: =

Original: i } such that all nodes with color i are in C i .
Revised: i } such that all nodes with color i are in C i .

Original: Now, we build an ordering by consecutively taking all nodes from C 1 , then all nodes from C 2 and so on.
Revised: Now, we build an ordering by consecutively taking all nodes from C 1 , then all nodes from C 2 and so on.

Original: Choosing the smallest color that passes the extensibility test will produce an optimal coloring for such an order of nodes.
Revised: Choosing the smallest color that passes the extensibility test will produce an optimal coloring for such an order of nodes.

Original: This coloring might be different from the one of c ∗ .
Revised: This coloring might be different from the one of c ∗ .

Original: This is, because a node in C i might have no conﬂicts with some color j < i and therefore this node will be assigned color j .
Revised: This is, because a node in C i might have no conﬂicts with some color j < i and therefore this node will be assigned color j .

Original: However, by assumption all nodes that have color j in c ∗ are already colored and a node from C i can have at most i − 1 conﬂicting colors in its neighborhood.
Revised: However, by assumption all nodes that have color j in c ∗ are already colored and a node from C i can have at most i − 1 conﬂicting colors in its neighborhood.

Original: Hence, the algorithm will produce a coloring of at most k colors, which we assumed to be optimal.
Revised: Hence, the algorithm will produce a coloring of at most k colors, which we assumed to be optimal.

Original: Proof of Lemma 3.2.
Revised: Proof of Lemma 3.2.

Original: Let S be the set over nodes with label 1 in a minimum vertex cover of G .
Revised: Let S be the set over nodes with label 1 in a minimum vertex cover of G .

Original: Order these nodes ﬁrst (in an arbitrary relative order), then order the remaining nodes in V − S after these nodes (in an arbitrary relative order).
Revised: Order these nodes ﬁrst (in an arbitrary relative order), then order the remaining nodes in V − S after these nodes (in an arbitrary relative order).

Original: Now, label the nodes with 1 in this order until every edge has an endpoint with label 1 .
Revised: Now, label the nodes with 1 in this order until every edge has an endpoint with label 1 .

Original: After | S | steps, every node in S has label 1 , meaning that the nodes with label 1 form a minimum vertex cover: If the nodes formed a vertex cover after less than | S | steps, we would ﬁnd a smaller vertex cover, contradicting the minimality of S .
Revised: After | S | steps, every node in S has label 1 , meaning that the nodes with label 1 form a minimum vertex cover: If the nodes formed a vertex cover after less than | S | steps, we would ﬁnd a smaller vertex cover, contradicting the minimality of S .

Original: D L IST OF COMBINATORIAL NODE LABELING PROBLEMS
Revised: D L IST OF COMBINATORIAL NODE LABELING PROBLEMS

Original: We provide an extensive list of classic graph optimization problems framed as node labeling problems.
Revised: We provide an extensive list of classic graph optimization problems framed as node labeling problems.

Original: Note that there can be multiple equivalent formulations.
Revised: Note that there can be multiple equivalent formulations.

Original: For some problems, we consider a weighed graph G with weight function w : E (cid:55)→ R + , we write w ( u, v ) the weight of an edge { u, v } .
Revised: For some problems, we consider a weighed graph G with weight function w : E (cid:55)→ R + , we write w ( u, v ) the weight of an edge { u, v } .

Original: For a set of nodes S , we denote the subgraph of G induced by S with G [ S ] .
Revised: For a set of nodes S , we denote the subgraph of G induced by S with G [ S ] .

Original: The problems in Table 11 require a partition of the nodes as their solution.
Revised: The problems in Table 11 require a partition of the nodes as their solution.

Original: These can be represented as node labeling problems by giving each partition its unique label.
Revised: These can be represented as node labeling problems by giving each partition its unique label.

Original: For many of the problems, the number of used labels determines the cost function.
Revised: For many of the problems, the number of used labels determines the cost function.

Original: The problems in Table 12 require a path (or a sequences of nodes) as their solution, which we represent as node labeling problems by having the label indicate the position in the path (or sequence).
Revised: The problems in Table 12 require a path (or a sequences of nodes) as their solution, which we represent as node labeling problems by having the label indicate the position in the path (or sequence).

Original: The problems in Table 13 require a set of nodes as their solution.
Revised: The problems in Table 13 require a set of nodes as their solution.

Original: These can be represented as node labeling problems by giving the nodes in the solution set the label 1 and the nodes not in the solution set the label 0 .
Revised: These can be represented as node labeling problems by giving the nodes in the solution set the label 1 and the nodes not in the solution set the label 0 .

Original: The cost function is closely related to the number of nodes with label 1 for most of these problems.
Revised: The cost function is closely related to the number of nodes with label 1 for most of these problems.

Original: Problem
Revised: Problem

Original: [Table]
Revised: [Table]

Original: (Kernighan & Lin, 1970)
Revised: (Kernighan & Lin, 1970)

Original: There are no more than
Revised: There are no more than

Original: [Table]
Revised: [Table]

Original: with the same label and at most k labels.
Revised: with the same label and at most k labels.

Original: [Table]
Revised: [Table]

Original: (Kernighan & Lin,
Revised: (Kernighan & Lin,

Original: [Table] [Table]
Revised: [Table] [Table]

Original: the same label and at most k labels.
Revised: the same label and at most k labels.

Original: [Table]
Revised: [Table]

Original: Minimum k -cut (Karger & Stein, 1996)
Revised: Minimum k -cut (Karger & Stein, 1996)

Original: k − | V | − | V
Revised: k − | V | − | V

Original: [Table] [Table]
Revised: [Table] [Table]

Original: and
Revised: and

Original: [Table]
Revised: [Table]

Original: { v
Revised: { v

Original: [Table]
Revised: [Table]

Original: Clique cover (Karp, 1972)
Revised: Clique cover (Karp, 1972)

Original: Every label induces a clique
Revised: Every label induces a clique

Original: [Table]
Revised: [Table]

Original: Domatic number (Hedetniemi & Laskar, 1990)
Revised: Domatic number (Hedetniemi & Laskar, 1990)

Original: Every label induces a dominating set of G [ V (cid:48) ∪ { v } ]
Revised: Every label induces a dominating set of G [ V (cid:48) ∪ { v } ]

Original: Negative
Revised: Negative

Original: [Table]
Revised: [Table]

Original: of labels
Revised: of labels

Original: Graph coloring (Jensen et al., 1995)
Revised: Graph coloring (Jensen et al., 1995)

Original: No neighbor of v has label l
Revised: No neighbor of v has label l

Original: Number of labels
Revised: Number of labels

Original: Graph co-coloring (Jensen et al., 1995)
Revised: Graph co-coloring (Jensen et al., 1995)

Original: The nodes with label l induce an independent set in G or the complement of G
Revised: The nodes with label l induce an independent set in G or the complement of G

Original: Number of labels k -defective coloring (Cowen et al., 1986)
Revised: Number of labels k -defective coloring (Cowen et al., 1986)

Original: No node has more than k neighbors with label l
Revised: No node has more than k neighbors with label l

Original: [Table]
Revised: [Table]

Original: Problem
Revised: Problem

Original: [Table]
Revised: [Table]

Original: × L , v, l )
Revised: × L , v, l )

Original: Cost function f
Revised: Cost function f

Original: Traveling salesman problem (Dantzig et al., 1954) l = max( L ) + 

Revised: Traveling salesman problem (Dantzig et al., 1954) l = max( L ) +

Original: and v is a neighbor of the node in L with label max( L )
Revised: and v is a neighbor of the node in L with label max( L )

Original: [Equation]
Revised: [Equation]

Original: Tree decomposition (Bodlaender, 2005)
Revised: Tree decomposition (Bodlaender, 2005)

Original: l = max( L
Revised: l = max( L

Original: [Equation]
Revised: [Equation]

Original: For a node v i with label i , add edges to G until v i forms a clique with its higher-labeled neighbors.
Revised: For a node v i with label i , add edges to G until v i forms a clique with its higher-labeled neighbors.

Original: The cost is the largest number of higher-labeled neighbors in the augmented graph (Bodlaender, 2005).
Revised: The cost is the largest number of higher-labeled neighbors in the augmented graph (Bodlaender, 2005).

Original: Longest path (Karger et al., 1997)
Revised: Longest path (Karger et al., 1997)

Original: [Equation]
Revised: [Equation]

Original: Maximum number of nodes with consecutive labels that induce a path
Revised: Maximum number of nodes with consecutive labels that induce a path

Original: Problem
Revised: Problem

Original: Extensibility Test T ( V (cid:48)
Revised: Extensibility Test T ( V (cid:48)

Original: × L , v, l )
Revised: × L , v, l )

Original: Cost function f
Revised: Cost function f

Original: Maximum cut (Karp, 1972)
Revised: Maximum cut (Karp, 1972)

Original: At least one node has label−|{{ u,v } ∈ E,l ( u ) (cid:54) =
Revised: At least one node has label−|{{ u,v } ∈ E,l ( u ) (cid:54) =

Original: l ( v ) }|
Revised: l ( v ) }|

Original: Sparsest cut (Arora et al., 2009)
Revised: Sparsest cut (Arora et al., 2009)

Original: At least one node has label|{{ u,v }∈ E, l ( u ) (cid:54) =
Revised: At least one node has label|{{ u,v }∈ E, l ( u ) (cid:54) =

Original: l ( v ) }| |{ v ∈ V, l ( v )=1 }|
Revised: l ( v ) }| |{ v ∈ V, l ( v )=1 }|

Original: Maximum independent set (Tarjan & Trojanowski, 1977) (Robson, 1986)
Revised: Maximum independent set (Tarjan & Trojanowski, 1977) (Robson, 1986)

Original: The subgraph induced by the nodes with label 1 is an independent set −|{ v ∈ V, l ( v ) = 1 }|
Revised: The subgraph induced by the nodes with label 1 is an independent set −|{ v ∈ V, l ( v ) = 1 }|

Original: Minimum vertex cover (node cover) (Karp, 1972)
Revised: Minimum vertex cover (node cover) (Karp, 1972)

Original: The subgraph induced by the nodes with label 1 is a vertex cover of G [ V (cid:48) ∪ { v } ] |{ v ∈ V, l ( v ) = 1 }|
Revised: The subgraph induced by the nodes with label 1 is a vertex cover of G [ V (cid:48) ∪ { v } ] |{ v ∈ V, l ( v ) = 1 }|

Original: Maximum clique (Tomita & Seki, 2003)
Revised: Maximum clique (Tomita & Seki, 2003)

Original: The subgraph induced by the nodes with label 1 is a clique −|{ v ∈ V, l ( v ) = 1 }|
Revised: The subgraph induced by the nodes with label 1 is a clique −|{ v ∈ V, l ( v ) = 1 }|

Original: Minimum feedback node set (Karp, 1972)
Revised: Minimum feedback node set (Karp, 1972)

Original: G [ { u ∈ V (cid:48) ∪ { v } , l ( u ) = 0 } ] is a forest |{ v ∈ V, l ( v ) = 1 }|
Revised: G [ { u ∈ V (cid:48) ∪ { v } , l ( u ) = 0 } ] is a forest |{ v ∈ V, l ( v ) = 1 }|

Original: Metric dimension (Harary & Melter, 1976)
Revised: Metric dimension (Harary & Melter, 1976)

Original: The nodes in V (cid:48) ∪ { v } are uniquely identiﬁed by their distances to nodes with label|{ v ∈ V, l ( v )
Revised: The nodes in V (cid:48) ∪ { v } are uniquely identiﬁed by their distances to nodes with label|{ v ∈ V, l ( v )

Original: = 1 }
Revised: = 1 }

Original: |
Revised: |

Original: Minimum dominating set (Hedetniemi & Laskar, 1990)
Revised: Minimum dominating set (Hedetniemi & Laskar, 1990)

Original: The nodes with label 1 form a dominating set of G [ V (cid:48) ∪ { v } ] |{ v ∈ V, l ( v ) = 1 }|
Revised: The nodes with label 1 form a dominating set of G [ V (cid:48) ∪ { v } ] |{ v ∈ V, l ( v ) = 1 }|

Original: Minimum connected dominating set (Hedetniemi & Laskar, 1990)
Revised: Minimum connected dominating set (Hedetniemi & Laskar, 1990)

Original: The nodes with label 1 form a connected dominating set of G [ V (cid:48) ∪ { v } ] |{ v ∈ V, l ( v ) = 1 }|
Revised: The nodes with label 1 form a connected dominating set of G [ V (cid:48) ∪ { v } ] |{ v ∈ V, l ( v ) = 1 }|

Original: 14(a) Erd˝os-Rényi graph, n = 16 .
Revised: 14(a) Erd˝os-Rényi graph, n = 16 .

Original: (b) Erd˝os-Rényi graph, n = 16 . (c) Erd˝os-Rényi graph, n = 16 .
Revised: (b) Erd˝os-Rényi graph, n = 16 . (c) Erd˝os-Rényi graph, n = 16 .

Original: 4          (d) Erd˝os-Rényi graph, n = 16 .
Revised: 4          (d) Erd˝os-Rényi graph, n = 16 .

Original: (e) Erd˝os-Rényi graph, n = 16 .
Revised: (e) Erd˝os-Rényi graph, n = 16 .

Original: 4          (f) Erd˝os-Rényi graph, n = 16 .
Revised: 4          (f) Erd˝os-Rényi graph, n = 16 .

Original: 3     10 11   (g) Watts-Strogatz graph, n = 16 .
Revised: 3     10 11   (g) Watts-Strogatz graph, n = 16 .

Original: 2 3           (h) Watts-Strogatz graph, n = 16 .
Revised: 2 3           (h) Watts-Strogatz graph, n = 16 .

Original: 46  10 11   (i) Watts-Strogatz graph, n = 16 .
Revised: 46  10 11   (i) Watts-Strogatz graph, n = 16 .

Original: 10    (j) Watts-Strogatz graph, n = 16 .
Revised: 10    (j) Watts-Strogatz graph, n = 16 .

Original: (k) Watts-Strogatz graph,
Revised: (k) Watts-Strogatz graph,

Original: [Figure]
Revised: [Figure]

Original: E A DDITIONAL E XAMPLES E. G RAPH C OLORING
Revised: E A DDITIONAL E XAMPLES E. G RAPH C OLORING

Original: Figure 8 and Figure 9 show additional results of our learned coloring heuristic on in-distribution graphs.
Revised: Figure 8 and Figure 9 show additional results of our learned coloring heuristic on in-distribution graphs.

Original: For the Erd˝os-Rényi graphs and Watts-Strogatz, we provide some examples in a circular layout and some with a force-directed layout.
Revised: For the Erd˝os-Rényi graphs and Watts-Strogatz, we provide some examples in a circular layout and some with a force-directed layout.

Original: The force-directed layout emphasizes the structure of the graph, but for these two graph classes leads to many crossing edges.
Revised: The force-directed layout emphasizes the structure of the graph, but for these two graph classes leads to many crossing edges.

Original: See Figure 10 and Figurefor results on cycles, wheels, and trees.
Revised: See Figure 10 and Figurefor results on cycles, wheels, and trees.

Original: Interestingly, the heuristic picks the highest degree node in a star or wheel sometimes ﬁrst and sometimes last.
Revised: Interestingly, the heuristic picks the highest degree node in a star or wheel sometimes ﬁrst and sometimes last.

Original: 0              (a) Barabási-Albert graph, n = 16 .
Revised: 0              (a) Barabási-Albert graph, n = 16 .

Original: 12  (b) Barabási-Albert graph, n = 16 .
Revised: 12  (b) Barabási-Albert graph, n = 16 .

Original: 10    (c) Barabási-Albert graph, n = 16 .
Revised: 10    (c) Barabási-Albert graph, n = 16 .

Original: 6        (d) Barabási-Albert graph, n = 16 .
Revised: 6        (d) Barabási-Albert graph, n = 16 .

Original: 10    (e) Barabási-Albert graph, n = 16 .
Revised: 10    (e) Barabási-Albert graph, n = 16 .

Original: 4       13 (f) Barabási-Albert graph, n = 16 .
Revised: 4       13 (f) Barabási-Albert graph, n = 16 .

Original: (g) Erd˝os-Rényi graph, n = 20 .
Revised: (g) Erd˝os-Rényi graph, n = 20 .

Original: 0            14    (h) Watts-Strogatz graph, n = 20 .
Revised: 0            14    (h) Watts-Strogatz graph, n = 20 .

Original: 7           (i) Barabási-Albert graph, n = 20 .
Revised: 7           (i) Barabási-Albert graph, n = 20 .

Original: (j) Erd˝os-Rényi graph, n = 20 .
Revised: (j) Erd˝os-Rényi graph, n = 20 .

Original: [Figure]
Revised: [Figure]

Original: Strogatz
Revised: Strogatz

Original: [Figure]
Revised: [Figure]

Original: n = 20 .
Revised: n = 20 .

Original: [Figure]
Revised: [Figure]

Original: Barabási
Revised: Barabási

Original: [Figure]
Revised: [Figure]

Original: Albert graph, n = 20 .
Revised: Albert graph, n = 20 .

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: n
Revised: n

Original: [Table]
Revised: [Table]

Original: (g) Tree graph, n =
Revised: (g) Tree graph, n =

Original: [Table]
Revised: [Table]

Original: [Table]
Revised: [Table]

Original: (j) Tree graph, n =
Revised: (j) Tree graph, n =

Original: [Table]
Revised: [Table]

Original: [Table]
Revised: [Table]

Original: (k) Tree graph, n =
Revised: (k) Tree graph, n =

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Figure]
Revised: [Figure]

Original: (a) Erd˝os-Rényi graph, n = 16 .
Revised: (a) Erd˝os-Rényi graph, n = 16 .

Original: 1              (b) Erd˝os-Rényi graph, n = 17 .
Revised: 1              (b) Erd˝os-Rényi graph, n = 17 .

Original: 7         (c) Erd˝os-Rényi graph, n = 18 .
Revised: 7         (c) Erd˝os-Rényi graph, n = 18 .

Original: (d) Erd˝os-Rényi graph, n = 20 .
Revised: (d) Erd˝os-Rényi graph, n = 20 .

Original: 10   15            29 32   37  (e) Erd˝os-Rényi graph, n = 41 .
Revised: 10   15            29 32   37  (e) Erd˝os-Rényi graph, n = 41 .

Original: 6 7     14                 33    39 (f) Erd˝os-Rényi graph, n = 42 .
Revised: 6 7     14                 33    39 (f) Erd˝os-Rényi graph, n = 42 .

Original: (g) Barabási-Albert graph, n = 16 .
Revised: (g) Barabási-Albert graph, n = 16 .

Original: 5 6         (h) Barabási-Albert graph, n = 17 .
Revised: 5 6         (h) Barabási-Albert graph, n = 17 .

Original: (i) Barabási-Albert graph, n = 18 .
Revised: (i) Barabási-Albert graph, n = 18 .

Original: 5           18(j)
Revised: 5           18(j)

Original: Barabási-Albert graph, n = 20 .
Revised: Barabási-Albert graph, n = 20 .

Original: 0    6 9 10 13  17                35    (k) Barabási-Albert graph, n = 41 .
Revised: 0    6 9 10 13  17                35    (k) Barabási-Albert graph, n = 41 .

Original: (l) Barabási-Albert graph, n = 42 .
Revised: (l) Barabási-Albert graph, n = 42 .

Original: E. M INIMUM V ERTEX C OVER
Revised: E. M INIMUM V ERTEX C OVER

Original: Figure 12 shows additional example covers of our learned heuristic on in-distribution graphs.
Revised: Figure 12 shows additional example covers of our learned heuristic on in-distribution graphs.