Learning Symbolic Rules for Reasoning in Quasi-Natural Language

Symbolic reasoning , rule-based symbol manipulation , is a hallmark of human intelligence . However , rule-based systems have had limited success competing with learning-based systems outside formalized domains such as automated theorem proving . We hypothesize that this is due to the manual construction of rules in past attempts . In this work , we ask how we can build a rule-based system that can reason with natural language input but without the manual construction of rules . We propose MetaQNL , a “ Quasi-Natural ” language that can express both formal logic and natural language sentences , and MetaInduce , a learning algorithm that induces MetaQNL rules from training data consisting of questions and answers , with or without intermediate reasoning steps . Our approach achieves state-of-theart accuracy on multiple reasoning benchmarks ; it learns compact models with much less data and produces not only answers but also checkable proofs . 1 INTRODUCTION . Symbolic reasoning—rule-based symbol manipulation—is a core component of human intelligence ( Mercier & Sperber , 2017 ) . It has been a core part of computer science research , and has achieved significant success in domains such as software verification ( Darvas et al. , 2005 ) and theorem proving ( Kovács & Voronkov , 2013 ; McCune , 1997 ) . However , such success has been restricted to domains amenable to rigid , precise formalization . It remains a challenge how to translate such success into “ informal ” domains such as reasoning with common sense knowledge and natural language input . Prior attempts to build rule-based systems , which rely on manually constructed rules , have achieved limited success and tended to produce brittle systems . Deep learning provides an attractive alternative that can easily sidestep the question of representation . A deep network can be trained to perform a reasoning task by directly predicting the answer without explicit symbol manipulation ( Clark et al. , 2020 ) . However , deep networks can require a large amount of training data and can suffer from poor generalization . More importantly , unlike symbolic systems , a deep network is a black box that is hard to interpret , inspect , and verify . Such lack of interpretability can be undesirable in certain applications , especially those critical to safety and security . In this work , we ask how to build a rule-based system that reasons symbolically but can work with natural language and handle domains difficult to formalize . Such a system would perform reasoning by explicit symbol manipulation based on known rules , therefore more interpretable and verifiable , but at the same time flexible enough to handle natural language input . At a glance , this may appear a large departure from the conventional wisdom that learning-based systems , particularly deep networks , are far superior to rule-based systems , as history has demonstrated repeatedly . However , we hypothesize that this conventional wisdom is incorrect because it assumes a false dichotomy between using learning and using rules ; rule-based systems underperformed not because they were rule-based , but because it is difficult to construct rules manually . Further , we hypothesize learning rules from data is key to building effective rule-based systems , but it may require a different kind of learning than gradient descent . The goal of this work is thus to develop a method that automatically learns symbolic rules from data to enable rules-based reasoning with natural language . This poses two main questions . First , what is the system of rules—the basic structures that define what symbols and manipulations allowed—such that it is compatible with not only formal logic but also natural language ? Second , what is the learning algorithm that induces a set of rules from training data ? In this work , we take initial steps toward answering both questions . We propose MetaQNL , a formal symbolic system we call a “ Quasi-Natural Language ” , which is compatible with not only rigorous logical inference but also natural language expressions . We also propose MetaInduce , a learning algorithm that induces MetaQNL rules from training data that consists of questions and answers , with or without intermediate reasoning steps . MetaQNL : a Symbolic System in Quasi-Natural Language . In MetaQNL , a sentence is a sequence of words and variables ( “ The elephant is [ X ] ” ) . They also include ordinary English sentences without variables . A rule consists of multiple sentences as its premises ( “ The elephant is [ X ] ” , “ If something is [ X ] then it [ Y ] ” ) and one sentence as its conclusion ( “ The elephant [ Y ] ” ) . When applying the rule in reasoning , variables are substituted with concrete sentences ( [ X ] → strong , [ Y ] → likes cats ) . Therefore , rules capture abstract knowledge that is independent of specific instances—the above rule holds whether [ Y ] is “ likes cats ” or “ is sleepy ” . Such abstraction is essential for reasoning in both humans and machines ( Marcus & Davis , 2020 ) . Fig . 1 illustrates how sentences and rules are used in reasoning . Starting from known sentences ( assumptions ) , we apply rules to derive new sentences until the goal is reached . At each step , we substitute the variables in a rule with concrete sentences . This process resembles Metamath ( Megill & Wheeler , 2019 ) , a formal language developed for formalizing mathematical proofs , where each step also consists of selecting a theorem and instantiating it with a suitable substitution . So we refer to the reasoning process as theorem proving and the result in Fig . 1 as a proof . It is worth noting that reasoning in MetaQNL is interpretable by design : it is transparent about what rules are assumed ; it produces not only an answer , but also a proof that can be mechanically checked against the rules . Assumptions and the goal are usually given when applying our system to a specific task . To solve the task , two issues remain : ( 1 ) Rule induction : What is the set of rules ? ( 2 ) Theorem proving : How to apply the rules to find a proof ? Theorem proving has been studied extensively in classical AI ( Robinson & Voronkov , 2001 ) and more recently with deep learning ( Alemi et al. , 2016 ; Yang & Deng , 2019 ; Bansal et al. , 2019 ) , and we can adapt existing algorithms such as forward chaining and backward chaining ( Russell & Norvig , 2002 ) . In this work , we simply use existing provers and focus instead on the more challenging problem of rule induction . MetaInduce : an Algorithm to Learn MetaQNL Rules . Rule induction can be formulated as a discrete optimization problem that seeks a minimum set of rules that are consistent with training examples . Note that it is important to seek a small number of rules because we always have a trivial solution that consists of one rule per example but is unlikely to generalize . This optimization is challenging due to the discrete , combinatorial search space . We introduce MetaInduce , a general method for learning MetaQNL rules . It encodes the problem as a maximum satisfiability ( MAX-SAT ) problem , which can be solved efficiently by off-the-shelf solvers ( De Moura & Bjørner , 2008 ) . Our method consists of 3 steps . First , given a training example , a rule proposer proposes a set of concrete rules ( rules without variables ) as candidates . This set can be overcomplete and inaccurate . These rules are used to prove the example using existing provers such as forward/backward chaining . Second , we generate abstract rules from concrete rules via a symbolic procedure called anti-unification ( Plotkin , 1970 ; Kutsia et al. , 2014 ) . Third , we encode the proof paths in MAX-SAT and solve for a subset of all rules using a MAX-SAT solver . Overview of Results . We benchmark our method on 2 tasks : learning compositional instructions and logical reasoning . For learning compositional instructions , our method not only achieves 100 % accuracy on two standard benchmarks : MiniSCAN ( Lake et al. , 2019 ) and SCAN ( Lake & Baroni , 2018 ) , but also recovers precisely the ground truth rules . For logical reasoning , our method achieves state of the art on the RuleTaker dataset ( Clark et al. , 2020 ) . Compared to existing methods , our approach learns compact models with much less data , and produces not only answers but also checkable proofs . On RuleTaker , our approach learns a model that has only 2869 symbols but is competitive with a prior approach that uses a neural network with 11 billion parameters . 2 RELATED WORK . Symbolic reasoning . Symbolic reasoning has been studied extensively in classical AI , such as theorem proving ( Kovács & Voronkov , 2013 ; Robinson & Voronkov , 2001 ) . An open problem is to perform symbolic reasoning in domains without a natural formalization , such as natural images or texts . One common approach is to manually construct a formal system ( e.g. , based on first-order logic with manually defined functions and predicates ) , then perform semantic parsing to translate images or texts into formalized statements as input to a reasoning module operating in a clean formal world . For example , to judge whether one statement implies another , Mineshima et al . ( 2015 ) use a semantic parser to convert both statements into higher-order logic ( with predefined predicates ) , and then run an automated theorem prover . Semantic parsing is still far from reliable ; therefore , researchers have developed techniques for learning it jointly with the reasoning module ( Mao et al. , 2018 ; Saparov & Mitchell , 2021 ; Dai et al. , 2019 ; Li et al. , 2020 ) . In contrast , our approach does not require a semantic parser , because rules in MetaQNL are directly applicable to natural language . Natural Logic ( McAllester & Givan , 1993 ; MacCartney & Manning , 2007 ; Angeli et al. , 2016 ) is a class of symbolic systems defined using the syntax of natural language , bypassing semantic parsing . Compared to our system , Natural Logic is more specialized because it is a specific logic committed to a set of predefined rules ( namely seven set-theoretical relations ) , which restrict the type of reasoning it can perform to monotonicity reasoning ( Icard III & Moss , 2014 ) . In contrast , our system has no such restrictions because is not a specific logic but a meta-language with minimal structure such that it can instantiate various types of reasoning , just as MetaMath is a meta-language that can describe a variety of mathematical logics ( Megill & Wheeler , 2019 ) . None of these works discussed so far learn rules from data ; they instead use a predefined formal system that is already specialized and already encodes a substantial amount of prior knowledge . In contrast , MetaQNL is almost “ knowledge-free ” in the sense that it imposes the weakest possible structure on the permitted rules and lets the specific rules emerge from data through learning . Reasoning with neural networks . Neural networks can perform “ soft ” reasoning in the space of continuous vectors without manipulating discrete symbols explicitly . Prior works have used transformer-based ( Vaswani et al. , 2017 ) language models for soft reasoning ( Polu & Sutskever , 2020 ; Saha et al. , 2020 ; Tafjord et al. , 2020 ; Gontier et al. , 2020 ; Talmor et al. , 2020 ) . Clark et al . ( 2020 ) finetune a pretrained transformer to classify whether the goal is provable from the assumptions , encoding them as sentences in a constrained natural language . Saha et al . ( 2020 ) and Tafjord et al . ( 2020 ) go one step further to generate proofs in addition to yes/no answers . Bostrom et al . ( 2021 ) generate conclusions from premises in unconstrained natural language . Instead of using a generic transformer , researchers have also added inductive biases to the neural architecture . Many are inspired by symbolic reasoning and are often called neuro-symbolic architectures . Rocktäschel & Riedel ( 2017 ) introduce Neural Theorem Provers ( NTPs ) . Given the assumptions and the goal in first-order logic , they use backward chaining to recursively construct a neural network . However , NTPs only work for formalized inputs and do not scale due to exponentially many proof paths in backward chaining . Weber et al . ( 2019 ) extend NTPs to natural language by extracting symbols from sentences using an off-the-shelf named entity recognizer . Minervini et al . ( 2020 ) make NTPs more scalable by dynamically pruning unpromising proof paths in backward chaining . Researchers have also attempted to embed symbolic structures such as logic formulas into continuous vectors while preserving logical operations ( Grefenstette , 2013 ; Kathryn & Mazaitis , 2018 ; Lee et al. , 2016 ; Schlag et al. , 2019 ) . For example , tensor product representations ( TPRs ) ( Smolensky , 1990 ) represent symbols as tensors and perform variable binding/unbinding via tensor operations such as inner/outer product . Dong et al . ( 2018 ) propose Neural Logic Machines ( NLMs ) —a neuro-symbolic architecture based on continuous approximation of logical inference . Predicates are represented as tensors ; rules are neural operators that map tensors to tensors . Cingillioglu & Russo ( 2020 ) propose an end-to-end neural architecture called unification networks to learn rules with variables from concrete examples . However , their system of rules is significantly less general than ours : their variables can only bind to a single word , whereas our variables bind to arbitrary sentences . In addition , their system does not support multistep chained reasoning . All reasoning is done in a single step : producing a conclusion in the form of an answer ( `` yes/no '' , a number , etc . ) given a number of premises consisting of a question and a set of supporting facts . Unlike these prior works , we learn symbolic rules instead of weights in a neural network . Further , during inference , we generate symbolic proofs whose correctness with respect to the induced rules is guaranteed and can be mechanically checked . Saha et al . ( 2020 ) and Tafjord et al . ( 2020 ) also generate proofs , but their proofs are natural language texts whose correctness is neither guaranteed nor mechanically checkable—their approach trains neural networks to directly predict both answers and proofs , but does not expose a system of rules against which a proof can be checked . Rule induction . Inductive logic programming ( ILP ) learns rules in first-order logic programs such as Prolog and Datalog ( Plotkin , 1972 ; Muggleton , 1991 ; Cropper & Dumančić , 2020 ) . Extending it to natural language is non-trivial—partially due to the need for a predefined ontology of objects and predicates , as well as a perfect semantic parser , both of which are infeasible . Unlike ILP , we learn rules in MetaQNL , which can express not only logic programs but also natural language sentences . And our experiments show that MetaQNL can solve tasks that are not easily solvable by ILP . For learning rules , our MetaInduce algorithm draws inspiration from existing ILP approaches . They encode proofs as either a boolean satisfiability problem solvable by off-the-shelf SAT solvers ( Raghothaman et al. , 2019 ) or a differentiable function amenable to gradient descent ( Yang et al. , 2017 ; Evans & Grefenstette , 2018 ; Si et al. , 2019 ) . Compared to these approaches , our rule space is different and more complex . Our rules consist of sentences with variables , whereas rules in ILP are typically Horn clauses in first-order logic . Further , ILP often imposes strong syntactic constraints on what rules are valid , e.g. , using rule templates ( Evans & Grefenstette , 2018 ; Raghothaman et al. , 2019 ) , or restricting to binary predicates ( Evans & Grefenstette , 2018 ) . These constraints are critical to good performance but are domain-dependent and difficult to get right ( Cropper & Dumančić , 2020 ) . Over-constraining the rule space makes the system less expressive , less generally applicable , and more brittle in the presence of noise . Another difference is that we minimize the number of rules in order to generalize , which is unnecessary for ILP due to stronger syntactic constraints . Our space of rules includes a rich hierarchy from abstract rules to concrete rules , making the search space much larger . In contrast , most ILP works assume function-free first-order logic such as Datalog . Their variables can only be instantiated with concrete entities , making their rule space much simpler . RNNLogic ( Qu et al. , 2021 ) learns first-order rules for knowledge base completion . They generate rules using RNNs , which is feasible because they require that rules can be expressed as a sequence of predicates . The strong syntactic constraint makes it less suitable for more general reasoning . Beyond first-order logic , Nye et al . ( 2020 ) learn rules for a string rewriting system . MetaQNL is more general because it can be applied to not only string rewriting but also other forms of reasoning ( see Sec . 5 ) .

Summary: This paper proposes a symbolic system in Quasi-Natural Language, MetaQNL, which is compatible with both logical inference and quasi natural language expressions, and where the basic building blocks are sentences and rules. The authors also propose MetaInduce, which learns to generalize a set of rules that explains the examples in MetaInduce.  MetaInduce consists of three mains steps: 1) a rule proposer proposes a set of concrete rules as candidates for each individual example. This set may not be fully correct and may not be the minimal explanations, and they are used to prove the example using forward/backward chaining. 2) the authors apply a symbolic procedure called anti-unification to generate abstract rules from concrete rules. 3) and finally, proof paths are encoded in MAX-SAT and a subset of all rules are solved using a MAX-SAT solver to find minimal possible explanations  This paper evaluates its methods on two synthetic datasets, and the authors claim to learn compact models with much less data, and produces answers as well as proofs