Original: Improved Logical Reasoning of Language Models via Differentiable Symbolic Programming
Revised: Improved Logical Reasoning of Language Models via Differentiable Symbolic Programming

Original: Anonymous ACL submission
Revised: Anonymous ACL submission

Original: Abstract
Revised: Abstract

Original: Pre-trained large language models (LMs) struggle to perform logical reasoning reliably despite advances in scale and compositionality.
Revised: Pre-trained large language models (LMs) struggle to perform logical reasoning reliably despite advances in scale and compositionality.

Original: In this work, we tackle this challengethrough the lens of symbolic programming.
Revised: In this work, we tackle this challengethrough the lens of symbolic programming.

Original: Wepropose DSR-LM, a D ifferentiable S ymbolic
Revised: Wepropose DSR-LM, a D ifferentiable S ymbolic

Original: R easoning framework where pre-trained LM sgovern the perception of factual knowledge,and a symbolic module performs deductivereasoning.
Revised: R easoning framework where pre-trained LM sgovern the perception of factual knowledge,and a symbolic module performs deductivereasoning.

Original: In contrast to works that rely onhand-crafted logic rules, our differentiable symbolic reasoning framework efficiently learnsweighted rules and applies semantic loss tofurther improve LMs.
Revised: In contrast to works that rely onhand-crafted logic rules, our differentiable symbolic reasoning framework efficiently learnsweighted rules and applies semantic loss tofurther improve LMs.

Original: DSR-LM is scalable,interpretable, and allows easy integration ofprior knowledge, thereby supporting extensivesymbolic programming to robustly derive a logical conclusion.
Revised: DSR-LM is scalable,interpretable, and allows easy integration ofprior knowledge, thereby supporting extensivesymbolic programming to robustly derive a logical conclusion.

Original: The results of our experimentssuggest that DSR-LM improves the logical reasoning abilities of pre-trained language models,resulting in a significant increase in accuracy ofover 20% on deductive reasoning benchmarks.
Revised: The results of our experimentssuggest that DSR-LM improves the logical reasoning abilities of pre-trained language models,resulting in a significant increase in accuracy ofover 20% on deductive reasoning benchmarks.

Original: Furthermore, DSR-LM outperforms a varietyof competitive baselines when faced with systematic changes in sequence length.
Revised: Furthermore, DSR-LM outperforms a varietyof competitive baselines when faced with systematic changes in sequence length.

Original:  Introduction
Revised:  Introduction

Original: Complex applications in natural language processing involve dealing with two separate challenges.
Revised: Complex applications in natural language processing involve dealing with two separate challenges.

Original: On one hand, there is the richness, nuances, andextensive vocabulary of natural language.
Revised: On one hand, there is the richness, nuances, andextensive vocabulary of natural language.

Original: On theother hand, one needs logical connectives, long reasoning chains, and domain-specific knowledge todraw logical conclusions.
Revised: On theother hand, one needs logical connectives, long reasoning chains, and domain-specific knowledge todraw logical conclusions.

Original: The systems handlingthese two challenges are complementary to eachother and are likened to psychologist Daniel Kahneman’s human “system 1” and “system 2” (Kahneman, 2011): while the former makes fast and intuitive decisions, akin to neural networks, the latterthinks more rigorously and methodically.
Revised: The systems handlingthese two challenges are complementary to eachother and are likened to psychologist Daniel Kahneman’s human “system 1” and “system 2” (Kahneman, 2011): while the former makes fast and intuitive decisions, akin to neural networks, the latterthinks more rigorously and methodically.

Original: Considering LMs as “system 1” and symbolic reasoners
Revised: Considering LMs as “system 1” and symbolic reasoners

Original: [Table]
Revised: [Table]

Original: as “system 2”, we summarize their respective ad-
Revised: as “system 2”, we summarize their respective ad-

Original: [Table]
Revised: [Table]

Original: vantages in Table 1.
Revised: vantages in Table 1.

Original: [Table]
Revised: [Table]

Original: Although pre-trained LMs have demonstrated
Revised: Although pre-trained LMs have demonstrated

Original: [Table]
Revised: [Table]

Original: remarkable predictive performance, making them
Revised: remarkable predictive performance, making them

Original: [Table]
Revised: [Table]

Original: an effective “system 1”, they fall short when asked
Revised: an effective “system 1”, they fall short when asked

Original: [Table]
Revised: [Table]

Original: to perform consistent logical reasoning (Kassner
Revised: to perform consistent logical reasoning (Kassner

Original: [Table]
Revised: [Table]

Original: et al., 2020;
Revised: et al., 2020;

Original: Helwe et al., 2021;
Revised: Helwe et al., 2021;

Original: Creswell et al.,
Revised: Creswell et al.,

Original: [Table]
Revised: [Table]

Original: 2022), which usually requires “system 2”.
Revised: 2022), which usually requires “system 2”.

Original: In part, this is because LMs largely lack capabilities of systematic generalization (Elazar et al., 2021;
Revised: In part, this is because LMs largely lack capabilities of systematic generalization (Elazar et al., 2021;

Original: Hase et al., 2021; Valmeekam et al., 2022).
Revised: Hase et al., 2021; Valmeekam et al., 2022).

Original: In this work, we seek to incorporate deductive logical reasoning with LMs.
Revised: In this work, we seek to incorporate deductive logical reasoning with LMs.

Original: Our approach has the same key objectives as neuro-symbolic programming (Chaudhuri et al., 2021): compositionality, consistency, interpretability, and easy integration of prior knowledge.
Revised: Our approach has the same key objectives as neuro-symbolic programming (Chaudhuri et al., 2021): compositionality, consistency, interpretability, and easy integration of prior knowledge.

Original: We present DSR-LM, which tightly integrates a differentiable symbolic reasoning module with pre-trained LMs in an end-to-end fashion.
Revised: We present DSR-LM, which tightly integrates a differentiable symbolic reasoning module with pre-trained LMs in an end-to-end fashion.

Original: With DSR-LM, the underlying LMs govern the perception of natural language and are finetuned to extract relational triplets with only weak supervision.
Revised: With DSR-LM, the underlying LMs govern the perception of natural language and are finetuned to extract relational triplets with only weak supervision.

Original: To overcome a common limitation of symbolic reasoning systems, the reliance on human-crafted logic rules (Huang et al., 2021; Nye et al., 2021), we adapt DSR-LM to induce and finetune rules automatically.
Revised: To overcome a common limitation of symbolic reasoning systems, the reliance on human-crafted logic rules (Huang et al., 2021; Nye et al., 2021), we adapt DSR-LM to induce and finetune rules automatically.

Original: Further, DSR-LM allows incorporation of semantic loss obtained by logical integrity constraints given as prior knowledge, which substantially helps the robustness.
Revised: Further, DSR-LM allows incorporation of semantic loss obtained by logical integrity constraints given as prior knowledge, which substantially helps the robustness.

Original: We conduct extensive experiments showing that
Revised: We conduct extensive experiments showing that

Original: DSR-LM can consistently improve the logical reasoning capability upon pre-trained LMs.
Revised: DSR-LM can consistently improve the logical reasoning capability upon pre-trained LMs.

Original: Even if
Revised: Even if

Original: DSR-LM uses a RoBERTa backbone with muchless parameters and does not explicitly take tripletsas supervision, it can still outperform various baselines by large margins.
Revised: DSR-LM uses a RoBERTa backbone with muchless parameters and does not explicitly take tripletsas supervision, it can still outperform various baselines by large margins.

Original: Moreover, we show that
Revised: Moreover, we show that

Original: DSR-LM can induce logic rules that are amenableto human understanding to explain decisions givenonly higher-order predicates.
Revised: DSR-LM can induce logic rules that are amenableto human understanding to explain decisions givenonly higher-order predicates.

Original: As generalizationover long-range dependencies is a significant weakness of transformer-based language models (Lakeand Baroni, 2018; Tay et al., 2020), we highlightthat in systematic, long-context scenarios, wheremost pre-trained or neural approaches fail to generalize compositionally, DSR-LM can still achieveconsiderable performance gains.
Revised: As generalizationover long-range dependencies is a significant weakness of transformer-based language models (Lakeand Baroni, 2018; Tay et al., 2020), we highlightthat in systematic, long-context scenarios, wheremost pre-trained or neural approaches fail to generalize compositionally, DSR-LM can still achieveconsiderable performance gains.

Original:  Related Work
Revised:  Related Work

Original: Logical reasoning with LMs.
Revised: Logical reasoning with LMs.

Original: Pre-trained LMshave been shown to struggle with logical reasoning over factual knowledge (Kassner et al., 2020;
Revised: Pre-trained LMshave been shown to struggle with logical reasoning over factual knowledge (Kassner et al., 2020;

Original: Helwe et al., 2021; Talmor et al., 2020a).
Revised: Helwe et al., 2021; Talmor et al., 2020a).

Original: There isencouraging recent progress in using transformersfor reasoning tasks (Zhou et al., 2020; Clark et al.
Revised: There isencouraging recent progress in using transformersfor reasoning tasks (Zhou et al., 2020; Clark et al.

Original: ,2021; Wei et al., 2022; Chowdhery et al., 2022;
Revised: ,2021; Wei et al., 2022; Chowdhery et al., 2022;

Original: Zelikman et al., 2022)
Revised: Zelikman et al., 2022)

Original: but these approaches usually require a significant amount of computationfor re-training or human annotations on reasoning provenance (Camburu et al., 2018;
Revised: but these approaches usually require a significant amount of computationfor re-training or human annotations on reasoning provenance (Camburu et al., 2018;

Original: Zhou et al.
Revised: Zhou et al.

Original: Nye et al., 2021; Wei et al., 2022).
Revised: Nye et al., 2021; Wei et al., 2022).

Original: Moreover,their entangled nature with natural language makesit fundamentally hard to achieve robust inferenceover factual knowledge (Greff et al., 2020; Saparovand He, 2022; Zhang et al., 2022).
Revised: Moreover,their entangled nature with natural language makesit fundamentally hard to achieve robust inferenceover factual knowledge (Greff et al., 2020; Saparovand He, 2022; Zhang et al., 2022).

Original: There are other obvious remedies for LMs’ poorreasoning capability.
Revised: There are other obvious remedies for LMs’ poorreasoning capability.

Original: Ensuring that the trainingcorpus contains a sufficient amount of exemplaryepisodes of sound reasoning reduces the dependency on normative biases and annotation artifacts (Talmor et al., 2020b; Betz et al., 2020; Haseet al., 2021).
Revised: Ensuring that the trainingcorpus contains a sufficient amount of exemplaryepisodes of sound reasoning reduces the dependency on normative biases and annotation artifacts (Talmor et al., 2020b; Betz et al., 2020; Haseet al., 2021).

Original: Heuristics like data augmentation arealso shown to be effective (Talmor et al., 2020b).
Revised: Heuristics like data augmentation arealso shown to be effective (Talmor et al., 2020b).

Original: But the above works require significant efforts forcrowdsourcing and auditing training data.
Revised: But the above works require significant efforts forcrowdsourcing and auditing training data.

Original: Ourmethod handily encodes a few prototypes/templates of logic rules and is thus more efficient interms of human effort.
Revised: Ourmethod handily encodes a few prototypes/templates of logic rules and is thus more efficient interms of human effort.

Original: Moreover, our goal is fundamentally different from theirs in investigating thetight integration of neural and symbolic models inan end-to-end manner.
Revised: Moreover, our goal is fundamentally different from theirs in investigating thetight integration of neural and symbolic models inan end-to-end manner.

Original: Neuro-symbolic reasoning.
Revised: Neuro-symbolic reasoning.

Original: Neuro-symbolicapproaches are proposed to integrate the perception of deep neural components and the reasoning of symbolic components.
Revised: Neuro-symbolicapproaches are proposed to integrate the perception of deep neural components and the reasoning of symbolic components.

Original: Representative works can be briefly categorized into regularization (Xu et al., 2018), program synthesis (Mao et al., 2018), and proof-guided probabilistic programming (Evans and Grefenstette, 2018; Rocktäschel and Riedel, 2017; Manhaeve et al., 2018; Zhang et al., 2019;
Revised: Representative works can be briefly categorized into regularization (Xu et al., 2018), program synthesis (Mao et al., 2018), and proof-guided probabilistic programming (Evans and Grefenstette, 2018; Rocktäschel and Riedel, 2017; Manhaeve et al., 2018; Zhang et al., 2019;

Original: Huang et al., 2021).
Revised: Huang et al., 2021).

Original: To improve compositionality of LMs, previous works propose to parameterize grammatical rules (Kim, 2021; Shaw et al., 2021) but show that those hybrid models are inefficient and usually underperform neural counterparts.
Revised: To improve compositionality of LMs, previous works propose to parameterize grammatical rules (Kim, 2021; Shaw et al., 2021) but show that those hybrid models are inefficient and usually underperform neural counterparts.

Original: In contrast to the above works, DSR-LM focuses on improving LMs’ reasoning over logical propositions with tight integration of their pre-trained knowledge in a scalable and automated way.
Revised: In contrast to the above works, DSR-LM focuses on improving LMs’ reasoning over logical propositions with tight integration of their pre-trained knowledge in a scalable and automated way.

Original:  Methodology
Revised:  Methodology

Original: 3. Problem Formulation
Revised: 3. Problem Formulation

Original: Each question answering (QA) example in the dataset is a triplet containing input text x , query q , and the answer y .
Revised: Each question answering (QA) example in the dataset is a triplet containing input text x , query q , and the answer y .

Original: Figure 1 shows an instance which we will use as our running example.
Revised: Figure 1 shows an instance which we will use as our running example.

Original: The input text x is a natural language passage within which there will be a set of entities, possibly referenced by 3rd person pronouns.
Revised: The input text x is a natural language passage within which there will be a set of entities, possibly referenced by 3rd person pronouns.

Original: The sentences hint at the relationships between entities.
Revised: The sentences hint at the relationships between entities.

Original: For example, “Dorothy went to her brother Rich’s birthday party” implies that Rich is Dorothy’s brother and Dorothy is Rich’s sister.
Revised: For example, “Dorothy went to her brother Rich’s birthday party” implies that Rich is Dorothy’s brother and Dorothy is Rich’s sister.

Original: The query q is a tuple of two entities, representing the people whom we want to infer the relation between.
Revised: The query q is a tuple of two entities, representing the people whom we want to infer the relation between.

Original: The expected relation is stored in the answer y , which will be one of a confined set of possible relations R , allowing us to treat the whole problem as an ∣R∣ -way classification problem.
Revised: The expected relation is stored in the answer y , which will be one of a confined set of possible relations R , allowing us to treat the whole problem as an ∣R∣ -way classification problem.

Original: We focus only on the problems where the desired relation is not explicitly stated in the context, but need to be deduced through a sequence of reasoning.
Revised: We focus only on the problems where the desired relation is not explicitly stated in the context, but need to be deduced through a sequence of reasoning.

Original: 3. Methodology Overview
Revised: 3. Methodology Overview

Original: DSR-LM’s design concerns tightly integrating a perceptive model for relation extraction with a symbolic engine for logical reasoning.
Revised: DSR-LM’s design concerns tightly integrating a perceptive model for relation extraction with a symbolic engine for logical reasoning.

Original: While we apply LMs for low level perception and relation extraction, we employ a symbolic reasoning module to consistently and logically reason about the extracted relations.
Revised: While we apply LMs for low level perception and relation extraction, we employ a symbolic reasoning module to consistently and logically reason about the extracted relations.

Original: With a recent surge in neurosymbolic methods, reasoning engines are made differentiable, allowing us to differentiate through the logical reasoning process.
Revised: With a recent surge in neurosymbolic methods, reasoning engines are made differentiable, allowing us to differentiate through the logical reasoning process.

Original: In particular, we em-
Revised: In particular, we em-

Original: [Figure]
Revised: [Figure]

Original: ploy Scallop (Huang et al., 2021) as our reasoningengine.
Revised: ploy Scallop (Huang et al., 2021) as our reasoningengine.

Original: We propose two add-ons to the existingneuro-symbolic methodology.
Revised: We propose two add-ons to the existingneuro-symbolic methodology.

Original: First, some rulesused for logical deduction are initialized using language models and further tuned by our end-to-endpipeline, alleviating human efforts.
Revised: First, some rulesused for logical deduction are initialized using language models and further tuned by our end-to-endpipeline, alleviating human efforts.

Original: Secondly, weemploy integrity constraints on the extracted relation graphs and the logical rules, to improve thelogical consistency of LMs and the learnt rules.
Revised: Secondly, weemploy integrity constraints on the extracted relation graphs and the logical rules, to improve thelogical consistency of LMs and the learnt rules.

Original: Based on this high-level design, we formalizeour method as follows.
Revised: Based on this high-level design, we formalizeour method as follows.

Original: We adopt pretrained LMsto build relation extractors, denoted M θ , whichtakes in the natural language input x and returnsa set of probabilistic relational symbols r .
Revised: We adopt pretrained LMsto build relation extractors, denoted M θ , whichtakes in the natural language input x and returnsa set of probabilistic relational symbols r .

Original: Next,we employ a differentiable deductive reasoningprogram, P ϕ , where ϕ represents the weights of thelearnt logic rules.
Revised: Next,we employ a differentiable deductive reasoningprogram, P ϕ , where ϕ represents the weights of thelearnt logic rules.

Original: It takes as input the probabilisticrelational symbols and the query q and returns adistribution over R as the output ˆ y .
Revised: It takes as input the probabilisticrelational symbols and the query q and returns adistribution over R as the output ˆ y .

Original: Overall, thedeductive model is written as
Revised: Overall, thedeductive model is written as

Original: [Equation]
Revised: [Equation]

Original: Additionally, we have the semantic loss ( sl ) derived by another symbolic program P sl computingthe probability of violating the integrity constraints:
Revised: Additionally, we have the semantic loss ( sl ) derived by another symbolic program P sl computingthe probability of violating the integrity constraints:

Original: [Equation]
Revised: [Equation]

Original: Combined, we aim to minimize the objective Jover training set D with loss function L :
Revised: Combined, we aim to minimize the objective Jover training set D with loss function L :

Original: [Equation]
Revised: [Equation]

Original: where w 1 and w 2 are tunable hyper-parameters tobalance the deduction loss and semantic loss.
Revised: where w 1 and w 2 are tunable hyper-parameters tobalance the deduction loss and semantic loss.

Original: 3. Relation Extraction
Revised: 3. Relation Extraction

Original: Since pre-trained LMs have strong pattern recognition capabilities for tasks like Named-EntityRecognition (NER) and Relation Extraction (RE) (Tenney et al., 2019; Soares et al., 2019), we adopt them as our neural components in DSR-LM.
Revised: Since pre-trained LMs have strong pattern recognition capabilities for tasks like Named-EntityRecognition (NER) and Relation Extraction (RE) (Tenney et al., 2019; Soares et al., 2019), we adopt them as our neural components in DSR-LM.

Original: To ensure that LMs take in strings of similar length, we divide the whole context into multiple windows.
Revised: To ensure that LMs take in strings of similar length, we divide the whole context into multiple windows.

Original: The goal is to extract distribution of relations between every pair of entities in each windowed context.
Revised: The goal is to extract distribution of relations between every pair of entities in each windowed context.

Original: Concretely, our relation extractor M θ comprises three components: 1) a Named-Entity Recognizer (NER) to obtain the entities in the input text, 2) a pre-trained language model, to be fine-tuned, that converts windowed text into embeddings, and 3) a classifier that takes in the embedding of entities and predicts the relationship between them.
Revised: Concretely, our relation extractor M θ comprises three components: 1) a Named-Entity Recognizer (NER) to obtain the entities in the input text, 2) a pre-trained language model, to be fine-tuned, that converts windowed text into embeddings, and 3) a classifier that takes in the embedding of entities and predicts the relationship between them.

Original: The set of parameters θ contains the parameters of both the LM and the classifier.
Revised: The set of parameters θ contains the parameters of both the LM and the classifier.

Original: We assume the relations to be classified come from a finite set of relations R .
Revised: We assume the relations to be classified come from a finite set of relations R .

Original: For example in
Revised: For example in

Original: CLUTRR (Sinha et al., 2019), we have 20 kinship relations including mother, son, uncle, fatherin-law, etc.
Revised: CLUTRR (Sinha et al., 2019), we have 20 kinship relations including mother, son, uncle, fatherin-law, etc.

Original: In practice, we perform (∣R∣ + 1 ) - way classification over each pair of entities, where the extra class stands for “n/a”.
Revised: In practice, we perform (∣R∣ + 1 ) - way classification over each pair of entities, where the extra class stands for “n/a”.

Original: The windowed contexts are split based on simple heuristics of “contiguous one to three sentences that contain at least two entities”, to account for coreference resolution.
Revised: The windowed contexts are split based on simple heuristics of “contiguous one to three sentences that contain at least two entities”, to account for coreference resolution.

Original: The windowed contexts can be overlapping and we allow the reasoning module to deal with noisy and redundant data.
Revised: The windowed contexts can be overlapping and we allow the reasoning module to deal with noisy and redundant data.

Original: Overall, assuming that there are m windows in the context x , we extract mn ( n − 1 )(∣R∣ + 1 ) probabilistic relational symbols.
Revised: Overall, assuming that there are m windows in the context x , we extract mn ( n − 1 )(∣R∣ + 1 ) probabilistic relational symbols.

Original: Each symbol is denoted as an atom of the form p ( s, o ) , where p ∈ R ∪ { n/a } is the relational predicate, and s , o are the two entities connected by the predicate.
Revised: Each symbol is denoted as an atom of the form p ( s, o ) , where p ∈ R ∪ { n/a } is the relational predicate, and s , o are the two entities connected by the predicate.

Original: We denote the probability of such symbol extracted by the
Revised: We denote the probability of such symbol extracted by the

Original: LM and relational classifier as Pr ( p ( s, o ) ∣ θ ) .
Revised: LM and relational classifier as Pr ( p ( s, o ) ∣ θ ) .

Original: All these probabilities combined form the output vector r =
Revised: All these probabilities combined form the output vector r =

Original: M θ ( x ) ∈
Revised: M θ ( x ) ∈

Original: R mn ( n − 1 )(∣R∣+ 1 ) .
Revised: R mn ( n − 1 )(∣R∣+ 1 ) .

Original: 3. Differentiable Symbolic Inference
Revised: 3. Differentiable Symbolic Inference

Original: The symbolic inference modules P ϕ and P sl areresponsible for processing the extracted relations todeduce 1) an expected output relation in R , and 2) asemantic loss encoding the probability of constraintviolation.
Revised: The symbolic inference modules P ϕ and P sl areresponsible for processing the extracted relations todeduce 1) an expected output relation in R , and 2) asemantic loss encoding the probability of constraintviolation.

Original: There are two main objectives for thesemodules.
Revised: There are two main objectives for thesemodules.

Original: First, they need to logically reason aboutthe output relation and the semantic loss based onthe extracted relational symbols r , the query q , andthe rule weights ϕ .
Revised: First, they need to logically reason aboutthe output relation and the semantic loss based onthe extracted relational symbols r , the query q , andthe rule weights ϕ .

Original: Second, they need to computethe gradients of ˆ y and l sl with respect to θ andϕ , namely ∂ ˆ y∂θ , ∂ ˆ y∂ϕ , ∂l sl ∂ϕ , and ∂l sl ∂θ , in order for thefine-tuning and rule learning to happen.
Revised: Second, they need to computethe gradients of ˆ y and l sl with respect to θ andϕ , namely ∂ ˆ y∂θ , ∂ ˆ y∂ϕ , ∂l sl ∂ϕ , and ∂l sl ∂θ , in order for thefine-tuning and rule learning to happen.

Original: Logical deduction.
Revised: Logical deduction.

Original: Logic rules can be appliedto known facts to deduce new ones.
Revised: Logic rules can be appliedto known facts to deduce new ones.

Original: For example,below is a horn clause, which reads “if b is a ’sbrother and c is b ’s daughter, then c is a ’s niece”:niece ( a, c ) ← brother ( a, b ) ∧ daughter ( b, c ) .
Revised: For example,below is a horn clause, which reads “if b is a ’sbrother and c is b ’s daughter, then c is a ’s niece”:niece ( a, c ) ← brother ( a, b ) ∧ daughter ( b, c ) .

Original: Note that the structure of the above rule canbe captured by a higher-order logical predicate called “composite” (abbreviated as co ).
Revised: Note that the structure of the above rule canbe captured by a higher-order logical predicate called “composite” (abbreviated as co ).

Original: This allows us to express many other similarlystructured rules with ease.
Revised: This allows us to express many other similarlystructured rules with ease.

Original: For instance, wecan have co(brother, daughter, niece)
Revised: For instance, wecan have co(brother, daughter, niece)

Original: andco(father, mother, grandmother) .
Revised: andco(father, mother, grandmother) .

Original: With thisset of rules, we may derive more facts based onknown kinship relations.
Revised: With thisset of rules, we may derive more facts based onknown kinship relations.

Original: In fact, composition is theonly kind of rule we need for kinship reasoning.
Revised: In fact, composition is theonly kind of rule we need for kinship reasoning.

Original: Ingeneral, there are many other useful higher-orderpredicates to reason over knowledge bases, whichwe list out in Table 2.
Revised: Ingeneral, there are many other useful higher-orderpredicates to reason over knowledge bases, whichwe list out in Table 2.

Original: Predicate
Revised: Predicate

Original: Example
Revised: Example

Original: [Table]
Revised: [Table]

Original: ( relative ) symmetric symmetric ( spouse )
Revised: ( relative ) symmetric symmetric ( spouse )

Original: [Table]
Revised: [Table]

Original: husband , wife ) implies implies ( mother , parent )
Revised: husband , wife ) implies implies ( mother , parent )

Original: Probability propagation.
Revised: Probability propagation.

Original: We seek to have thededuced facts to also be associated with probabilities computed using probabilities predicted by theunderlying relation extractor M θ .
Revised: We seek to have thededuced facts to also be associated with probabilities computed using probabilities predicted by theunderlying relation extractor M θ .

Original: This is achievedby allowing the propagation of probabilities.
Revised: This is achievedby allowing the propagation of probabilities.

Original: Forexample, we have the proof tree with probabilities:0 .
Revised: Forexample, we have the proof tree with probabilities:0 .

Original: [Equation]
Revised: [Equation]

Original: [Equation]

Original: [Equation]
Revised: [Equation]

Original: daughter

Original: [Equation]
Revised: [Equation]

Original: K
Revised: K

Original: [Equation]
Revised: [Equation]

Original: 72 ∶∶ niece ( D,K )
Revised: 72 ∶∶ niece ( D,K )

Original: In practice, there could be multiple steps in theproof tree (multi-hop) and one fact can be derivedby multiple proof trees.
Revised: In practice, there could be multiple steps in theproof tree (multi-hop) and one fact can be derivedby multiple proof trees.

Original: We employ the inferencealgorithms based on approximated weighted modelcounting (WMC) presented in (Manhaeve et al., 2018) to account for probabilistic inference under complex scenarios.
Revised: We employ the inferencealgorithms based on approximated weighted modelcounting (WMC) presented in (Manhaeve et al., 2018) to account for probabilistic inference under complex scenarios.

Original: Since the WMC procedure is augmented for differentiation, we can obtain the gradient ∂ ˆ y∂ r .
Revised: Since the WMC procedure is augmented for differentiation, we can obtain the gradient ∂ ˆ y∂ r .

Original: From here, we can obtain ∂ ˆ y∂θ =
Revised: From here, we can obtain ∂ ˆ y∂θ =

Original: ∂ ˆ y∂ r ∂ r ∂θ , where the second part can be automatically derived from differentiating M θ .
Revised: ∂ ˆ y∂ r ∂ r ∂θ , where the second part can be automatically derived from differentiating M θ .

Original: Rule learning.
Revised: Rule learning.

Original: Hand-crafted rules could be expensive or even impossible to obtain.
Revised: Hand-crafted rules could be expensive or even impossible to obtain.

Original: To alleviate this issue, DSR-LM applies LMs to help automatically extract rules, and further utilizes the differentiable pipeline to fine-tune the rules.
Revised: To alleviate this issue, DSR-LM applies LMs to help automatically extract rules, and further utilizes the differentiable pipeline to fine-tune the rules.

Original: Each rule such as co(brother, daughter, niece) is attached a weight, initialized by prompting an underlying
Revised: Each rule such as co(brother, daughter, niece) is attached a weight, initialized by prompting an underlying

Original: LM.
Revised: LM.

Original: For example, the prompt we use for extracting co( r , p , q ) is “one’s r ’s p is their < q :mask> ”.
Revised: For example, the prompt we use for extracting co( r , p , q ) is “one’s r ’s p is their < q :mask> ”.

Original: Given that the relations r, p, q ∈ R , DSR-LM automatically enumerates r and p from R while query for LM to unmask the value of q .
Revised: Given that the relations r, p, q ∈ R , DSR-LM automatically enumerates r and p from R while query for LM to unmask the value of q .

Original: LM then returns a distribution of words, which we take an intersection with R .
Revised: LM then returns a distribution of words, which we take an intersection with R .

Original: The probabilities combined form the initial rule weights ϕ .
Revised: The probabilities combined form the initial rule weights ϕ .

Original: This type of rule extraction strategy is different from existing approaches in inductive logic programming, since we are exploiting
Revised: This type of rule extraction strategy is different from existing approaches in inductive logic programming, since we are exploiting

Original: LMs for existing knowledge about relationships.
Revised: LMs for existing knowledge about relationships.

Original: Note that LMs often make simple mistakes answering such prompt.
Revised: Note that LMs often make simple mistakes answering such prompt.

Original: In fact, with the above prompt, even GPT-3 can only produce 62% of composition rules correctly.
Revised: In fact, with the above prompt, even GPT-3 can only produce 62% of composition rules correctly.

Original: While we can edit prompt to include few-shot examples, in this work we consider fine-tuning such rule weights ϕ within our differentiable reasoning pipeline.
Revised: While we can edit prompt to include few-shot examples, in this work we consider fine-tuning such rule weights ϕ within our differentiable reasoning pipeline.

Original: The gradient with respect to ϕ is also derived with the WMC procedure, giving us ∂ ˆ y∂ϕ .
Revised: The gradient with respect to ϕ is also derived with the WMC procedure, giving us ∂ ˆ y∂ϕ .

Original: In practice, we use two optimizers with different hyper-parameters to update the rule weights ϕ and the underlying model parameter θ , in order to account for optimizing different types of weights.
Revised: In practice, we use two optimizers with different hyper-parameters to update the rule weights ϕ and the underlying model parameter θ , in order to account for optimizing different types of weights.

Original: Semantic loss and integrity constraints.
Revised: Semantic loss and integrity constraints.

Original: In general, learning with weak supervision label is hard, not to mention that the deductive rules are learnt as well.
Revised: In general, learning with weak supervision label is hard, not to mention that the deductive rules are learnt as well.

Original: We thereby introduce an additional semantic loss during training.
Revised: We thereby introduce an additional semantic loss during training.

Original: Here, semantic loss is derived by a set of integrity constraints used to regularize the predicted entity-relation graph as well as the learnt logic rules.
Revised: Here, semantic loss is derived by a set of integrity constraints used to regularize the predicted entity-relation graph as well as the learnt logic rules.

Original: In particular, we consider rules that detect violations of integrity constraints.
Revised: In particular, we consider rules that detect violations of integrity constraints.

Original: For example, “if A is B’s father, then B should be
Revised: For example, “if A is B’s father, then B should be

Original: A’s son or daughter” is an integrity constraint for relation extractor—if the model predicts a father  relationship between A and B, then it should alsopredict a son or daughter relationship between Band A.
Revised: A’s son or daughter” is an integrity constraint for relation extractor—if the model predicts a father  relationship between A and B, then it should alsopredict a son or daughter relationship between Band A.

Original: Encoded in first order logic, it is∀ a, b, father ( a, b ) ⇒ ( son ( b, a ) ∨ daughter ( b, a )) .
Revised: Encoded in first order logic, it is∀ a, b, father ( a, b ) ⇒ ( son ( b, a ) ∨ daughter ( b, a )) .

Original: Through differentiable reasoning, we evaluate theprobability of such constraint being violated, yielding our expected semantic loss .
Revised: Through differentiable reasoning, we evaluate theprobability of such constraint being violated, yielding our expected semantic loss .

Original: In practice, arbitrary number of constraints can be included, thoughtoo many interleaving ones could hinder learning.
Revised: In practice, arbitrary number of constraints can be included, thoughtoo many interleaving ones could hinder learning.

Original:  Experiments
Revised:  Experiments

Original: We evaluate DSR-LM on both CLUTRR and
Revised: We evaluate DSR-LM on both CLUTRR and

Original: DBpedia-INF.
Revised: DBpedia-INF.

Original: We show that DSR-LM has accurateand generalizable long-range reasoning capability.
Revised: We show that DSR-LM has accurateand generalizable long-range reasoning capability.

Original: 4. Datasets
Revised: 4. Datasets

Original: CLUTRR (Sinha et al., 2019) consists of kinshipreasoning questions.
Revised: CLUTRR (Sinha et al., 2019) consists of kinshipreasoning questions.

Original: Given a context that describesa family’s routine activity, the goal is to deducethe relationship between two family members thatis not explicitly mentioned in the story.
Revised: Given a context that describesa family’s routine activity, the goal is to deducethe relationship between two family members thatis not explicitly mentioned in the story.

Original: Althoughthe dataset is synthetic, the sentences are crowdsourced and hence there is a considerable amountof naturalness inside the dataset.
Revised: Althoughthe dataset is synthetic, the sentences are crowdsourced and hence there is a considerable amountof naturalness inside the dataset.

Original: The family kinship graph is synthetic and the names of the familymembers are randomized.
Revised: The family kinship graph is synthetic and the names of the familymembers are randomized.

Original: For ablation study, wemanually crafted 92 kinship composition rules asan external symbolic knowledge base.
Revised: For ablation study, wemanually crafted 92 kinship composition rules asan external symbolic knowledge base.

Original: This yieldsthe following symbolic information for each datapoint: 1) the full kinship graph corresponding tothe story, 2) the symbolic knowledge base (KB),and 3) a query representing the question.
Revised: This yieldsthe following symbolic information for each datapoint: 1) the full kinship graph corresponding tothe story, 2) the symbolic knowledge base (KB),and 3) a query representing the question.

Original: The
Revised: The

Original: CLUTRR dataset is divided into different difficulties measured by k , the number of facts used inthe reasoning chain.
Revised: CLUTRR dataset is divided into different difficulties measured by k , the number of facts used inthe reasoning chain.

Original: For training, we only have10K data points with 5K k = 2 and another 5Kk = 3 , meaning that we can only receive supervision on data with short reasoning chains.
Revised: For training, we only have10K data points with 5K k = 2 and another 5Kk = 3 , meaning that we can only receive supervision on data with short reasoning chains.

Original: The testset, on the other hand, contains 1.1K examples withk ∈ { 2 , . .
Revised: The testset, on the other hand, contains 1.1K examples withk ∈ { 2 , . .

Original: DBpedia-INF is a curated subset of the evaluation dataset used in RuleBert (Saeed et al., 2021).
Revised: DBpedia-INF is a curated subset of the evaluation dataset used in RuleBert (Saeed et al., 2021).

Original: Similar to CLUTRR, it is generated syntheticallyto test the reasoning capability of LMs.
Revised: Similar to CLUTRR, it is generated syntheticallyto test the reasoning capability of LMs.

Original: Given asynthetic passage describing the relation betweenentities, and soft deductive logic rules, we aim todeduce the relationship between any two entities.
Revised: Given asynthetic passage describing the relation betweenentities, and soft deductive logic rules, we aim todeduce the relationship between any two entities.

Original: The symbolic program of DBpedia-INF consistsof 26 predicates, 161 soft rules mined from DBpedia, and 16 rules defining the negation and symmetricity between the predicates.
Revised: The symbolic program of DBpedia-INF consistsof 26 predicates, 161 soft rules mined from DBpedia, and 16 rules defining the negation and symmetricity between the predicates.

Original: The difficultyof the questions is represented in terms of reasoning length from k ∈ { 0 , . . .
Revised: The difficultyof the questions is represented in terms of reasoning length from k ∈ { 0 , . . .

Original: 1 Larger k implies harder question.
Revised: 1 Larger k implies harder question.

Original: Compared to the exact dataset used in Rulebert, we clean it in order to ensure the question-answer pairs are logically consistent and probabilistically correct.
Revised: Compared to the exact dataset used in Rulebert, we clean it in order to ensure the question-answer pairs are logically consistent and probabilistically correct.

Original: 4. Experimental Setup
Revised: 4. Experimental Setup

Original: Implementation.
Revised: Implementation.

Original: We employ Scallop (Huang et al., 2021) as the differentiable symbolic inference module.
Revised: We employ Scallop (Huang et al., 2021) as the differentiable symbolic inference module.

Original: We show the program used for
Revised: We show the program used for

Original: CLUTRR reasoning task in Figure 2.
Revised: CLUTRR reasoning task in Figure 2.

Original: It comprises relation type declarations, deductive rules for kinship reasoning, and integrity constraints for computing semantic loss (attached in the Appendix).
Revised: It comprises relation type declarations, deductive rules for kinship reasoning, and integrity constraints for computing semantic loss (attached in the Appendix).

Original: The program used for DBpedia-INF is written in a similar manner with additional high-order predicates listed in Table 2.
Revised: The program used for DBpedia-INF is written in a similar manner with additional high-order predicates listed in Table 2.

Original: Pre-trained LMs for fine-tuning.
Revised: Pre-trained LMs for fine-tuning.

Original: We used the
Revised: We used the

Original: HuggingFace (Wolf et al., 2019) pre-trained w2vgoogle-news-300 , RoBERTa-base, and DeBERTabase as the pretrained language models.
Revised: HuggingFace (Wolf et al., 2019) pre-trained w2vgoogle-news-300 , RoBERTa-base, and DeBERTabase as the pretrained language models.

Original: We finetune RoBERTa-base and DeBERTa-base during training with binary cross entropy loss.
Revised: We finetune RoBERTa-base and DeBERTa-base during training with binary cross entropy loss.

Original: Our relation extraction module is implemented by adding an MLP classifier after the LM, accepting a concatenation of the embedding of the two entities and the embedding of the whole windowed context.
Revised: Our relation extraction module is implemented by adding an MLP classifier after the LM, accepting a concatenation of the embedding of the two entities and the embedding of the whole windowed context.

Original: Our model.
Revised: Our model.

Original: Our main model, DSR-LM, uses
Revised: Our main model, DSR-LM, uses

Original: RoBERTa as the underlying LM.
Revised: RoBERTa as the underlying LM.

Original: The relation classifier is a 2-layer fully connected MLP.
Revised: The relation classifier is a 2-layer fully connected MLP.

Original: For training, we initialize ϕ by prompting the LM.
Revised: For training, we initialize ϕ by prompting the LM.

Original: To accelerate the learning process, we use multinomial sampling to retrieve 150 rules for symbolic reasoning.
Revised: To accelerate the learning process, we use multinomial sampling to retrieve 150 rules for symbolic reasoning.

Original: During testing, we will instead pick the top 150 rules.
Revised: During testing, we will instead pick the top 150 rules.

Original: We use two Adam optimizer to update θ and ϕ , with learning rate 10 − 5 and 10 − 2 respectively.
Revised: We use two Adam optimizer to update θ and ϕ , with learning rate 10 − 5 and 10 − 2 respectively.

Original: For ablation studies, we present a few other models.
Revised: For ablation studies, we present a few other models.

Original: First, we ablate on back-bone LMs.
Revised: First, we ablate on back-bone LMs.

Original: Specifically, we have DSR-LM-DeBERTa which uses DeBERTa as the back-bone LM.
Revised: Specifically, we have DSR-LM-DeBERTa which uses DeBERTa as the back-bone LM.

Original: DSR-w2v-BiLSTM, on the other hand, uses as back-bone the word2vec (Mikolov et al., 2013) model for word embedding and BiLSTM
Revised: DSR-w2v-BiLSTM, on the other hand, uses as back-bone the word2vec (Mikolov et al., 2013) model for word embedding and BiLSTM

Original: (Huang et al., 2015) for sequential encoding.
Revised: (Huang et al., 2015) for sequential encoding.

Original: For DSR-LM-with-Manual-Rule we treat the logic rules to be given, meaning that we provide 92 composition rules for CLUTRR and around rules for DBpedia-INF.
Revised: For DSR-LM-with-Manual-Rule we treat the logic rules to be given, meaning that we provide 92 composition rules for CLUTRR and around rules for DBpedia-INF.

Original: In this case, we set ground
Revised: In this case, we set ground

Original: // Relation declaration type kinship(rela: String, subject: String, object: String) type query(subject: String, object: String) type composite(r1: String, r2: String, r3: String) //
Revised: // Relation declaration type kinship(rela: String, subject: String, object: String) type query(subject: String, object: String) type composite(r1: String, r2: String, r3: String) //

Original: Rules to derive the final answer rel kinship(r3,a,c) = kinship(r1,a,b), kinship(r2,b,c), composite(r1,r2,r3), a !=
Revised: Rules to derive the final answer rel kinship(r3,a,c) = kinship(r1,a,b), kinship(r2,b,c), composite(r1,r2,r3), a !=

Original: c rel answer(r) =
Revised: c rel answer(r) =

Original: query(s, o), derive(r, s, o) //
Revised: query(s, o), derive(r, s, o) //

Original: Integrity constraints (6 for kinship graph and 2 for rule learning) rel violation(!r)
Revised: Integrity constraints (6 for kinship graph and 2 for rule learning) rel violation(!r)

Original: =
Revised: =

Original: r := forall(a, b: kinship(FATHER, a, b) => kinship(SON, b, a) or kinship(DAUGHTER, b, a)) //
Revised: r := forall(a, b: kinship(FATHER, a, b) => kinship(SON, b, a) or kinship(DAUGHTER, b, a)) //

Original: Other constraints are omitted... truth rules to have 1 . 0 weight and therefore ϕ isnot learnt.
Revised: Other constraints are omitted... truth rules to have 1 . 0 weight and therefore ϕ isnot learnt.

Original: Then, we have DSR-LM-without-ICwhich does not have integrity constraints and semantic loss.
Revised: Then, we have DSR-LM-without-ICwhich does not have integrity constraints and semantic loss.

Original: Lastly, we have DSR-without-LM thattakes ground truth structured entity relation graphas input.
Revised: Lastly, we have DSR-without-LM thattakes ground truth structured entity relation graphas input.

Original: This way, we do not need the underlyingrelation extractor and only ϕ needs to be learnt.
Revised: This way, we do not need the underlyingrelation extractor and only ϕ needs to be learnt.

Original: Baselines.
Revised: Baselines.

Original: We compare DSR-LM with a spectrum of baselines from purely neural to logicallystructured.
Revised: We compare DSR-LM with a spectrum of baselines from purely neural to logicallystructured.

Original: The baselines include pretrained largelanguage models (BERT (Kenton and Toutanova,2019) and RoBERTa (Liu et al., 2019)), non-LMcounterparts (BiLSTM (Hochreiter and Schmidhuber, 1997; Cho et al., 2014) and BERT-LSTM),structured models (GAT (Veliˇckovi´c et al., 2018),
Revised: The baselines include pretrained largelanguage models (BERT (Kenton and Toutanova,2019) and RoBERTa (Liu et al., 2019)), non-LMcounterparts (BiLSTM (Hochreiter and Schmidhuber, 1997; Cho et al., 2014) and BERT-LSTM),structured models (GAT (Veliˇckovi´c et al., 2018),

Original: RN (Santoro et al., 2017), and MAC (Hudson and
Revised: RN (Santoro et al., 2017), and MAC (Hudson and

Original: Manning, 2018)), and other neuro-symbolic models (CTP (Minervini et al., 2020), RuleBert (Saeedet al., 2021)).
Revised: Manning, 2018)), and other neuro-symbolic models (CTP (Minervini et al., 2020), RuleBert (Saeedet al., 2021)).

Original: The structured models include thosemodels with relational inductive biases, while theneuro-symbolic model uses logic constraints.
Revised: The structured models include thosemodels with relational inductive biases, while theneuro-symbolic model uses logic constraints.

Original: Baseline setup.
Revised: Baseline setup.

Original: We highlight a few baselines weinclude for completeness but are treated as unfaircomparison to us: GAT, CTP, and GPT-3 variants.
Revised: We highlight a few baselines weinclude for completeness but are treated as unfaircomparison to us: GAT, CTP, and GPT-3 variants.

Original: All baselines other than GAT and CTP take as inputnatural language stories and the question to producethe corresponding answer.
Revised: All baselines other than GAT and CTP take as inputnatural language stories and the question to producethe corresponding answer.

Original: GAT and CTP, on thecontrary, takes entity relation graph rather thannatural language during training and testing.
Revised: GAT and CTP, on thecontrary, takes entity relation graph rather thannatural language during training and testing.

Original: The model sizes are different across baselines aswell.
Revised: The model sizes are different across baselines aswell.

Original: Model size generally depends on two parts,the backbone pre-trained LM, and the classification network built upon the LM.
Revised: Model size generally depends on two parts,the backbone pre-trained LM, and the classification network built upon the LM.

Original: GPT-3 contains175B parameters, and RoBERTa uses 123M parameters.
Revised: GPT-3 contains175B parameters, and RoBERTa uses 123M parameters.

Original: The classification model of our method has2.97M parameters (assuming using embeddingsfrom RoBERTa).
Revised: The classification model of our method has2.97M parameters (assuming using embeddingsfrom RoBERTa).

Original: With extra 10K parameters forrule weights, our DSR-LM framework has around127M parameters.
Revised: With extra 10K parameters forrule weights, our DSR-LM framework has around127M parameters.

Original: For GPT-3 variants, we conduct experiments on
Revised: For GPT-3 variants, we conduct experiments on

Original: CLUTRR with GPT-3 under the Zero-Shot (GPTZS), GPT-3 Fine-Tuned (GPT-3 FT), and Few(5)-
Revised: CLUTRR with GPT-3 under the Zero-Shot (GPTZS), GPT-3 Fine-Tuned (GPT-3 FT), and Few(5)-

Original: Shot (GPT-3 5S) (Brown et al., 2020), as well as
Revised: Shot (GPT-3 5S) (Brown et al., 2020), as well as

Original: Zero-Shot-CoT (GPT-3 ZS-CoT) (Kojima et al., 2022a) settings.
Revised: Zero-Shot-CoT (GPT-3 ZS-CoT) (Kojima et al., 2022a) settings.

Original: For fair comparison, we also include the ground truth kinship composition knowledge in GPT-3 zero shot (GPT-3 ZS w/ Rule), and shot (GPT-3 5S w/ Rule).
Revised: For fair comparison, we also include the ground truth kinship composition knowledge in GPT-3 zero shot (GPT-3 ZS w/ Rule), and shot (GPT-3 5S w/ Rule).

Original: We include the prompts we used and additional details in Appendix A.
Revised: We include the prompts we used and additional details in Appendix A.

Original: [Equation]
Revised: [Equation]

Original: v - B i L S T
Revised: v - B i L S T

Original: M
Revised: M

Original: G P T - 3 Z
Revised: G P T - 3 Z

Original: S
Revised: S

Original: G P T - 

Revised: G P T -

Original: S
Revised: S

Original: G P T - 3 Z
Revised: G P T - 3 Z

Original: S - C o T
Revised: S - C o T

Original: G P TFT
Revised: G P TFT

Original: G P T - 3 Z
Revised: G P T - 3 Z

Original: S w / R u l e
Revised: S w / R u l e

Original: G P T - 

Revised: G P T -

Original: S w / R u l e
Revised: S w / R u l e

Original: R o B E R T a
Revised: R o B E R T a

Original: B E R T
Revised: B E R T

Original: B E R T - L S
Revised: B E R T - L S

Original: T M
Revised: T M

Original: M A C R N
Revised: M A C R N

Original: B i L S T M - M ean B i L S T M - A tt
Revised: B i L S T M - M ean B i L S T M - A tt

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

Original: 4. Experimental Results
Revised: 4. Experimental Results

Original: DSR-LM systematically outperforms a wide range of baselines by a large margin.
Revised: DSR-LM systematically outperforms a wide range of baselines by a large margin.

Original: We evaluate DSR-LM and baselines on both CLUTRR and
Revised: We evaluate DSR-LM and baselines on both CLUTRR and

Original: DBpedia-INF, as reported in Figure 3 and Table 3.
Revised: DBpedia-INF, as reported in Figure 3 and Table 3.

Original: In the CLUTRR experiment, DSR-LM achieves the best performance among all the models (Figure 3).
Revised: In the CLUTRR experiment, DSR-LM achieves the best performance among all the models (Figure 3).

Original: Next, we examine how models trained on stories generated from clauses of length k ≤ 3 and evaluated on stories generated from larger clauses of length k ≥ 4 .
Revised: Next, we examine how models trained on stories generated from clauses of length k ≤ 3 and evaluated on stories generated from larger clauses of length k ≥ 4 .

Original: A fine-grained generalizability study reveals that although all models’ performances decline as the reasoning length of the test sequence increases, pure neural-based models decrease the fastest (Figure 4a and 4b).
Revised: A fine-grained generalizability study reveals that although all models’ performances decline as the reasoning length of the test sequence increases, pure neural-based models decrease the fastest (Figure 4a and 4b).

Original: It manifests the systematic issue that language models alone are still not robust for length generalization (Lake
Revised: It manifests the systematic issue that language models alone are still not robust for length generalization (Lake

Original: [Table]
Revised: [Table]

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

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

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

Original: [Figure]
Revised: [Figure]

Original: and Baroni, 2018).
Revised: and Baroni, 2018).

Original: On the other hand, the performance of DSR-LM decreases much slower as testreasoning length increases and outperforms all thebaselines when k ≥ 4 .
Revised: On the other hand, the performance of DSR-LM decreases much slower as testreasoning length increases and outperforms all thebaselines when k ≥ 4 .

Original: In the DBpedia-INF experiment, DSR-LM outperforms RuleBert by 37% in terms of overall performance (Table 3), showing that DSR-LM hasmuch more robust generalization.
Revised: In the DBpedia-INF experiment, DSR-LM outperforms RuleBert by 37% in terms of overall performance (Table 3), showing that DSR-LM hasmuch more robust generalization.

Original: Recall that RuleBert aims to improve the logical reasoning of LMsby straightforward fine-tuning with soft rules andfacts.
Revised: Recall that RuleBert aims to improve the logical reasoning of LMsby straightforward fine-tuning with soft rules andfacts.

Original: Our results show that augmenting data alonefor fine-tuning do not effectively improve systematicity.
Revised: Our results show that augmenting data alonefor fine-tuning do not effectively improve systematicity.

Original: Meanwhile, DSR-LM imbues reasoninginductive biases throughout training and learns useful rules to generalize to longer reasoning lengths.
Revised: Meanwhile, DSR-LM imbues reasoninginductive biases throughout training and learns useful rules to generalize to longer reasoning lengths.

Original: Learning interpretable logic rules.
Revised: Learning interpretable logic rules.

Original: DSR-LM iscapable of producing explicit logic rules as part ofthe learning process.
Revised: DSR-LM iscapable of producing explicit logic rules as part ofthe learning process.

Original: For presentation, we show thetop-10 rules learnt from DSR-LM model in Table 4.
Revised: For presentation, we show thetop-10 rules learnt from DSR-LM model in Table 4.

Original: We compare the top-92 most likely prompted andfine-tuned rules against the 92 hand-crafted rules,and 70 of them match.
Revised: We compare the top-92 most likely prompted andfine-tuned rules against the 92 hand-crafted rules,and 70 of them match.

Original: Additionally, we find thatour rule weight fine-tuning helps correct 11 of theincorrect rules produced by LM.
Revised: Additionally, we find thatour rule weight fine-tuning helps correct 11 of theincorrect rules produced by LM.

Original: Through this qualitative analysis, it is clear that DSR-LM providesan interface to probe and interpret the intermediate steps, enhancing the interpretability.
Revised: Through this qualitative analysis, it is clear that DSR-LM providesan interface to probe and interpret the intermediate steps, enhancing the interpretability.

Original: GPT-3 variants are inferior in long-range reasoning.
Revised: GPT-3 variants are inferior in long-range reasoning.

Original: Interestingly, ZS scores 28.6% accuracy on CLUTRR while ZS-CoT scores 25.6%, suggesting that the chain-of-thought prompting might not work in long-range reasoning (Figure 3).
Revised: Interestingly, ZS scores 28.6% accuracy on CLUTRR while ZS-CoT scores 25.6%, suggesting that the chain-of-thought prompting might not work in long-range reasoning (Figure 3).

Original: In fact, there are many cases where GPT-3 favors complication over simplicity: GPT-3 frequently answers “stepdaughter”, “stepmother”, and “adopted son”, while the real answers are simply “daughter”, “mother”, and “son”.
Revised: In fact, there are many cases where GPT-3 favors complication over simplicity: GPT-3 frequently answers “stepdaughter”, “stepmother”, and “adopted son”, while the real answers are simply “daughter”, “mother”, and “son”.

Original: Additionally, GPTcould derive the correct result for the wrong reason, e.g. “Jeffrey is Gabrielle’s son, which would make William her grandson, and Jeffrey’s brother.”
Revised: Additionally, GPTcould derive the correct result for the wrong reason, e.g. “Jeffrey is Gabrielle’s son, which would make William her grandson, and Jeffrey’s brother.”

Original: While we count the final answer to be correct (William is Jeffrey’s brother), there is a clear inconsistency in the reasoning chain: William cannot be Gabrielle’s grandson and Jeffrey’s brother simultaneously, given that Jeffrey is Gabrielle’s son.
Revised: While we count the final answer to be correct (William is Jeffrey’s brother), there is a clear inconsistency in the reasoning chain: William cannot be Gabrielle’s grandson and Jeffrey’s brother simultaneously, given that Jeffrey is Gabrielle’s son.

Original: Lastly, we observe that, both GPT-3 FT and many other methods have an accuracy drop as k becomes larger (Figure 4b), ZS and ZS-CoT stay relatively consistent, suggesting that the size of context and the reasoning chain may have a low impact on GPT-
Revised: Lastly, we observe that, both GPT-3 FT and many other methods have an accuracy drop as k becomes larger (Figure 4b), ZS and ZS-CoT stay relatively consistent, suggesting that the size of context and the reasoning chain may have a low impact on GPT-

Original: 3’s performance.
Revised: 3’s performance.

Original: 4. Analyses and Ablation Studies
Revised: 4. Analyses and Ablation Studies

Original: Symbolic reasoner consistently improves LMsand word embeddings.
Revised: Symbolic reasoner consistently improves LMsand word embeddings.

Original: Since DSR-LM hasa model agnostic architecture, we study howthe choice of different LMs impacts the reasoning performance.
Revised: Since DSR-LM hasa model agnostic architecture, we study howthe choice of different LMs impacts the reasoning performance.

Original: As shown in Table 5, thetwo transformer-based models have on-par performance and outperform the word2vec one.
Revised: As shown in Table 5, thetwo transformer-based models have on-par performance and outperform the word2vec one.

Original: However,note that the word2vec-based model still has better performance than all other baselines.
Revised: However,note that the word2vec-based model still has better performance than all other baselines.

Original: Besideshigher final accuracy, the pre-trained transformerbased language model also accelerates the training process.
Revised: Besideshigher final accuracy, the pre-trained transformerbased language model also accelerates the training process.

Original: Both DSR-LM-RoBERTa and DSRLM-DeBERTa reach their best performance within20 epochs, while it takes DSR-w2v-BiLSTM 40epochs to peak.
Revised: Both DSR-LM-RoBERTa and DSRLM-DeBERTa reach their best performance within20 epochs, while it takes DSR-w2v-BiLSTM 40epochs to peak.

Original: [Table]
Revised: [Table]

Original: Incorporate domain knowledge.
Revised: Incorporate domain knowledge.

Original: DSR-LM allows injecting domain specific knowledge.
Revised: DSR-LM allows injecting domain specific knowledge.

Original: In DSRLM-with-Rule, we manually crafted 92 rules forkinship reasoning to replace the learnt rules.
Revised: In DSRLM-with-Rule, we manually crafted 92 rules forkinship reasoning to replace the learnt rules.

Original: Asshown in Table 6, it obtained a 0.36% performancegain over DSR-LM.
Revised: Asshown in Table 6, it obtained a 0.36% performancegain over DSR-LM.

Original: The fact that the improvementis marginal implies our method extracts useful rulesto obtain on-par performance with manually craftedones.
Revised: The fact that the improvementis marginal implies our method extracts useful rulesto obtain on-par performance with manually craftedones.

Original: DSR-LM-without-IC, our model without integrity constraints specified on predicted relationsand rules, performs worse than DSR-LM, suggesting that logical integrity constraints are essentialcomponent for improving the model robustness.
Revised: DSR-LM-without-IC, our model without integrity constraints specified on predicted relationsand rules, performs worse than DSR-LM, suggesting that logical integrity constraints are essentialcomponent for improving the model robustness.

Original: [Table]
Revised: [Table]

Original: The impact of the relation extractor.
Revised: The impact of the relation extractor.

Original: To understand what causes the failure case of DSR-LM, westudy the performance of our relation classificationmodel separately.
Revised: To understand what causes the failure case of DSR-LM, westudy the performance of our relation classificationmodel separately.

Original: We isolate the trained relationextractor and found that it reaches 84.69% accu-
Revised: We isolate the trained relationextractor and found that it reaches 84.69% accu-

Original: [Table]
Revised: [Table]

Original: racy on the single relation classification task.
Revised: racy on the single relation classification task.

Original: For
Revised: For

Original: [Table]
Revised: [Table]

Original: comparison, we train a relation extractor using all
Revised: comparison, we train a relation extractor using all

Original: [Table]
Revised: [Table]

Original: the intermediate labels in the training dataset, and it
Revised: the intermediate labels in the training dataset, and it

Original: [Table]
Revised: [Table]

Original: reaches 85.32% accuracy.
Revised: reaches 85.32% accuracy.

Original: It shows that even using
Revised: It shows that even using

Original: [Table]
Revised: [Table]

Original: only weak supervision (i.e., the final answers to
Revised: only weak supervision (i.e., the final answers to

Original: [Table]
Revised: [Table]

Original: multi-hop questions)
Revised: multi-hop questions)

Original: , our approach can reach on-
Revised: , our approach can reach on-

Original: [Table]
Revised: [Table]

Original: par performance as supervised relation extraction.
Revised: par performance as supervised relation extraction.

Original: [Table]
Revised: [Table]

Original: Reasoning over structured KBs.
Revised: Reasoning over structured KBs.

Original: To understand the rule learning capability of our approach, we de-
Revised: To understand the rule learning capability of our approach, we de-

Original: [Table]
Revised: [Table]

Original: sign our ablation model DSR-without-LM to take
Revised: sign our ablation model DSR-without-LM to take

Original: [Table]
Revised: [Table]

Original: as input ground-truth KBs instead of natural lan-
Revised: as input ground-truth KBs instead of natural lan-

Original: [Table]
Revised: [Table]

Original: guage.
Revised: guage.

Original: In this case, rule weights are not initialized
Revised: In this case, rule weights are not initialized

Original: [Table]
Revised: [Table]

Original: by LM but randomized.
Revised: by LM but randomized.

Original: As shown in Table 7, our model outperforms GAT and CTP which also op-
Revised: As shown in Table 7, our model outperforms GAT and CTP which also op-

Original: [Table]
Revised: [Table]

Original: erates on structured KBs.
Revised: erates on structured KBs.

Original: It demonstrates that our
Revised: It demonstrates that our

Original: [Table]
Revised: [Table]

Original: differentiable rule learning paradigm learns rules
Revised: differentiable rule learning paradigm learns rules

Original: [Table]
Revised: [Table]

Original: to reason about KBs consistently.
Revised: to reason about KBs consistently.

Original: [Table]
Revised: [Table]

Original: Failure cases of DSR-LM.
Revised: Failure cases of DSR-LM.

Original: We showcase in Appendix Table 8 that even state-of-the-art large LMs are prone to logical fallacies.
Revised: We showcase in Appendix Table 8 that even state-of-the-art large LMs are prone to logical fallacies.

Original: On the other hand, the failure case of our method usually occurs in the stage of relation extraction.
Revised: On the other hand, the failure case of our method usually occurs in the stage of relation extraction.

Original: For example, for the following sentence “Christopher and Guillermina are having a father-daughter dance”, our RoBERTa based relation extractor fails to recognize the fatherdaughter relationship but rather thinks C and G have a husband-wife relationship.
Revised: For example, for the following sentence “Christopher and Guillermina are having a father-daughter dance”, our RoBERTa based relation extractor fails to recognize the fatherdaughter relationship but rather thinks C and G have a husband-wife relationship.

Original: We require most of the relation extraction to be correct in order to avoid cascading error.
Revised: We require most of the relation extraction to be correct in order to avoid cascading error.

Original: As the error rate on individual relation extraction accumulates, it leads to the observed drop in accuracy as k becomes larger.
Revised: As the error rate on individual relation extraction accumulates, it leads to the observed drop in accuracy as k becomes larger.

Original:  Concluding Remarks
Revised:  Concluding Remarks

Original: We investigate how to improve LMs’ logical reasoning capability using differentiable symbolic reasoning.
Revised: We investigate how to improve LMs’ logical reasoning capability using differentiable symbolic reasoning.

Original: Through extensive experiments, we demonstrate the effectiveness of DSR-LM over challenging scenarios where widely deployed large LMs fail to reason reliably.
Revised: Through extensive experiments, we demonstrate the effectiveness of DSR-LM over challenging scenarios where widely deployed large LMs fail to reason reliably.

Original: We hope our work can lay the groundwork for exploring neuro-symbolic programming techniques to improve the robustness of
Revised: We hope our work can lay the groundwork for exploring neuro-symbolic programming techniques to improve the robustness of

Original: LMs on reasoning problems.
Revised: LMs on reasoning problems.

Original: Limitations
Revised: Limitations

Original: The primary limitation of DSR-LM is the need for aconfined problem space.
Revised: The primary limitation of DSR-LM is the need for aconfined problem space.

Original: It requires a well-definedrelational schema to perform logical reasoning, andthus will not be suited for an open-ended problemsetup.
Revised: It requires a well-definedrelational schema to perform logical reasoning, andthus will not be suited for an open-ended problemsetup.

Original: Nevertheless, DSR-LM is suitable for manydomain specific problems within Natural Language
Revised: Nevertheless, DSR-LM is suitable for manydomain specific problems within Natural Language

Original: Understanding and Reasoning, allowing domainexperts to freely inject domain-specific knowledgein a structured and logical manner.
Revised: Understanding and Reasoning, allowing domainexperts to freely inject domain-specific knowledgein a structured and logical manner.

Original: Another limitation is the expressiveness of thesymbolic reasoning module we use.
Revised: Another limitation is the expressiveness of thesymbolic reasoning module we use.

Original: As a designchoice, Scallop’s expressiveness based on Datalogis sufficient to solve a variety of deductive reasoning tasks.
Revised: As a designchoice, Scallop’s expressiveness based on Datalogis sufficient to solve a variety of deductive reasoning tasks.

Original: However, reasoning reliably over muchmore complex scenarios like natural language satisfiability (NLSat) (Richardson and Sabharwal, 2021)problems will be much harder for DSR-LM.
Revised: However, reasoning reliably over muchmore complex scenarios like natural language satisfiability (NLSat) (Richardson and Sabharwal, 2021)problems will be much harder for DSR-LM.

Original: Onthat front, one could extend SATNet (Wang et al.
Revised: Onthat front, one could extend SATNet (Wang et al.

Original: ,2019) for it to be combined with LMs in order tosolve satisfiability problems.
Revised: ,2019) for it to be combined with LMs in order tosolve satisfiability problems.

Original: Ethics Statement
Revised: Ethics Statement

Original: In our experimental results, we find a notableethical bias of LMs when prompting GPT-3 using “Myrna is Christopher’s wife.
Revised: In our experimental results, we find a notableethical bias of LMs when prompting GPT-3 using “Myrna is Christopher’s wife.

Original: Guillerminais Christopher’s daughter.” will give the answer“So Guillermina is Myrna’s stepdaughter.”.
Revised: Guillerminais Christopher’s daughter.” will give the answer“So Guillermina is Myrna’s stepdaughter.”.

Original: Theresults imply the historical marriage conditions of
Revised: Theresults imply the historical marriage conditions of

Original: Myrna and Christopher, which might be untruthful or even harmful for users.
Revised: Myrna and Christopher, which might be untruthful or even harmful for users.

Original: DSR-LM holds thepotential to alleviate those biases by leveraginghuman-specified schema to learn logic rules forrobust inference with fact verification, which weleave for future work.
Revised: DSR-LM holds thepotential to alleviate those biases by leveraginghuman-specified schema to learn logic rules forrobust inference with fact verification, which weleave for future work.

Original: A Implementation Details
Revised: A Implementation Details

Original: Hardware.
Revised: Hardware.

Original: We perform all the experiments ona server with two 20-core Intel Xeon CPUs, four
Revised: We perform all the experiments ona server with two 20-core Intel Xeon CPUs, four

Original: GeForce RTX 2080 Ti GPUs, and 768 GB RAM.
Revised: GeForce RTX 2080 Ti GPUs, and 768 GB RAM.

Original: Reasoner details.
Revised: Reasoner details.

Original: The learning of rules andthe fine-tuning of the underlying LM should happen separately with different learning rates – finetuning LM is an intricate process that requires avery small learning rate, while rules should belearned with larger learning rates since gradientsare directly back-propagated onto the weights.
Revised: The learning of rules andthe fine-tuning of the underlying LM should happen separately with different learning rates – finetuning LM is an intricate process that requires avery small learning rate, while rules should belearned with larger learning rates since gradientsare directly back-propagated onto the weights.

Original: Thiscan be realized by employing two separate optimizers, one for fine-tuning and the other for rule learning.
Revised: Thiscan be realized by employing two separate optimizers, one for fine-tuning and the other for rule learning.

Original: During training time, we rotate training thetwo parts by toggling one and the other optimizerfor every 10 batches of data points.
Revised: During training time, we rotate training thetwo parts by toggling one and the other optimizerfor every 10 batches of data points.

Original: Rule learning training setup.
Revised: Rule learning training setup.

Original: For rule learning,we can initialize the transitivity tensor using thelanguage model provided composite rules.
Revised: For rule learning,we can initialize the transitivity tensor using thelanguage model provided composite rules.

Original: Sincethe CLUTRR dataset consists of 20 different relations and a transitivity relationship is defined over3 relations, there are 8K possible transitivity factsover these relations.
Revised: Sincethe CLUTRR dataset consists of 20 different relations and a transitivity relationship is defined over3 relations, there are 8K possible transitivity factsover these relations.

Original: Specifically, we give everypredicted composite rule by the GPT with a 0 .
Revised: Specifically, we give everypredicted composite rule by the GPT with a 0 .

Original: 5weight, while initializing the other rules with arange such as [ 0 , 0 . 1 ] , since otherwise, an insensible transitive fact may be getting a random highweight while it effectively does nothing for reasoning.
Revised: 5weight, while initializing the other rules with arange such as [ 0 , 0 . 1 ] , since otherwise, an insensible transitive fact may be getting a random highweight while it effectively does nothing for reasoning.

Original: The learning process encourages the rulesthat yield the correct query result and suppressesthe rules that lead to wrong answers.
Revised: The learning process encourages the rulesthat yield the correct query result and suppressesthe rules that lead to wrong answers.

Original: To avoid theexponential blow-up caused by injecting all the 8Krules in the reasoning engine, we sample 200 rulesaccording to their weights during the training timeand deterministically use the top 200 learned rulesduring the test time.
Revised: To avoid theexponential blow-up caused by injecting all the 8Krules in the reasoning engine, we sample 200 rulesaccording to their weights during the training timeand deterministically use the top 200 learned rulesduring the test time.

Original: For the QA-No-Rule setup,the confidence score of rules, the MLP classifierfor relation extraction, and the underlying LM arelearned and updated simultaneously during training.
Revised: For the QA-No-Rule setup,the confidence score of rules, the MLP classifierfor relation extraction, and the underlying LM arelearned and updated simultaneously during training.

Original: To account for their difference, we employ two
Revised: To account for their difference, we employ two

Original: Adam optimizers A RL and A RE .
Revised: Adam optimizers A RL and A RE .

Original: A RE is used foroptimizing models for relation extraction, and thuswill take as parameters the MLP classifier and theunderlying LM.
Revised: A RE is used foroptimizing models for relation extraction, and thuswill take as parameters the MLP classifier and theunderlying LM.

Original: It has a low learning rate 0 .
Revised: It has a low learning rate 0 .

Original: 00001since it needs to fine-tune LMs.
Revised: 00001since it needs to fine-tune LMs.

Original: A RL , on the otherhand, will take as a parameter the confidence scoretensor for the transitive rules, and is set to havea higher learning rate of 0 . 001 .
Revised: A RL , on the otherhand, will take as a parameter the confidence scoretensor for the transitive rules, and is set to havea higher learning rate of 0 . 001 .

Original: For the integrityconstraints, we set the result integrity violation losswith the weight 0 .
Revised: For the integrityconstraints, we set the result integrity violation losswith the weight 0 .

Original: 1 , and set the rule integrity constraint violation loss with the weight 0 .
Revised: 1 , and set the rule integrity constraint violation loss with the weight 0 .

Original: We setthe batch size to 16 and train for 20 epochs.
Revised: We setthe batch size to 16 and train for 20 epochs.

Original: To obtain the initial rule weights for the composition rule in our CLUTRR experiment, the prompt we use is “Mary’s P ’s Q is her <mask> .”
Revised: To obtain the initial rule weights for the composition rule in our CLUTRR experiment, the prompt we use is “Mary’s P ’s Q is her <mask> .”

Original: where P and Q are enumerations of all possible relationships, and the unmasked value is treated as the answer
Revised: where P and Q are enumerations of all possible relationships, and the unmasked value is treated as the answer

Original: R , producing composite(P, Q, R) .
Revised: R , producing composite(P, Q, R) .

Original: For the other rule templates we used, the prompts are
Revised: For the other rule templates we used, the prompts are

Original: transitive: “is R ’s R one’s R ? <
Revised: transitive: “is R ’s R one’s R ? <

Original: mask> ”;
Revised: mask> ”;

Original: the probability of the unmasked word be-
Revised: the probability of the unmasked word be-

Original: ing “yes” is treated the rule weight for
Revised: ing “yes” is treated the rule weight for

Original: transitive(R) .
Revised: transitive(R) .

Original: symmetric: “does A is R of B means B is R
Revised: symmetric: “does A is R of B means B is R

Original: of A? <mask> ”; the probability of the un-
Revised: of A? <mask> ”; the probability of the un-

Original: masked word being “yes” is treated the rule
Revised: masked word being “yes” is treated the rule

Original: weight for symmetric(R) .
Revised: weight for symmetric(R) .

Original: inverse: “A is R of B means B is <mask>
Revised: inverse: “A is R of B means B is <mask>

Original: of A”
Revised: of A”

Original: ; the unmasked value is treated as the
Revised: ; the unmasked value is treated as the

Original: answer P , producing inverse(R, P) .
Revised: answer P , producing inverse(R, P) .

Original: 4. implies: “does R imply P ? <
Revised: 4. implies: “does R imply P ? <

Original: mask>”; the probability of unmasked value being “yes” is treated as the rule weight for implies(R,
Revised: mask>”; the probability of unmasked value being “yes” is treated as the rule weight for implies(R,

Original: P) .
Revised: P) .

Original: GPT-3 Prompt Setups.
Revised: GPT-3 Prompt Setups.

Original: For Zero-Shot, we use the prompt “So B is A ’s:” for the query pair ( A, B ) to ask GPT-3 to complete the relationship between A and B .
Revised: For Zero-Shot, we use the prompt “So B is A ’s:” for the query pair ( A, B ) to ask GPT-3 to complete the relationship between A and B .

Original: We pick the phrase in the first line or before the first period from the completed text and compare it directly with the ground truth relation.
Revised: We pick the phrase in the first line or before the first period from the completed text and compare it directly with the ground truth relation.

Original: For the Few(5)-Shot setting, we randomly select 5 examples from the training dataset used for other models ( k ∈ [ 2 , 3 ] ) to serve as examples.
Revised: For the Few(5)-Shot setting, we randomly select 5 examples from the training dataset used for other models ( k ∈ [ 2 , 3 ] ) to serve as examples.

Original: We use the same prompt for Few-Shot and Fine-Tuned as the Zero-Shot and the automated GPT-3 finetuning setup for our training dataset, trained for epochs.
Revised: We use the same prompt for Few-Shot and Fine-Tuned as the Zero-Shot and the automated GPT-3 finetuning setup for our training dataset, trained for epochs.

Original: To add in the transitive KB, we simply include 92 hand-crafted rules in natural language as a part of the prompt, and we performed Zero-shot with KB, and Few(5)-shot with KB experiments.
Revised: To add in the transitive KB, we simply include 92 hand-crafted rules in natural language as a part of the prompt, and we performed Zero-shot with KB, and Few(5)-shot with KB experiments.

Original: For the Zero-Shot-CoT setting, we use the prompt “Who is B to A ?
Revised: For the Zero-Shot-CoT setting, we use the prompt “Who is B to A ?

Original: Let’s think step by step” to suggest GPT-3 to auto-complete while working out a reasoning chain.
Revised: Let’s think step by step” to suggest GPT-3 to auto-complete while working out a reasoning chain.

Original: Under this setup, it is impossible to compare the answer to the ground truth automatically.
Revised: Under this setup, it is impossible to compare the answer to the ground truth automatically.

Original: Therefore, we manually check through the whole test dataset of CLUTRR.
Revised: Therefore, we manually check through the whole test dataset of CLUTRR.

Original: Licenses.
Revised: Licenses.

Original: The CLUTRR dataset is of CC-BYNC 4.0 (Attr Non-Commercial Inter.) license.
Revised: The CLUTRR dataset is of CC-BYNC 4.0 (Attr Non-Commercial Inter.) license.

Original: The
Revised: The

Original: DBpedia-INF is under MIT license.
Revised: DBpedia-INF is under MIT license.

Original: B Additional Experimental Results
Revised: B Additional Experimental Results

Original: In Table 8, we showcase the failure cases of large
Revised: In Table 8, we showcase the failure cases of large

Original: LMs for logical inference, where Zero-shot-CoTdenotes zero-shot chain-of-thoughts (Kojima et al.
Revised: LMs for logical inference, where Zero-shot-CoTdenotes zero-shot chain-of-thoughts (Kojima et al.

Original: ,2022b).
Revised: ,2022b).

Original: [Table]
Revised: [Table]

Original: William
Revised: William

Original: [Table]
Revised: [Table]

Original: help
Revised: help

Original: [Table]
Revised: [Table]

Original: his car next
Revised: his car next

Original: [Table]
Revised: [Table]

Original: party
Revised: party

Original: [Table]
Revised: [Table]

Original: daughter Julia to the park
Revised: daughter Julia to the park

Original: [Table]
Revised: [Table]

Original: Beverly,
Revised: Beverly,

Original: [Table]
Revised: [Table]

Original: them
Revised: them

Original: [Table]
Revised: [Table]

Original: was excited because today she was going to the zoo with her uncle Frank
Revised: was excited because today she was going to the zoo with her uncle Frank

Original: [Table]
Revised: [Table]

Original: a great day shopping with her daughter
Revised: a great day shopping with her daughter

Original: [Table]
Revised: [Table]

Original: Kimberley
Revised: Kimberley

Original: [Table]
Revised: [Table]

Original: Who is Beverly to Jenny
Revised: Who is Beverly to Jenny

Original: [Table]
Revised: [Table]

Original: Melissa and her father, Stephen, went to the marina.
Revised: Melissa and her father, Stephen, went to the marina.

Original: Stephen’s daughter, Margaret, had purchased a boat, and they were eager to see it.
Revised: Stephen’s daughter, Margaret, had purchased a boat, and they were eager to see it.

Original: Annie and her aunt, Evelyn, went to the deli.
Revised: Annie and her aunt, Evelyn, went to the deli.

Original: They got a half a pound of corned beef, and two pounds of salami
Revised: They got a half a pound of corned beef, and two pounds of salami

Original: [Table]
Revised: [Table]

Original: Melissa and her sister Annie were arguing over a toy.
Revised: Melissa and her sister Annie were arguing over a toy.

Original: While they were fighting,
Revised: While they were fighting,

Original: [Table]
Revised: [Table]

Original: grabbed the toy
Revised: grabbed the toy

Original: [Table]
Revised: [Table]

Original: and ran off to play with it by herself.
Revised: and ran off to play with it by herself.

Original: Who is Evelyn to Melissa?
Revised: Who is Evelyn to Melissa?

Original: Let’s do it step by step:
Revised: Let’s do it step by step:

Original: [Table]
Revised: [Table]

Original: fore
Revised: fore

Original: [Table]
Revised: [Table]

Original: Evelyn
Revised: Evelyn

Original: [Table]
Revised: [Table]

Original: his
Revised: his

Original: Davis to the baseball game
Revised: Davis to the baseball game

Original: [Table]
Revised: [Table]

Original: Sharon
Revised: Sharon

Original: Brian went out to lunch together yesterday.
Revised: Brian went out to lunch together yesterday.

Original: Brian and his brother Oliver went to the park to play basketball.
Revised: Brian and his brother Oliver went to the park to play basketball.

Original: Davis played scrabble with his mother Sharon and his brother Oliver.
Revised: Davis played scrabble with his mother Sharon and his brother Oliver.

Original: Davis asked his brother Oliver if he would come help him fix his car next weekend.
Revised: Davis asked his brother Oliver if he would come help him fix his car next weekend.

Original: Who is James to Oliver?
Revised: Who is James to Oliver?

Original: Let’s do it step
Revised: Let’s do it step

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

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

Original: married
Revised: married

Original: [Table]
Revised: [Table]

Original: Faye’s
Revised: Faye’s

Original: [Table]
Revised: [Table]

Original: daughter
Revised: daughter

Original: [Table]
Revised: [Table]

Original: law
Revised: law

Original: [Table]
Revised: [Table]

Original: [Table]
Revised: [Table]

Original: brother so Charles is Christine’s brother
Revised: brother so Charles is Christine’s brother

Original: [Table]
Revised: [Table]

Original: is son so nephew.
Revised: is son so nephew.

Original: [Table]
Revised: [Table]

Original: Christine’s
Revised: Christine’s

Original: [Table]
Revised: [Table]

Original: uncle niece
Revised: uncle niece

Original: [Table]
Revised: [Table]

Original: // question :: (sub, obj) represents a question asking about relation // between ` sub ` and ` obj ` type question(sub: String, obj: String) //
Revised: // question :: (sub, obj) represents a question asking about relation // between ` sub ` and ` obj ` type question(sub: String, obj: String) //

Original: context :: (rela, sub, obj) represents there is a ` rela ` // between ` sub ` and ` obj ` type kinship(rela: usize, sub: String, obj: String) //
Revised: context :: (rela, sub, obj) represents there is a ` rela ` // between ` sub ` and ` obj ` type kinship(rela: usize, sub: String, obj: String) //

Original: Composition rule :: (r1, r2, r3) represents compositing r1 and r2 yields r3 type composite(r1: usize, r2: usize, r3: usize) //
Revised: Composition rule :: (r1, r2, r3) represents compositing r1 and r2 yields r3 type composite(r1: usize, r2: usize, r3: usize) //

Original: Constants used for defining relation properties const DAUGHTER = 0, SISTER = 1, ..., MOTHER_IN_LAW =const MALE = 0, FEMALE =type gender(r: usize, gender_id: i32) rel gender =
Revised: Constants used for defining relation properties const DAUGHTER = 0, SISTER = 1, ..., MOTHER_IN_LAW =const MALE = 0, FEMALE =type gender(r: usize, gender_id: i32) rel gender =

Original: {(DAUGHTER, FEMALE), (SISTER, FEMALE), ..., (MOTHER_IN_LAW, FEMALE)} type gen(r: usize, gen_id: i32)
Revised: {(DAUGHTER, FEMALE), (SISTER, FEMALE), ..., (MOTHER_IN_LAW, FEMALE)} type gen(r: usize, gen_id: i32)

Original: rel gen = {(DAUGHTER, -1), (SISTER, 0), ..., (MOTHER_IN_LAW, 1)} //
Revised: rel gen = {(DAUGHTER, -1), (SISTER, 0), ..., (MOTHER_IN_LAW, 1)} //

Original: Composition rel kinship(r3, x, z) =
Revised: Composition rel kinship(r3, x, z) =

Original: composite(r1, r2, r3), kinship(r1, x, y), kinship(r2, y, z), x !=
Revised: composite(r1, r2, r3), kinship(r1, x, y), kinship(r2, y, z), x !=

Original: z // Answer rel answer(r) =
Revised: z // Answer rel answer(r) =

Original: question(s, o), kinship(r, s, o) //
Revised: question(s, o), kinship(r, s, o) //

Original: Integrity constraints on results
Revised: Integrity constraints on results

Original: rel violation(!r) =
Revised: rel violation(!r) =

Original: r := forall(a, b: kinship(GRANDFATHER, a, b) => (kinship(GRANDSON, b, a) or kinship(GRANDDAUGHTER, b, a)))
Revised: r := forall(a, b: kinship(GRANDFATHER, a, b) => (kinship(GRANDSON, b, a) or kinship(GRANDDAUGHTER, b, a)))

Original: rel violation(!r)
Revised: rel violation(!r)

Original: =
Revised: =

Original: r := forall(a, b: kinship(GRANDMOTHER, a, b) => (kinship(GRANDSON, b, a) or kinship(GRANDDAUGHTER, b, a)))
Revised: r := forall(a, b: kinship(GRANDMOTHER, a, b) => (kinship(GRANDSON, b, a) or kinship(GRANDDAUGHTER, b, a)))

Original: rel violation(!r)
Revised: rel violation(!r)

Original: =
Revised: =

Original: r := forall(a, b: kinship(FATHER, a, b) => (kinship(SON, b, a) or kinship(DAUGHTER, b, a)))
Revised: r := forall(a, b: kinship(FATHER, a, b) => (kinship(SON, b, a) or kinship(DAUGHTER, b, a)))

Original: rel violation(!r)
Revised: rel violation(!r)

Original: =
Revised: =

Original: r := forall(a, b: kinship(MOTHER, a, b) => (kinship(SON, b, a) or kinship(DAUGHTER, b, a)))
Revised: r := forall(a, b: kinship(MOTHER, a, b) => (kinship(SON, b, a) or kinship(DAUGHTER, b, a)))

Original: rel violation(!r)
Revised: rel violation(!r)

Original: =
Revised: =

Original: r := forall(a, b: kinship(HUSBAND, a, b) =
Revised: r := forall(a, b: kinship(HUSBAND, a, b) =

Original: > kinship(WIFE, b, a))
Revised: > kinship(WIFE, b, a))

Original: rel violation(!r)
Revised: rel violation(!r)

Original: =
Revised: =

Original: r := forall(a, b: kinship(BROTHER, a, b) => (kinship(SISTER, b, a) or kinship(BROTHER, b, a))) //
Revised: r := forall(a, b: kinship(BROTHER, a, b) => (kinship(SISTER, b, a) or kinship(BROTHER, b, a))) //

Original: Integrity constraints on rules rel violation(!r) =
Revised: Integrity constraints on rules rel violation(!r) =

Original: r := forall(r1, r2, r3: composite(r1, r2, r3) and gender(r2, g) => gender(r3, g)) rel violation(!r) =
Revised: r := forall(r1, r2, r3: composite(r1, r2, r3) and gender(r2, g) => gender(r3, g)) rel violation(!r) =

Original: r := forall(r1, r2, r3: composite(r1, r2, r3) and gen(r1, g1) and gen(r2, g2) =
Revised: r := forall(r1, r2, r3: composite(r1, r2, r3) and gen(r1, g1) and gen(r2, g2) =

Original: > gen(r3, g1 + g2))
Revised: > gen(r3, g1 + g2))