Recent machine reading comprehension datasets such as ReClor and LogiQA require performing logical reasoning over text. Conventional neural models are insufficient for logical reasoning, while symbolic reasoners cannot directly apply to text. To meet the challenge, we present a neural-symbolic approach which, to predict an answer, passes messages over a graph representing logical relations between text units. It incorporates an adaptive logic graph network (AdaLoGN) which adaptively infers logical relations to extend the graph and, essentially, realizes mutual and iterative reinforcement between neural and symbolic reasoning. We also implement a novel subgraph-to-node message passing mechanism to enhance context-option interaction for answering multiple-choice questions. Our approach shows promising results on ReClor and LogiQA. Machine reading comprehension (MRC) has drawn much research attention. Early MRC datasets are not difficult for state-of-the-art neural methods. Indeed, BERT (Devlin et al., 2019) has outperformed humans on SQuAD (Rajpurkar et al., 2016). Recent datasets become more challenging. For example, ReClor (Yu et al., 2020) and LogiQA (Liu et al., 2020) require understanding and reasoning over logical relations described in text, where neural methods showed unsatisfactory performance. For instance, consider the MRC task in Figure 1. The context consists of a set of textual propositions describing logical relations between elementary discourse units (EDUs) (Mann and Thompson, 1988). For example, the first sentence describes an implication between two EDUs: the company gets project A implies that product B can be put on the market on schedule. With the help of propositional calculus, humans can formalize propositions and then apply inference rules in proposi-Context: If the company gets project A, product B can be put on the market on schedule. Product B is put on schedule if and only if the company's fund can be normally turned over. If the company's fund cannot be turned over normally, the development of product C cannot be carried out as scheduled. The fact is that the development of product C is carried out as scheduled. Question: This shows: Options:A. The company gets project A and product B is put on the market on schedule. B. The company does not get project A and product B is not put on the market on schedule. C. Product B is put on the market on schedule and the company's fund is turned over normally. D. Product B is not put on the market on schedule, and the company's fund turnover is extremely abnormal. Figure 1: An example MRC task (adapted from a task in LogiQA). Existing Methods and Limitations To solve it, conventional neural models are insufficient for providing the required reasoning capabilities, while symbolic reasoners cannot directly apply to unstructured text. One promising direction is to consider a neural-symbolic solution, such as the recent DAGN method (Huang et al., 2021a). It breaks down the context and each option into a set of EDUs and connects them with discourse relations as a graph. Then it performs graph neural network (GNN) based reasoning to predict an answer. However, we identify two limitations in this method. L1: Despite the graph representation, it is predominantly a neural method over discourse relations. It is debatable whether the required symbolic reasoning over logical relations (e.g., implication, negation) can be properly approximated. L2: The graph is often loosely connected and composed of long paths. Node-to-node message passing implemented in existing GNN models (Kipf and Welling, 2017; Schlichtkrull et al., 2018; Velickovic et al., 2018) is prone to provide insufficient interaction be-7147 (b) Extended TLG. Dashed nodes and edges represent adaptively inferred EDUs and logical relations, respectively. Double edges represent subgraph-to-node message passing. Our Approach. While we follow the general framework of DAGN, i.e., graph construction and then graph-based reasoning, we overcome its two limitations with a novel neural-symbolic approach. To address L1, Figure 3 sketches out our idea. Specifically, we propose to construct a text logic graph (TLG) representing EDUs and their logical relations as opposed to discourse relations, so we can explicitly perform symbolic reasoning to extend the TLG with inferred logical relations, as illustrated in Figure 2. The inferred relations may provide crucial connections to be used in the subsequent graph-based message passing, i.e., symbolic reasoning reinforces neural reasoning . Further, while trivially computing and admitting the deductive closure may extend the TLG with irrelevant connections which would mislead message passing, we leverage signals from neural reasoning to adaptively admit relevant extensions, i.e., neural reasoning reinforces symbolic reasoning . Moreover, we iterate the above mutual reinforcement by restarting inference in each iteration with signals from the previous iteration to accommodate corrections to the reasoning process and allow sufficient neural-symbolic interaction. To address L2, we aggregate the information in the context subgraph of TLG and employ a novel subgraph-to-node message passing mechanism to enhance the interaction from the holistic context Figure 3: Our main idea: mutual and iterative reinforcement between symbolic and neural reasoning. subgraph to each node in the option subgraph, and vice versa , as illustrated in Figure 2b. We incorporate the above two ideas into our new Adaptive Logic Graph Network (AdaLoGN). To summarize, our technical contributions include  a novel neural-symbolic approach where neural and symbolic reasoning mutually and iteratively reinforce each other, and  a novel aggregation-based enhancement of message passing in graph-based neural reasoning. Outline. We elaborate our approach in Section 2, present experiments in Section 3, discuss related work in Section 4, and conclude in Section 5. Our code is available on GitHub: https:// github.com/nju-websoft/AdaLoGN . A MRC task (cid:104) c, q, O (cid:105) consists of a context c , a question q , and a set of options O . Only one option in O is the correct answer to q given c . The goal of the task is to find this option. Figure 4 outlines our implementation. For each option o  O , we generate the representations of c, q, o (i.e., g c , g q , g o , respectively) by a pre-trained language model (Section 2.1), and we construct a raw TLG where nodes (i.e., u 1 , . . . , u | V | ) represent EDUs extracted from c, q, o and edges represent their logical relations (Section 2.2). With their initial representations (i.e., h (0) u 1 , . . . , h (0) u | V | ) obtained from the pre-trained language model, in an iterative manner, we adaptively extend the TLG (i.e., symbolic reasoning) and then pass messages (i.e., neural reasoning) to update node representations (i.e., h ( l +1) u 1 , . . . , h ( l +1) u | V | ) for generating the representation of the TLG (i.e., h G ) (Section 2.3). Finally, we predict the correctness of o (i.e., score o ) based on the above representations (Section 2.4). We use RoBERTa (Liu et al., 2019), a pre-trained language model, to encode three token sequences c = c 1    c | c | , q = q 1    q | q | , and o = o 1    o | o | which are concatenated by the classifier token < s > and the separator token < /s > : [ g < s > ; g c 1 ; . . . ; g < /s > ; g q 1 ; . . . ; g o 1 ; . . . ; g < /s > ] = RoBERTa ( < s > c 1    < /s > q 1    o 1    < /s > ) . (1) The output vector representations are averaged to form the representations of c, q, o : g c = 1 | c | | c | (cid:80) i =1 g c i , g q = 1 | q | | q | (cid:80) i =1 g q i , g o = 1 | o | | o | (cid:80) i =1 g o i . For a piece of text, its TLG is a directed graph G = (cid:104) V, E (cid:105) where V is a set of nodes representing EDUs of the text (Mann and Thompson, 1988), and E  V  R  V is a set of labeled directed edges representing logical relations between EDUs described in the text. We consider six types of common logical relations R = { conj , disj , impl , neg , rev , unk } :  conjunction ( conj ), disjunction ( disj ), implication ( impl ), and negation ( neg ) are standard logical connectives in propositional logic; Rhetorical Relation Logical Relation LIST, CONTRAST conj DISJUNCTION disj RESULT impl CAUSE, PURPOSE, CONDITION, BACKGROUND rev Table 1: Mapping from rhetorical relations in Graphene to logical relations in TLG. represent the inverse relation of impl ;  unk represents an unknown relation. relations, edges labeled with them are bidirectional. Observe the difference between our TLG and the discourse-based logic graph considered in DAGN (Huang et al., 2021a): edges in the former represent logical relations, while those in the latter represent discourse relations. Therefore, we can explicitly perform symbolic reasoning on TLG. We initialize a raw TLG from c and o . Following Huang et al. (2021a), we ignore q as it is usually uninformative in existing datasets. Specifically, we use Graphene (Cetto et al., 2018) to extract EDUs and their rhetorical relations (Mann and Thompson, 1988) from c and o . Rhetorical relations are converted to logical relations via the mapping in Table 1. Note that each impl edge is always paired with an inverse rev edge, and vice versa. We also define a small number of syntactic rules to identify EDUs that negate each other and connect them with neg . The rules are based on part-of-speech tags and dependencies. For example, one such rule checks whether two EDUs differ from each other only by an antonym of an adverb. In addition, for each pair of EDUs that are adjacent in the text (including the last EDU of c and the first EDU of o ) but have none of the above logical relations, we connect them with unk because Graphene may fail to identify their relation. Since TLG consists of logical relations, we explicitly perform symbolic reasoning by applying inference rules to extend the TLG with inferred logical relations to benefit the subsequent neural reasoning. However, rather than computing the deductive closure which may undesirably provide many relations that are irrelevant to answering the question 7149 and mislead neural reasoning, we perform adaptive extension by leveraging signals from neural reasoning to identify and admit relevant extensions. For neural reasoning, we perform message passing to update node representations, which finally are pooled into the representation of the TLG to be used in the subsequent answer prediction. We iterate the above process by restarting inference on the raw TLG in each iteration with signals from the previous iteration to accommodate corrections to the reasoning process and let symbolic and neural reasoning sufficiently interact with each other. We transform the above idea into a new model named AdaLoGN outlined in Figure 4 and detailed below. Let G = (cid:104) V, E (cid:105) be a raw TLG. For symbolic reasoning over the logical relations in G , we apply two inference rules about implication in propositional logic . Other rules are left for future work. Hypothetical Syllogism: (( u i  u j )  ( u j  u k )) (cid:96) ( u i  u k ) . Specifically, if E contains two edges (cid:104) u i , impl , u j (cid:105) and (cid:104) u j , impl , u k (cid:105) , we can add two edges (cid:104) u i , impl , u k (cid:105) and (cid:104) u k , rev , u i (cid:105) to E , as illustrated in Figure 5a. Transposition: ( u i  u j ) (cid:96) (  u j   u i ) . Specifically, if E contains an edge (cid:104) u i , impl , u j (cid:105) , we can add two edges (cid:104) u j , impl ,  u i (cid:105) and (cid:104) u i , rev ,  u j (cid:105) to E , as illustrated in Figure 5b. Note that if u i (resp. u j ) is not incident from/to any neg edge, i.e.,  u i (resp.  u j ) is not a node in V , we will add  u i (resp.  u j ) to V whose text negates that of u i (resp. u j ), and then add a bidirectional neg edge between u i and  u i (resp. u j and  u j ) to E . Besides, recall that unk represents a potential logical relation between EDUs that are adjacent in text. Considering that an EDU often inherits logical relations from its adjacent EDUs, we heuristically define and apply the following inference rule. Adjacency-Transmission: (( u i (cid:63) u j )  ( u i  u k )) (cid:96) ( u k (cid:63) u j ) , (5) where (cid:63)  { ,  , } and  represents adjacency in text. For example, if E contains two edges (cid:104) u i , conj , u j (cid:105) and (cid:104) u i , unk , u k (cid:105) , we can add a bidirectional conj edge between u k and u j to E , as illustrated in Figure 5c. While this rule may generate false propositions, we expect our adaptive reasoner to apply it properly. For example, it is useful for handling the following sentence: ... only 1 person in the group knew 3 of the group ( u k ), 3 people knew 2 of the group ( u i ), and 4 people know 1 of the group ( u j ). Graphene identifies (cid:104) u i , conj , u j (cid:105) and (cid:104) u i , unk , u k (cid:105) but misses (cid:104) u k , conj , u j (cid:105) , which can be generated by applying this rule. Our symbolic reasoning is adaptive . We rely on signals from neural reasoning to decide which inference steps are relevant to answering the questions and hence are admitted to extend the TLG. Specifically, each candidate extension (cid:15) applies an inference rule over a set of nodes V (cid:15)  V . We average their vector representations (which will be detailed later) to form the representation of (cid:15) : h (cid:15) = 1 | V (cid:15) | (cid:88) u i  V (cid:15) h u i . Since (cid:15) is for predicting the correctness of o , we interact h (cid:15) with the representation of o , i.e., g o in Equation (2), to predict the relevance score of (cid:15) : where (cid:107) represents vector concatenation. We admit all possible (cid:15) to extend G such that rel (cid:15) >  where  is a predefined threshold. Moreover, our neural-symbolic reasoning is iterative . In the ( l +1) -th iteration, we restart symbolic reasoning with the raw TLG and recompute Equation (6) with node representations h ( l ) u i from neural reasoning in the l -th iteration (which will be detailed in Section 2.3.3). The initial node representations h (0) u i are obtained from a pre-trained language 7150 model. Specifically, we flatten V into a sequence of nodes in the order they appear in the text. Recall that V is divided into V c = { u 1 , . . . , u | V c | } and V o = { u | V c | +1 , . . . , u | V | } representing the nodes extracted from c and o , respectively. Each node u i is a token sequence u i = u i 1    u i | ui | . We use RoBERTa to encode V c and V o which are concatenated by < s > and < /s > , where nodes inside V c and V o are separated by a special token  | : [ h < s > ; h u 11 ; ... ; h | ; ... ; h < /s > ; h u | Vc | +11 ; ... ; h | ; ... ; h < /s > ] = RoBERTa ( < s > u 1 1  |  < /s > u | V c | +1 1  |  < /s > ) . (8) The output vector representations are averaged to form the initial representation of each node u i  V : h (0) u i = 1 | u i | | u i | (cid:88) j =1 h u ij . To let the nodes in TLG interact with each other and fuse their information, our neural reasoning performs graph-based message passing (Gilmer et al., 2017) to update node representations in each iteration from h ( l ) u i to h ( l +1) u i . Since TLG is a heterogeneous graph containing multiple types of edges, we incorporate the node-to-node message passing mechanism in R-GCN (Schlichtkrull et al., 2018) as a basis. Further, observe that TLG is usually loosely connected and prone to cause insufficient interaction between V c and V o via long paths in limited iterations, which cannot be alleviated by simply increasing the number of iterations because it would raise other issues such as over-smoothing (Li et al., 2018; Chen et al., 2020). To enhance such interaction which is critical to predicting the correctness of o , we incorporate a novel subgraph-to-node message passing mechanism to holistically pass the information aggregated from a subgraph (e.g., V c ) to a node (e.g., each u i  V o ). Specifically, without loss of generality, for each u i  V o , we compute the u i -attended aggregate representation of V c by an attention-weighted sum of node representations over V c : h ( l ) V c ,u i = (cid:88) u j  V c  i,j h ( l ) u j , where  i,j = softmax j ([ a i, 1 ; . . . ; a i, | V c | ] (cid:124) ) , a i,j = LeakyReLU ( linear ( h ( l ) u i (cid:107) h ( l ) u j )) . (10) Let N i be the set of neighbors of u i . Let N ir  N i be the subset under logical relation r  R . We update the representation of u i by passing messages to u i from its neighbors and from V c : h ( l +1) u i = ReLU ( (cid:88) r  R (cid:88) u j  N ir  i,j | N ir | W ( l ) r h ( l ) u j + W ( l ) 0 h ( l ) u i +  i W ( l ) subgraph h ( l ) V c ,u i ) , where  i,j = softmax idx ( a i,j ) ([ . . . ; a i,j ; . . . ] (cid:124) ) for all u j  N i , a i,j = LeakyReLU ( linear ( h ( l ) u i (cid:107) h ( l ) u j )) ,  i = sigmoid ( linear ( h ( l ) u i (cid:107) h ( l ) V c ,u i )) , (11) W ( l ) r , W ( l ) 0 , W ( l ) subgraph are matrices of learnable parameters, and idx ( a i,j ) returns the index of a i,j in the | N i | -dimensional vector [ . . . ; a i,j ; . . . ] (cid:124) . In an analogous way, for each u i  V c , we compute the u i -attended aggregate representation of V o denoted by h ( l ) V o ,u i and update h ( l +1) u i . Observe two differences between Equation (11) and its counterpart in the original R-GCN. First, we incorporate subgraph-to-node message passing and control it by a gating mechanism (i.e.,  i ). Second, we weight node-to-node message passing by an attention mechanism (i.e.,  i,j ). After L iterations where L is a hyperparameter, for each node u i  V , we fuse its representations over all the iterations with a residual connection: h fus u i = h (0) u i + linear ( h (1) u i (cid:107)    (cid:107) h ( L ) u i ) . (12) Inspired by Huang et al. (2021a), we feed all h fus u i into a bidirectional residual GRU layer (Cho et al., 2014) to finalize node representations: [ h fnl u 1 ; . . . ; h fnl u | V | ] = Res BiGRU ([ h fus u 1 ; . . . ; h fus u | V | ]) . We aggregate these node representations by computing an o -attended weighted sum: h V = (cid:88) u i  V  i h fnl u i , where  i = softmax i ([ a 1 ; . . . ; a | V | ] (cid:124) ) , a i = LeakyReLU ( linear ( g o (cid:107) h fnl u i )) , (14) and g o is the representation of o in Equation (2). We concatenate h V and the relevance scores to form the representation of G : h G = ( h V (cid:107) rel E (1) (cid:107)    (cid:107) rel E ( L ) ) , where rel E ( l ) = 1 |E ( l ) | (cid:88) (cid:15) E ( l ) rel (cid:15) , (15) 7151 E ( l ) is the set of candidate extensions in the l -th iteration, and rel (cid:15) is in Equation (7). In this way, we are able to train the network in Equation (7). We fuse the representations of c, q, o and the TLG to predict the correctness of o : score o = linear (tanh( linear ( g c (cid:107) g q (cid:107) g o (cid:107) h G ))) (16) where g c , g q , g o are in Equation (2). Let o gold  O be the correct answer. We optimize the cross-entropy loss with label smoothing: L =  (1   ) score (cid:48) o gold   1 | O | (cid:88) o i  O score (cid:48) o i , where score (cid:48) o i = log exp( score o i ) (cid:80) o j  O exp( score o j ) , (17) and  is a predefined smoothing factor. ReClor (Yu et al., 2020) consists of 6,138 four-option multiple-choice questions collected from standardized exams such as GMAT and LSAT. The questions were divided into 4,638 for training, 500 for development, and 1,000 for testing. The test set was further divided into 440 easy questions (Test-E) where each question could be correctly answered by some strong baseline method using only the options and ignoring the context and the question, and the rest 560 hard questions (Test-H). LogiQA (Liu et al., 2020) consists of 8,768 four-option multiple-choice questions collected from the National Civil Servants Examination of China, which were translated into English. The questions were divided into 7,376 for training, 651 for development, and 651 for testing. We experimented on NVIDIA V100 (32GB). We tuned hyperparameters on the development set of each dataset. Specifically, for text encoding, we used RoBERTa-large with hidden layer = 24 and hidden units = 1 , 024 implemented by Hugging Face (Wolf et al., 2020). For message passing, our implementation was based on DGL (Wang et al., 2019). For both datasets, we used the Adam optimizer, and set attention heads = 16 , dropout rate = 0 . 1 , epochs = 10 , batch size = 16 selected from { 8 , 16 , 24 } , number of iterations L = 2 from { 2 , 3 } , and maximum sequence length = 384 . For ReClor, we set warm-up proportion = 0 . 1 from { 0 . 1 , 0 . 2 } , learning rate = 7 e  6 from { 6 e  6 , 7 e  6 , 8 e  6 , 1 e  5 } , and seed = 123 from { 123 , 1234 , 42 , 43 } . For LogiQA, we set warm-up proportion = 0 . 2 from { 0 . 1 , 0 . 2 } , learning rate = 8 e  6 from { 6 e  6 , 7 e  6 , 8 e  6 , 1 e  5 } , and seed = 42 from { 123 , 1234 , 42 , 43 } . For the relevance score threshold  below Equation (7), we set  = 0 . 6 from { 0 . 4 , 0 . 5 , 0 . 6 , 0 . 7 } for both datasets. For the smoothing factor  in Equation (17), we set  = 0 . 25 for both datasets. To fit in our GPU's memory, we restricted a raw TLG to contain at most 25 nodes and 50 edges by, if needed, randomly merging nodes connected by an unk edge and/or deleting non-bridge edges while keeping the graph connected. We compared our approach, referred to as AdaLoGN, with popular pre-trained language models and with other known methods in the literature. Reasoning-based MRC, like other MRC tasks, can be solved by using a pre-trained language model with a classification layer. Yu et al. (2020) reported the results of BERTLARGE , RoBERTa LARGE , and XLNet LARGE on ReClor. Huang et al. (2021a) reported the results of BERTLARGE and RoBERTa LARGE on LogiQA. In the literature, we found the results of DAGN (Huang et al., 2021a), Focal Reasoner (Ouyang et al., 2021), and LReasoner (Wang et al., 2021a,b) on both datasets. For a fair comparison with our approach, we presented their results on RoBERTa LARGE , while LReasoner achieved better results with ALBERT. Between the two variants of LReasoner, one without data augmentation (w/o DA) and the other with data augmentation (w/ DA), we presented both of their results but mainly compared with the former because our approach and other baseline methods would also benefit if data augmentation were incorporated. Following the literature, we reported accuracy, i.e., the proportion of correctly answered questions. For our approach we reported the max across 3 runs on the development set of each dataset. On ReClor, as shown in Table 2, AdaLoGN outperformed all the baseline methods on the test set by at least 1.30%, except for LReasoner (w/ DA) which performed data augmentation so that the comparison might be unfair. AdaLoGN and LReasoner (w/ DA) both exceeded 60%, being comparable with human-level performance (63%). On LogiQA, as shown in Table 3, AdaLoGN outperformed all the baseline methods on the test set, including LReasoner (w/ DA). Still, our result (40.71%) was not comparable with human-level performance (86%). In particular, on both ReClor and LogiQA, AdaLoGN exceeded DAGN on the test set by 1.39%1.90%, which demonstrated the effectiveness of our approach in addressing the limitations of DAGN mentioned in Section 1. 3.6 Ablation Study We conducted an ablation study to evaluate the effectiveness of the two main technical contributions in our approach: adaptive extension of TLG and subgraph-to-node message passing. We compared the standard version of AdaLoGN with two variants removing adaptive extension. AdaLoGN no-ext performs no extension. AdaLoGN full-ext performs full extension by computing and admitting the deductive closure. On ReClor, as shown in Table 4, both variants exhibited a fair decrease in accuracy on the test set by 0.70%1.40%. On LogiQA, as shown in Table 5, the decreases were larger, 1.69% on the test set, possibly because the questions in LogiQA were harder so that the effectiveness of our adaptive extension became more noticeable. Interestingly, on both datasets, AdaLoGN full-ext was not better than AdaLoGN no-ext on the test set, indicating that a naive injection of logical reasoning into neural reasoning might not have positive effects. We analyzed the distributions of relevance scores of candidate extensions, i.e., rel (cid:15) in Equation (7). As shown in Figure 6, they approximated a normal distribution on both datasets. By setting the threshold  = 0 . 6 , we admitted 19.57% and 4.86% of the extensions on ReClor and LogiQA, respectively. We also compared with a variant of AdaLoGN using a subset of inference rules. By ignoring the adjacency-transmission rule, AdaLoGN no-at showed a decrease in accuracy on the test sets by 0.77%0.80%, suggesting the usefulness of this rule despite its heuristic nature. We compared the standard version of AdaLoGN with two variants removing subgraph-to-node message passing or implementing it in a different way. AdaLoGN n2n only performs node-to-node message passing in a standard way. AdaLoGN n2n+ only performs node-to-node message passing but, as an alternative to our holistic subgraph-to-node message passing, it adds a bidirectional unk edge between each node in the context subgraph and each node in the option subgraph to enhance context-option interaction. On ReClor, as shown in Table 4, both variants exhibited a large decrease in accuracy on the test set by 1.60%2.60%. On LogiQA, as shown in Table 5, the decreases were also large, 1.69%1.85% on the test set. The results demonstrated the effectiveness of our subgraph-to-node message passing. Compared with AdaLoGN n2n , AdaLoGN n2n+ achieved better results on ReClor but worse results on LogiQA on the test set, indicating that a naive enhancement of context-option interaction could have negative effects. From the development set of each dataset, we randomly sampled fifty questions to which our approach outputted an incorrect answer. We analyzed the sources of these errors. Note that an error could Source of Error ReClor LogiQA Construction of raw TLG 38% 36% Adaptive extension of TLG 18% 22% Expressivity of symbolic reasoning 20% 18% Others (about neural reasoning) 46% 40% Table 6: Error analysis of AdaLoGN. As shown in Table 6, we mainly relied on Graphene to extract a raw TLG from text based on syntactic analysis, which accounted for about one third of the errors (36%38%). Our adaptive extension of TLG constituted about one fifth of the errors (18%22%), e.g., some excessive extensions produced irrelevant logical relations which might mislead message passing. One fifth of the errors (18%20%) were due to the limited expressivity of our symbolic reasoning, i.e., a subset of propositional logic, while some questions required quantifiers. Other errors might be related to neural reasoning such as message passing or answer prediction (40%46%). On both ReClor and LogiQA, our approach used about 0.8 second for answering a question. While simple MRC tasks have been well studied, complex MRC tasks requiring various reasoning capabilities are receiving increasing research attention. Among others, multi-hop MRC tasks in HotpotQA (Yang et al., 2018) and WikiHop (Welbl et al., 2018) require retrieving and reading multiple supporting passages to answer a question. They can be solved by constructing and reasoning over a graph connecting passages that overlap or co-occur with each other (Qiu et al., 2019; Tu et al., 2020), by implicitly supervising a retriever via word weighting (Huang et al., 2021b), or by iteratively applying dense retrieval (Xiong et al., 2021). MRC tasks in DROP (Dua et al., 2019) require discrete reasoning such as addition, counting, and sorting. Neural networks have been extended to incorporate modules that can perform such reasoning over numbers and dates mentioned in a given context (Gupta et al., 2020). For MRC tasks in CommonsenseQA (Tal-mor et al., 2019) which are targeted at commonsense knowledge and reasoning, recent methods fuse external commonsense knowledge with pre-7154 trained language models for reasoning (Yan et al., 2021; Xu et al., 2021). There are also studies on MRC tasks requiring spatial/geographical reasoning (Huang et al., 2019; Li et al., 2021) and tempo-ral/causal reasoning (Sun et al., 2018). Different from the above reasoning capabilities, the MRC tasks considered in this paper require logical reasoning , such as reasoning about sufficient and necessary conditions, categorization, conjunctions and disjunctions. Pre-trained language models alone struggled and were far behind human-level performance on such tasks in ReClor (Yu et al., 2020) and LogiQA (Liu et al., 2020) due to their weakness in logical reasoning. Among existing methods for solving such tasks, DAGN (Huang et al., 2021a) and Focal Reasoner (Ouyang et al., 2021) extract discourse or coreference relations from text and represent as a graph of text units. Then they employ GNN to pass messages and update representations for predicting an answer. Different from their neural nature, our approach symbolically performs logical reasoning as required by such tasks, by applying inference rules over extracted logical relations to extend the graph. This feature resembles LReasoner (Wang et al., 2021a,b) which extends the context with inferred logical relations to benefit the subsequent neural reasoning. However, different from LReasoner which computes the deductive closure and identifies relevant extensions by text overlapping with the options in an unsupervised manner, our approach predicts relevance based on signals from neural reasoning in a supervised manner , and our prediction evolves over iterations after sufficient interaction between symbolic and neural reasoning. All these features helped our approach achieve better performance in the experiments. Our approach represents a novel implementation of neural-symbolic reasoning (Raedt et al., 2020), and it differs from the following existing methods. One paradigm of neural-symbolic reasoning is logic-driven neural reasoning. For example, logical constraints can be compiled into a neural network by augmenting the loss function (Xu et al., 2018) or the network structure (Li and Srikumar, 2019). Logical connectives, quantifiers, and consistency checking can also be approximated by neural networks (Dong et al., 2019; Ren et al., 2020; Gu et al., 2019). While these methods incorporate logical reasoning into neural reasoning via emulation, our approach explicitly performs logical reasoning by applying inference rules over logical relations. Such exact inference is more accurate than emulation-based approximation. Another paradigm is neural-driven logical reasoning. For example, neural networks have been employed to predict the truth of an atom in answering first-order logic queries (Arakelyan et al., 2021), and to implement predicates in probabilistic logic programming (Manhaeve et al., 2021). These methods and our approach cope with different problems, thus using different techniques. Specifically, while these methods complement logical reasoning with extra facts generated by neural reasoning, our approach filters inferred logical relations based on signals from neural reasoning. Moreover, observe that the neural-symbolic interaction in the above methods are unidirectional, i.e., they leverage either symbolic or neural reasoning to reinforce the other. By contrast, we allow bidirectional neural-symbolic interaction where neural and symbolic reasoning mutually and iteratively reinforce each other for better performance. To meet the challenge of reasoning-based MRC, we presented a neural-symbolic approach where neural and symbolic reasoning mutually and iteratively reinforce each other via our new AdaLoGN model. We also enhanced graph-based neural reasoning with a novel subgraph-to-node message passing mechanism. Since these ideas are quite general, we believe they have great potential for a variety of applications beyond MRC, e.g., link prediction. Error analysis has revealed some shortcomings of our approach. Currently we rely on syntactic tools to extract a raw TLG from text. We will explore other extraction methods to achieve a higher quality. We also plan to apply more inference rules and incorporate quantifiers to improve the expressivity of our symbolic reasoning. This work was supported in part by the NSFC (62072224) and in part by the Beijing Academy of Artificial Intelligence (BAAI).
abstain abstain method abstain objective result abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain other abstain abstain abstain method method method method method abstain other abstain method abstain abstain method method method method method abstain method abstain abstain objective objective abstain method method method objective abstain method abstain abstain method abstain method method abstain method abstain method method abstain abstain method method abstain method method abstain abstain abstain abstain abstain abstain abstain abstain method abstain method method abstain method method abstain abstain abstain method method abstain method method method abstain abstain method method method method method abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain result result result abstain abstain abstain abstain abstain result abstain abstain abstain abstain abstain result abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain abstain other other other other other other other method other other other objective other method abstain abstain other other other method other other other method method other objective objective objective method result method objective result other