Graph Neural Networks Meet Neural-Symbolic Computing: A Survey and Perspective

1 Introduction

Over the last decade Artificial Intelligence in general, and deep learning in particular, have been the focus of intensive research endeavors, gathered media attention and led to debates on their impacts both in academia and industry [Marcus, 2020; Raghavan, 2019]. The recent AI Debate in Montreal with Yoshua Bengio and Gary Marcus [Marcus, 2020], and the AAAI-2020 fireside conversation with Nobel Laureate Daniel Kahneman and the 2018 Turing Award winners and deep learning pioneers Geoff Hinton, Yoshua Bengio and Yann LeCun have led to new perspectives on the future of AI. It has now been argued that if one aims to build richer AI systems, i.e. semantically sound, explainable, and reliable, one has to add a sound reasoning layer to deep learning [Marcus, 2020]. Kahneman has made this point clear when he stated at AAAI-2020 that "...so far as I'm concerned, System 1 certainly knows language... System 2... does involve certain manipulation of symbols." [Kahneman et al., 2020].

Kahneman's comments address recent parallels made by researchers between "Thinking, Fast and Slow" and the socalled "AI's systems 1 and 2", which could, in principle, be modelled by deep learning and symbolic reasoning, respectively. 1 In this paper, we present a survey and relate recent research results on: (1) Neural-Symbolic Computing, by summarizing the main approaches to rich knowledge representation and reasoning within deep learning, and (2) the approach pioneered by the authors and others of Graph Neural Networks (GNNs) for learning and reasoning about problems that require relational structures or symbolic learning. Although recent papers have surveyed GNNs, including [Battaglia et al., 2018; Chami et al., 2020; Wu et al., 2019; Zhang et al., 2018] they have not focused on the relationship between GNNs and neural-symbolic computing (NSC). [Bengio et al., 2018] also touches particular topics related to some we discuss here, in particular to do with metatransfer learning. Recent surveys in neural-symbolic computing [d'Avila Garcez et al., 2015; d'Avila Garcez et al., 2019; Townsend et al., 2019] have not exploited the highly relevant applications of GNNs in symbolic and relational learning, or the relationship between the two approaches.

Our Contribution. As mentioned above, recent work have surveyed graph neural networks and neural-symbolic computing, but to the best of our knowledge, no survey has reviewed and analysed the recent results on the specific relationship between GNNs and NSC. We also outline the promising directions for research and applications combining GNNs and NSC from the perspective of symbolic reasoning tasks. The above-referenced surveys on GNNs, although comprehensive, all describe other application domains. The remainder of the paper is organized as follows. In Section 2, we present an overview and taxonomy of neural-symbolic computing. In Section 3, we discuss the main GNN models and their relationship to neural-symbolic computing. We then outline the main GNN architectures and their use in relational and symbolic learning. Finally, we conclude and point out directions for further research. We shall assume familiarity with neural learning and symbolic AI.

1 "Thinking, Fast and Slow", by Daniel Kahneman: New York, FSG, 2011, describes the author's "... current understanding of judgment and decision making, which has been shaped by psychological discoveries of recent decades."

2 Neural-Symbolic Computing Taxonomy

At this year's Robert S. Engelmore Memorial Lecture, at the AAAI Conference on Artificial Intelligence, New York, February 10th, 2020, Henry Kautz introduced a taxonomy for neural-symbolic computing as part of a talk entitled The Third AI Summer. Six types of neuralsymbolic systems are outlined: (1) SYMBOLIC NEURO SYMBOLIC, (2) SYMBOLIC[NEURO], (3) NEURO;SYMBOLIC, (4) NEURO:SYMBOLIC → NEURO, (5) NEUROSYMBOLIC and (6) NEURO[SYMBOLIC].

The origin of GNNs [Scarselli et al., 2008] can be traced back to neural-symbolic computing (NSC) in that both sought to enrich the vector representations in the inputs of neural networks, first by accepting tree structures and then graphs more generally. In this sense, according to Kautz's taxonomy, GNNs are a TYPE 1 neural-symbolic system. GNNs [Battaglia et al., 2018] were recently combined with convolutional networks in novel ways which have produced impressive results on data efficiency. In parallel, NSC has focused on the learning of adequate embeddings for the purpose of symbolic computation. This branch of neural-symbolic computing, which includes Logic Tensor Networks [Serafini and d'Avila Garcez, 2016] and Tensor Product Representations [Huang et al., 2017] has been called in [d'Avila Garcez et al., 2019] tensorization methods and draw similarities with [Diligenti et al., 2017] that use fuzzy methods in representing first-order logic. These have been classified by Kautz as TYPE 5 neural-symbolic systems, as also discussed in what follows. A natural point of contact between GNNs and NSC is the provision of rich embeddings and attention mechanisms towards structured reasoning and efficient learning.

TYPE 1 neural-symbolic integration is standard deep learning, which some may argue is a stretch to refer to as neuralsymbolic, but which is included here to note that the input and output of a neural network can be made of symbols e.g. in the case of language translation or question answering applications. TYPE 2 are hybrid systems such as DeepMind's AlphaGo and other systems, where the core neural network is loosely-coupled with a symbolic problem solver such as Monte Carlo tree search. TYPE 3 is also a hybrid system whereby a neural network focusing on one task (e.g. object detection) interacts via input/output with a symbolic system specialising in a complementary task (e.g. query answering). Examples include the neuro-symbolic concept learner [Mao et al., 2019] and deepProbLog [Manhaeve et al., 2018; Galassi et al., 2020].

In a TYPE 4 neural-symbolic system, symbolic knowledge is compiled into the training set of a neural network. Kautz offers [Lample and Charton, 2020] as an example. Here, we would also include other tightly-coupled neural-symbolic systems where various forms of symbolic knowledge, not restricted to if-then rules only, can be translated into the initial architecture and set of weights of a neural network [d'Avila Garcez et al., 2009], in some cases with guarantees of correctness. We should also mention [Arabshahi et al., 2018], which learn and reason over mathematical constructions, as well as [Arabshahi et al., 2019], which propose a learning architecture that extrapolates to much harder symbolic maths reasoning problems than what was seen during training. TYPE 5 are those tightly-coupled neural-symbolic systems where a symbolic logic rule is mapped onto a distributed representation (an embedding) and acts as a soft-constraint (a regularizer) on the network's loss function. Examples of these are [Huang et al., 2017] and [Serafini and d'Avila Garcez, 2016].

Finally, TYPE 6 systems should be capable, according to Kautz, of true symbolic reasoning inside a neural engine. It is what one could refer to as a fully-integrated system. Early work in neural-symbolic computing has achieved this: see [d'Avila Garcez et al., 2009] for a historical overview; and some TYPE 4 systems are also capable of it [d'Avila Garcez et al., 2009; d'Avila Garcez et al., 2015; Hitzler et al., 2004], but in a localist rather than a distributed architecture and using simpler forms of embedding than TYPE 5 systems. Kautz adds that TYPE 6 systems should be capable of combinatorial reasoning, suggesting using an attention schema to achieve it effectively. In fact, attention mechanisms can be used to solve graph problems, for example with pointer networks [Vinyals et al., 2015]. It should be noted that the same problems can be solved through other NSC architectures, such as GNNs [Prates et al., 2019]. This idea resonates with the recent proposal outlined by Bengio in the AI debate of December 2019.

In what concerns neural-symbolic computing theory, the study of TYPE 6 systems is highly relevant. In practical terms, a tension exists between effective learning and sound reasoning, which may prescribe the use of a more hybrid approach (TYPES 3 to 5) or variations thereof such as the use of attention with tensorization. Orthogonal to the above taxonomy, but mostly associated so far with TYPE 4, is the study of the limits of reasoning within neural networks w.r.t. full first-order, higher-order and non-classical logic theorem proving [d'Avila Garcez and Lamb, 2003; d'Avila Garcez et al., 2015]. In this paper, as we revisit the use of rich logic embeddings in TYPE 5 systems, notably Logic Tensor Networks [Serafini and d'Avila Garcez, 2016], alongside the use of attention mechanisms or convolutions in GNNs, we will seek to propose a research agenda and specific applications of symbolic reasoning and statistical learning towards the sound development of TYPE 6 systems.

3 Graph Neural Networks Meet Neural-Symbolic Computing

One of the key concepts in machine learning is that of priors or inductive biases - the set of assumptions that a learner uses to compute predictions on test data. In the context of deep learning (DL), the design of neural building blocks that enforce strong priors has been a major source of breakthroughs. For instance, the priors obtained through feedforward layers encourage the learner to combine features additively, while the ones obtained through dropout discourage it to overfit and the ones obtained through multi-task learning encourage it to prefer sets of parameters that explain more than one task.

One of the most influential neural building blocks, having helped pave the way for the DL revolution, is the convolutional layer [LeCun et al., 2015]. Convolutional architectures are successful for tasks defined over Euclidean signals be-

Figure 1: Due to permutation invariance, literals ¬x5 and x3 can exchange places with no effect to the boolean function f(x). There are 5! = 120 such permutations.

cause they enforce equivariance to spatial translation. This is a useful property to have when learning representations for objects regardless of their position in a scene.

Analogously, recurrent layers enforce equivariance in time that is useful for learning over sequential data. Recently, attention mechanisms, through the advent of transformer networks, have enabled advancing the state-of-art in many sequential tasks, notably in natural language processing [Devlin et al., 2019; Goyal et al., 2019] and symbolic reasoning tasks such as solving math equations and integrals 2 [Lample and Charton, 2020]. Attention encourages the learner to combine representations additively, while also enforcing permutation invariance. All three architectures take advantage of sparse connectivity - another important design in DL which is key to enable the training of larger models. Sparse connectivity and neural, building blocks with strong priors usually go hand in hand, as the latter leverage symmetries in the input space to cut down parameters through invariance to different types of transformations. NSC architectures often combine the key design concepts from convolutional networks and attention-based architectures to enforce permutation invariance over the elements of a set or the nodes of a graph (Fig. 1). Some NSC architectures such as Pointer Networks [Vinyals et al., 2015] implement attention directly over a set of inputs X = {x1, . . . , xn} coupled with a decoder that outputs a sequence (i1, i2, . . . in) ∈ [1, n]m of "pointers" to the input elements (hence the name). Note that both formalizations are defined over set inputs rather than sequential ones.

3.1 Logic Tensor Networks

Tensorisation is a class of approaches that embeds first-order logic (FOL) symbols such as constants, facts and rules into real-valued tensors. Normally, constants are represented as one-hot vectors (first-order tensor). Predicates and functions are matrices (second-order tensor) or higher-order tensors.

In early work, embedding techniques were proposed to transform symbolic representations into vector spaces where reasoning can be done through matrix computation [Bordes et al., 2011; Serafini and d'Avila Garcez, 2016; Santoro et al., 2017]. Training embedding systems can be carried out as distance learning using backpropagation. Most research in this direction focuses on representing relational predicates in a neural network. This is known as "relational embedding" [Sutskever and Hinton, 2008]. For representation of more complex logical structures, i.e. FOL formulas, a system named Logic Tensor Network (LTN) [Serafini and d'Avila Garcez, 2016] is proposed by extending Neural Tensor Networks (NTN), a state-of-the-art relational embedding method. LTNs effectively implement learning using symbolic information as a prior, as pointed out by [van Harmelen and ten Teije, 2019]. Related ideas are discussed formally in the context of constraint-based learning and reasoning [d'Avila Garcez et al., 2019]. Recent research in first-order logic programs has successfully exploited advantages of distributed representations of logic symbols for efficient reasoning, inductive programming [Evans and Grefenstette, 2018] and differentiable theorem proving [Rockt¨aschel and Riedel, 2016].

2 It is advisable to read [Lample and Charton, 2020] alongside this critique of its limitations [Davis, 2019]

3.2 Pointer Networks

The Pointer Network (PN) formalization [Vinyals et al., 2015] is a neural architecture meant for computing a m-sized sequence (i1, i2, . . . in) ∈ [1, n]m over the elements of an input set X = {x1, . . . , xn}. PN implements a simple modification over the traditional seq2seq model, augmenting it with a simplified variant of the attention mechanism whose outputs are interpreted as "pointers" to the input elements. Traditional seq2seq models implement an encoder-decoder architecture in which the elements of the input sequence are consumed in order and used to update the encoder's hidden state at each step. Finally, a decoder consumes the encoder's hidden state and is used to yield a sequence of outputs, one at a time.

It is known that seq2seq models tend to exhibit improved performance when augmented with an attention mechanism, a phenomenon noticeable from the perspective of Natural Language Processing [Devlin et al., 2019]. Traditional models however yield sequences of outputs over a fixed-length dictionary (for instance a dictionary of tokens for language models), which is not useful for tasks whose output is defined over the input set and hence require a variable-length dictionary. PN tackle this problem by encoding the n-sized input set P with a traditional encoding architecture and decoding a probability distribution p(Ci|C1, . . .Ci-1,P) over the set {1, . . . , n} of indices at each step i by computing a softmax over an attention layer parameterized by matrices W1,W2 and vector v feeding on the decoder state di and the encoder states ei (1, . . . , n):

The output pointers can then be used to compute loss functions over combinatorial optimization problems. In the original paper the authors define a PN to solve the Traveling Salesperson Problem (TSP) in which a beam search procedure is used to select cities given the probability distributions computed at each step and finally a loss function can computed for the output tour by adding the corresponding city distances. Given their discrete nature, PNs are naturally suitable for many combinatorial problems (the original paper evaluates PN on Delauney Triangulation, TSP and Convex Hull problems). Unfortunately, even though PNs can solve problems over sets, they cannot be directly applied to general (noncomplete) graphs.

3.3 Convolutions as Self-Attention

The core building block of models in the GNN family is the graph convolution operation, which is a neural building block that enables one to perform learning over graph inputs. Empowering DL architectures with the capacity of feeding on graph-based data is particularly suitable for neural-symbolic reasoning, as symbolic expressions are easily represented as graphs (Fig. 2). Furthermore, graph representations have useful properties such as permutation invariance and flexibility for generalization over the input size (models in the graph neural network family can be fed with graphs regardless of their size in terms of number of vertices). Graph convolutions can be seen as a variation of the well-known attention mechanism [Garcia and Bruna, 2018]. A graph convolution is essentially an attention layer with two key differences:

1. There is no dot-product for computing weights: encodings are simply added together with unit weights. 3
2. The sum is masked with an adjacency mask, or in other words the graph convolution generalizes attention for non-complete graphs.

All models in the GNN family learn continuous representations for graphs by embedding nodes into hyper-dimensional spaces, an insight motivated by graph embedding algorithms. A graph embedding corresponds to a function f : V → Rn mapping from the set of vertices V of a graph G = (V, E) to n-dimensional vectors. In the context of GNNs, we are interested in learning the parameters θ of a function f : G × θ → (V → Rn ). That is, a parameterized function f(G, θ) over the set of graphs G whose outputs are mappings V → Rn from vertices to n-dimensional vectors. In other words, GNNs learn functions to encode vertices in a generalized way. Note that since the output from a GNN is itself a function, there are no limitations for the number of vertices in the input graph. This useful property stems from the modular architecture of GNNs, which will be discussed at length in the sequel. We argue that this should be interesting to explore in the context of neural-symbolic computing in the representation and manipulation of variables within neural networks.

Generally, instead of synthesizing a vertex embedding function from the ground up, GNNs choose an initial, simpler vertex embedding such as mapping each vertex to the same (learned) vector representation or sampling vectors from a multivariate normal distribution, and then learn to refine this representation by iteratively updating representations for all vertices. The refinement process, which consists of each vertex aggregating information from its direct neighbors to update its own embedding is at the core of how GNNs learn properties over graphs. Over many refinement steps, vertices can aggregate structural information about progressively larger reachable subsets of the input graph. However we rely on a well-suited transformation at each step to enable vertices to make use of this structural information to solve problems over graphs. The graph convolution layer, described next in Section 3.4, implements such transformation.

3.4 Graph Convolutional Networks

Graph convolutions are defined in analogy to convolutional layers over Euclidean data. Both architectures compute weighted sums over a neighborhood. For CNNs, this neighborhood is the well known 9-connected or 25-connected neighborhood defined over pixels. One can think of the set of pixels of an image as a graph with a grid topology in which each vertex is associated with a vector representation corresponding to the Red/Green/Blue channels. The internal activations of a CNN can also be thought of graphs with grid topologies, but the vector representations for each pixel are generally embedded in spaces of higher dimensionality (corresponding to the number of convolutional kernels learned at each layer). In this context, Graph Convolutional Networks (GCNs) [Kipf and Welling, 2017] can be thought of as a generalization of CNNs for non-grid topologies. Generalizing CNNs this way is tricky because one cannot rely anymore on learning 3 × 3 or 5 × 5 kernels, for two reasons:

3 The Graph Attention network (GAT) however generalizes graph convolutions with dot-product attention [Veliˇckovi´c et al., 2018]

1. In grid topologies pixels are embedded in 2-dimensional Euclidean space, which enables one to learn a specific weight for each neighbor on the basis of its relative position (left, right, central, top-right, etc.). This is not true for general graphs, and hence weights such as W1,0,W1,1,W1,1,W0,1 do not always have a clear interpretation.
2. In grid topologies each vertex has a fixed number of neighbors and weight sharing, but there is no such constraint for general graphs. Thus we cannot hope to learn a specific weight for each neighbor as the required number of such weights will vary with the input graph.

GCNs tackle this problem the following way: Instead of learning kernels corresponding to matrices of weights, they learn transformations for vector representations (embeddings) of graph vertices. Concretely, given a graph G = (V, E) and a matrix x(k) ∈ R|V|×d of vertex representations (i.e. ⃗ xi (k) is the vector representation of vertex i at the k-th layer), a GCN computes the representations ⃗ xi (k+1) of vertex i in the next layer as:

In other words, we linearly transform the vector representation of each neighbor j by multiplying it with a learned matrix of weights θk, normalizing it by the square roots of the degrees deg i, deg j of both vertices, aggregate all results additively and finally apply a non-linearity σ. Note that θk denotes the learned weight matrix for GCN layer k: in general one will stack n different GCN layers together and hence learn the parameters of n such matrices. Also note that one iterates over an extended neighborhood N(i) ∪ {i}, which includes i itself. This is done to prevent "forgetting" the representation of the vertex being updated. Equation 2 can be summarized as: x(k+1) = ( ˜D- 1 2 ˜A˜D- 12 )x(k) θ(k) , where ˜A = A + I is the adjacency matrix A plus self-loops (I is the identity matrix) and ˜D is the degree matrix of ˜A.

3.5 The Graph Neural NetworkModel

Although GCNs are conceptually simpler, the GNN model predates them by a decade, having been originally proposed by [Scarselli et al., 2008]. The model is similar to GCNs, with two key differences:

1. One does not stack multiple independent layers as in GCNs. A single parameterized function is iterated many times, in analogy to recurrent networks, until convergence.

(2) The transformations applied to neighbor vertex representations are not necessarily linear, and can be implemented by deep neural networks (e.g. by a multilayer perceptron).

Concretely, the graph neural network model defines parameterized functions h : N × N × N × Rd → Rd and g : N × Rd → Ro , named the transition function and the output function. In analogy to a graph convolution layer, the transition function defines a rule for updating vertex representations by aggregating transformations over representations of neighbor vertices. The vertex representation ⃗ xi (t+1) for vertex i at time (t + 1) is computed as:

Where li, lj and lij are respectively the labels for nodes i and j and edge ij and Rd , Ro are respectively the space of vertex representations and the output space. The model is defined over labelled graphs, but can still be implemented for unlabelled ones by supressing li, lj, lij from the transition function. After a certain number of iterations one should expect that vertex embeddings ⃗ xi (t+1) are enriched with structural information about the input graph. At this point, the output function g can be used to compute an output for each vertex, given its final representation: ⃗ oi = g(li, ⃗ xi)

In other words, the output at the end of the process is a set of |V| vectors ∈ Ro . This is useful for node classification tasks, in which one can have o equal the number of node classes and enforce ⃗ oi to encode a probability distribution by incorporating a softmax layer into the output function g. If one would like to learn a function over the entire graph instead of its neighbors, there are many possibilities, of which one is to compute the output on an aggregation over all final vertex representations: ⃗o = g (∑i∈V ⃗ xvg )

3.6 Message-passing Neural Networks

Message-passing neural networks implement a slight modification over the original GNN model, which is to define a specialized update function u : Rd × Rd → Rd to update the representation for vertex i given its current representation and an aggregation mi over transformations of neighbor vertex embeddings (which are referred to as "messages", hence message-passing neural networks), as an example:

Also, the update procedure is run over a fixed number of steps and it is usual to implement u if using some type of recurrent neural network (RNN), such as Long-Short Term Memory (LSTM) cells [Hochreiter and Schmidhuber, 1997; Selsam et al., 2019], or Gated Recurrent Units.

3.7 Graph Attention Networks

The Graph Attention Networks (GAT) [Veliˇckovi´c et al., 2018] augment models in the graph neural network family with an attention mechanism enabling vertices to weigh neighbor representations during their aggregation. As with other types of attention, a parameterized function is used to compute the weights dynamically, which enables the model to learn to weigh representations wisely. The goal of the GAT is to compute a coefficient eij : R for each neighbor j of a given vertex i, so that the aggregation in Equation 3 becomes:

To compute eij, the GAT introduces a weight matrix W ∈ Rd × Rd , used to multiply vertex embeddings for i and j, which are concatenated and multiplied by a parameterized weight vector ⃗a. Finally, a non-linearity is applied to the computation in the above equation and then a softmax over the set of neighbors N(i) is applied over the exponential of the result, yielding: eij = softmaxj(σ(⃗a · (W⃗ xi ||W ⃗ xj))) GAT are known to outperform typical GCN architectures for graph classification tasks, as shown in the original paper [Veliˇckovi´c et al., 2018].

4 Perspectives and Applications of GNNs to Neural-Symbolic Computing

In this paper, we have seen that GNNs endowed with attention mechanisms are a promising direction of research towards the provision of rich reasoning and learning in type 6 neuralsymbolic systems. Future work includes, of course, application and systematic evaluation of relevant specific tasks and data sets. These include what John McCarthy described as drosophila tasks for Computer Science: basic problems that can illustrate the value of a computational model.

Examples in the case of GNNs and NSC could be: (1) extrapolation of a learned classification of graphs as Hamiltonian to graphs of arbitrary size, (2) reasoning about a learned graph structure to generalise beyond the distribution of the training data, (3) reasoning about the partOf(X, Y ) relation to make sense of handwritten MNIST digits and non-digits. (4) using an adequate self-attention mechanism to make combinatorial reasoning computationally efficient. This last task relates to satisfiability including work on using GNNs to solve the TSP problem. The other tasks are related to metatransfer learning across domains, extrapolation and causality. In terms of domains of application, the following are relevant.

4.1 Relational Learning and Reasoning

GNN models have been successfully applied to a number of relational reasoning tasks. Despite the success of convolutional networks, visual scene understanding is still out of reach for pure CNN models, and hence are a fertile ground for GNN-based models. Hybrid CNN + GNN models in particular have been successful in these tasks, having been applied to understanding human-object interactions, localising objects, and challenging visual question answering problems [Santoro et al., 2017]. Relational reasoning has also been applied to physics, with models for extracting objects and relations in unsupervised fashion [van Steenkiste et al., 2018]. GNNs coupled with differentiable ODE solvers have been used to learn the Hamiltonian dynamics of physical systems given their interactions modelled as a dynamic graph [Greydanus et al., 2019]. The application of NSC models to life sciences is very promising, as graphs are natural representations for molecules, including proteins. In this context, [Stokes et al., 2020] have generated the first machine-learning discovered antibiotic ("halcin") by training a GNN to predict the probability that a given input molecule has a growth inhibition effect on the bacterium E. coli and using it to rank randomlygenerated molecules. Protein Structure Prediction, which is concerned with predicting the three-dimensional structure of proteins given its molecular description, is another promising problem for graph-based and NSC models such as DeepMind's AlphaFold and its variations [Wei, 2019].

In Natural language processing, tasks are usually defined over sequential data, but modelling textual data with graphs offers a number of advantages. Several approaches have defined graph neural networks over graphs of text cooccurrences, showing that these architectures improve upon the state-of-the-art for seq2seq models [Yao et al., 2019]. GNN models have also been successfully applied to relational tasks over knowledge bases, such as link prediction [Schlichtkrull et al., 2018]. As previously mentioned, attention mechanisms, which can be seen as a variation of models in the GNN family, have enabled substantial improvements in several NLP tasks through transfer learning over pretrained transformer language models [Devlin et al., 2019]. The extent to which language models pretrained over huge amounts of data can perform language understanding however is substantially debated, as pointed out by both Marcus [Marcus, 2020] and Kahneman [Kahneman et al., 2020].

Graph-based neural network models have also found a fertile field of application in software engineering: due to the structured and unambiguous nature of code, it can be represented naturally with graphs that are derived unambiguously via parsing. Several works have then utilised GNNs to perform analysis over graph representations of programs and obtained significant results. More specifically, Microsoft's "Deep Program Understanding" research program has used a GNN variant called Gated Graph Sequence Neural Networks [Li et al., 2016] in a large number of applications, including spotting errors, suggesting variable names, code completion [Brockschmidt et al., 2019], as well as edit representation and automatically applying edits to programs [Yin et al., 2019].

4.2 Combinatorial Optimization and Constraint Satisfaction Problems

Many combinatorial optimization problems are relational in structure and thus are prime application targets to GNN-based models [Bengio et al., 2018]. For instance, [Khalil et al., 2017] uses a GNN-like model to embed graphs and use these embeddings in their heuristic search for the Minimum Vertex Cover (MVC), Maximum Cut and Traveling Salesperson (TSP) problems. Regarding end-to-end models, [Kool et al., 2019] trained a transformer-based GNN model to embed TSP answers and extract solutions with an attentionbased decoder, while obtaining better performance than previous work. [Li et al., 2018] used a GCN as a heuristic to a search algorithm, applying this method on four canonical NP-complete problems, namely Maximal Independent Set, MVC, Maximal Clique, and the Boolean Satisfiability Problem (SAT). [Palm et al., 2018] achieved convergent algorithms over relational problems. The expressiveness of GNNs has also been the focus of recent research [Sato, 2020].

Regarding NP-Hard problems, neural-symbolic models with an underlying GNN formalization have been proposed to train solvers for the decision variants of the SAT, TSP and graph colouring problems, respectively [Selsam et al., 2019; Prates et al., 2019; Lemos et al., 2019]. This allowed these models to be trained with a single bit of supervision on each instance, [Selsam et al., 2019; Cameron et al., 2020] being able to extract assignments from the trained model, [Prates et al., 2019] performing a binary search on the prediction probability to estimate the optimal route cost. [Toenshoff et al., 2019] built an end-to-end framework for dealing with (boolean) constraint satisfaction problems in general, extending the previous works and providing comparisons and performance increases, and [Abboud et al., 2020] have proposed a GNN-based architecture that learns to approximate DNF counting. There has also been work in generative models for combinatorial optimization, such as [You et al., 2019], which generates SAT instances using a graph-based approach.

5 Conclusions

We presented a review on the relationship between Graph Neural Network (GNN) models and architectures and NeuralSymbolic Computing (NSC). In order to do so, we presented the main recent research results that highlight the potential applications of these related fields both in foundational and applied AI and Computer Science problems. The interplay between the two fields is beneficial to several areas. These range from combinatorial optimization/constraint satisfaction to relational reasoning, which has been the subject of increasing industrial relevance in natural language processing, life sciences and computer vision and image understanding [Raghavan, 2019; Marcus, 2020]. This is largely due to the fact that many learning tasks can be easily and naturally captured using graph representations, which can be seen as a generalization over the traditional sequential (RNN) and gridbased representations (CNN) in the family of deep learning building blocks. Finally, it is worth mentioning that the principled integration of both methodologies (GNNs and NSC) offers a richer alternative to the construction of trustful, explainable and robust AI systems, which is clearly an invaluable research endeavor.

Acknowledgements

This work is partly supported by CNPq and CAPES, Brazil - Finance Code 001.