Paper deep dive
Making Implicit Premises Explicit in Logical Understanding of Enthymemes
Xuyao Feng, Anthony Hunter
Intelligence
Status: succeeded | Model: google/gemini-3.1-flash-lite-preview | Prompt: intel-v1 | Confidence: 95%
Last extracted: 3/13/2026, 12:16:32 AM
Summary
The paper proposes a neuro-symbolic pipeline to decode enthymemes by translating natural language arguments into logical formulas. The pipeline integrates an LLM to generate implicit premises, a text-to-AMR parser, an AMR-to-propositional-logic translator, and a PySAT-based reasoner. It uses word embeddings and NLI models to relax logical constraints, allowing for commonsense reasoning, and demonstrates effectiveness on the ARCT and ANLI datasets.
Entities (6)
Relation Signals (4)
Neuro-symbolic pipeline → evaluateson → ARCT
confidence 95% · We evaluate our pipeline on two enthymeme datasets, demonstrating promising performance
AMR → translatesto → Propositional Logic
confidence 95% · An advantage of AMR is that we can easily transform an AMR graph into first-order logic formulas
Neuro-symbolic pipeline → uses → LLM
confidence 95% · we propose a pipeline that integrates: (1) a large language model (LLM) to generate intermediate implicit premises
Neuro-symbolic pipeline → uses → PySAT
confidence 95% · And (3) a neuro-symbolic reasoner based on a SAT solver to determine entailment.
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Real-world arguments in text and dialogues are normally enthymemes (i.e. some of their premises and/or claims are implicit). Natural language processing (NLP) methods for handling enthymemes can potentially identify enthymemes in text but they do not decode their underlying logic, whereas logic-based approaches for handling them assume a knowledgebase with sufficient formulae that can be used to decode them via abduction. There is therefore a lack of a systematic method for translating textual components of an enthymeme into a logical argument and generating the logical formulae required for their decoding, and thereby showing logical entailment. To address this, we propose a pipeline that integrates: (1) a large language model (LLM) to generate intermediate implicit premises based on the explicit premise and claim; (2) another LLM to translate the natural language into logical formulas; and (3) a neuro-symbolic reasoner based on a SAT solver to determine entailment. We evaluate our pipeline on two enthymeme datasets, demonstrating promising performance in selecting the correct implicit premise, as measured by precision, recall, F1-score, and accuracy.
Tags
Links
- Source: https://arxiv.org/abs/2603.06114v1
- Canonical: https://arxiv.org/abs/2603.06114v1
Trouble viewing inline? Open PDF directly →
Full Text
49,095 characters extracted from source content.
Expand or collapse full text
Making Implicit Premises Explicit in Logical Understanding of Enthymemes Xuyao Feng 1 , Anthony Hunter 1 , 1 Department of Computer Science, University College London, United Kingdom xuyao.feng.20, anthony.hunter@ucl.ac.uk, Abstract Real-world arguments in text and dialogues are nor- mally enthymemes (i.e. some of their premises and/or claims are implicit). Natural language pro- cessing (NLP) methods for handling enthymemes can potentially identify enthymemes in text but they do not decode their underlying logic, whereas logic-based approaches for handling them assume a knowledgebase with sufficient formulae that can be used to decode them via abduction. There is there- fore a lack of a systematic method for translating textual components of an enthymeme into a logi- cal argument and generating the logical formulae required for their decoding, and thereby showing logical entailment. To address this, we propose a pipeline that integrates: (1) a large language model (LLM) to generate intermediate implicit premises based on the explicit premise and claim; (2) another LLM to translate the natural language into logi- cal formulas; and (3) a neuro-symbolic reasoner based on a SAT solver to determine entailment. We evaluate our pipeline on two enthymeme datasets, demonstrating promising performance in selecting the correct implicit premise, as measured by preci- sion, recall, F1-score, and accuracy. 1 Introduction Humans frequently engage in argumentation when con- fronted with conflicting evidence and opinions [ Atkinson et al., 2017 ] . Computational models of argument provide for- mal languages for arguments and counterarguments [ Besnard et al., 2014 ] . However, in the real-world, arguments are often incomplete (i.e., not all the premises or claims are explicit); these arguments are known as enthymemes. For example, for an argument with the claim you should take an umbrella, it may be sufficient to have the premise the weather report pre- dicts rain, and so the logical connection between the premise and claim is implicit. Existing work on enthymemes falls into two categories. The first category uses natural language processing (NLP) to identify and understand enthymemes in textual data [ Haber- nal et al., 2018; Singh et al., 2022; Wei et al., 2023; Sviridova et al., 2025 ] . The second category are symbolic approaches that use abduction to decode enthymemes: iden- tifying missing premises which, when added to the explicit ones, logically entail the claim [ Hunter, 2007; de Saint- Cyr, 2011; Black and Hunter, 2012; Hosseini et al., 2014; Xydis et al., 2020; Panisson et al., 2022; Hunter, 2022; Leiva et al., 2023; Leiva et al., 2025; Ben-Naim et al., 2025; David and Hunter, 2025 ] . For example, given atoms r (the weather report predicts rain) and u (take an umbrella), the premiser is insufficient to entail the claim u (i.e.r⊬ u). This enthymeme can be decoded by adding r → u to the premises to create a valid inference (i.e. r,r → u⊢ u). While the NLP approaches focus on the textual level and do not reconstruct the underlying logic-based argument struc- ture, the symbolic approaches currently assume a sufficiently large set of logical formulas for decoding enthymemes but they do not consider how to obtain these formulas. There- fore, there is a lack of a systematic method to first translate the textual components of a free-text enthymeme into a logi- cal form and then use automated methods to decode it. To address this shortcoming, we propose a neuro-symbolic pipeline that first utilizes an off-the-shelf large language model (LLM) to generate intermediate premises based on the given explicit premise and the claim. For example, for the premise they add a lot to the piece and I look forward to reading comments, and the claim comment sections have not failed, an intermediate premise could be comments sections are a welcome distraction from my work. So we identify inter- mediate premises that with the explicit premises can entail the claim. The rest of the neuro-symbolic pipeline (summarized in Figure 2) is based on translating the text (premises, im- plicit premises, and claim) into logic, and then using neuro- symbolic reasoning to show entailment (using word embed- dings to identity predicates that can be treated as the same and thereby offers a form of commonsense reasoning that is more relaxed than reasoning with propositional logic) and so extends the proposal in [ Feng and Hunter, 2025 ] . We proceed as follows: Section 2 reviews necessary back- ground; Section 3 describes our pipeline; Section 4 describes the datasets and evaluation; Section 5 discusses the results; and Section 6 discusses our contribution. 2 Background This section reviews abstract meaning representation (AMR), and how we can translate it into propositional logic. arXiv:2603.06114v1 [cs.CL] 6 Mar 2026 (w / want-01 (w / want-01 :arg0 (b / boy) :arg0 (b / boy) :arg1 (g / go-01 :arg1 (g / go-01 :arg0 b)) :arg0 b :polarity -)) Figure 1: AMR for the sentence “The boy wants to go.” (left) and “The boy does not want to go.” (right). 2.1 Abstract meaning representation Abstract meaning representation (AMR) is a semantic repre- sentation language for representing sentences as rooted, la- belled, directed, and acyclic graphs (DAGs). AMR is in- tended to assign the same AMR graph to similar sentences, even if they are not identically worded. The approach was first introduced by Langkilde and Knight in 1998 [ Langkilde and Knight, 1998 ] as a derivation from the Penman Sentence Plan Language [ Kasper, 1989 ] . In 2013, AMRs re-gained at- tention due to Banarescu et al. [ Banarescu et al., 2013 ] , and were introduced into NLP tasks such as machine translation and natural language understanding. The modern (post-2010) AMR 1 draws on predicate senses and semantic roles from the OntoNotes project [ Hovy et al., 2006 ] . In AMR, negation is represented via the :polarity relation. For example, Figure 1 represents “The boy does not want to go.” In AMR, the numbers after the instance name (such as want-01 above) denote a particular OntoNotes or PropBank semantic frame [ Kingsbury and Palmer, 2002 ] . These frames have different parameters, but the subject is generally denoted by arg0 and the object by arg1. The parameters, which draw out the semantic roles of the words in the AMR, include location (e.g. “France”), unit (e.g. “kilogrammes”), and time (e.g. “yesterday”). AMR uses the same struc- ture to represent semantically similar texts by making sev- eral simplifying assumptions. AMR cannot represent verb tenses nor distinguish between verbs and nouns. Also it does not represent articles, quote marks, or the singular and plural. Nonetheless, AMR offers a valuable formal abstraction of the meaning of sentences. In our pipeline, we use the IBM Transition AMR parser 2 to load the pre-trained ensemble AMR 3.0 model (AMR3-joint- ontowiki-seed43), which combines smatch-based ensembling techniques with ensemble distillation [ Lee et al., 2021 ] to translate sentence of text into an AMR graph. 2.2 Translation of AMR into Logic An advantage of AMR is that we can easily transform an AMR graph into first-order logic formulas using the Bos al- gorithm [ Bos, 2016 ] which translates each graph into a nested conjunction of atoms, where each monadic atom is a concept and each dyadic atom is relation between a pair of concepts [ Chanin and Hunter, 2023 ] . An example of this is shown be- low, where the AMR for “The boy does not want to go” from 1 https://github.com/amrisi/amr-guidelines 2 https://github.com/IBM/transition-amr-parser/tree/master A set of sentences Prompt an LLM for intermediate implicit premise(s) Text-to-AMR Parser (based on a fine-tuned LLM) AMR-to-Propositional-Logic Translator Relaxation Methods (based on word embeddings and NLI) Automated Reasoner (based on PySAT) Label (entailment and non-entailment) Figure 2: Our neuro-symbolic pipeline where input is a set of natural language sentences (e.g. premise, implicit premises and claim), and the output is a label. Figure 1 is converted into a logical formula as follows. ∃w(∃b(want(w)∧ arg0(w, b)∧ boy(b) ∧¬∃g(arg1(w, g)∧ go(g)∧ arg0(g, b)))) There is an open-source Python library based on the Bos algorithm, the AMR-to-logic converter [ Chanin and Hunter, 2023 ] , to translate AMR graphs into first-order logic. We ex- tended this library, to give our AMR-to-propositional-logic translator, by rewriting each first-order logic formula to a propositional logic formula by grounding out the existentially quantified variables with new constants. We refer to each such propositional formula as an AMR formula. For this, we make the assumption that for each existentially quanti- fied variable, there is a specific entity that can represent the quantified variable. This can be viewed as a Skolem con- stant. We choose each constant symbol for this grounding as follows: For each monadic predicate r(a), we use r as the constant symbol to replace the variable symbol a throughout the formula. This then means the monadic predicates are now redundant and so we delete them. For the above example, the propositional logic formula is simplified as follows. arg0(want, boy)∧ ¬(arg1(want, go)∧ arg0(go, boy)) For our pipeline, we assume the usual definitions for propositional logic. We start with a set of propositional atoms (letters), and we constructed formula in the usual way using the connectives for negation¬, conjunction∧, disjunction∨, implication←, and biconditional↔. 3 Pipeline Our neuro-symbolic pipeline 3 , which is summarized in Fig- ure 2, consists of five main components: An LLM to generate intermediate implicit premises (Section 3.1); A text-to-AMR parser (Section 2.1); An AMR-to-propositional-logic trans- lator (2.2); A set of methods for relaxing the propositional formulas (3.3 and 3.4); And an automated reasoner based on PySAT (3.5). 3 Link to github code suppressed for anonymous reviewing 3.1 Generate implicit premises We use an LLM to generate implicit premises by providing the premise and claim, then requesting one, two, or three, steps of intermediate implicit premises. The intermediate steps are intended to make explicit how the claim follows from the explicit premise (as a form of chain of reasoning [ Wei et al., 2022 ] ). Furthermore, it is intended that as the number of steps is increased, more information is provided for how to show that the claim follows from the premises. The LLM used is DeepSeek v3.2 [ DeepSeek-AI, 2025 ] , and our prompt is presented in the appendix. The implicit premises, like the explicit premises and claims, are natural language statements, and so we use the text-to-AMR parser and the AMR-to-propositional-logic translator to obtain logical for- mulas which we handle in Sections 3.3 and 3.4. For the evaluation (Section 4), the implicit premises gener- ated above are helpful premises. We used the same method to also generate unhelpful premises. So for a premise and claim, the unhelpful premise together with the premise would con- tradict or be neutral with respect to the claim. So for the eval- uation, we had one-, two-, and three-step helpful premises and one-, two-, and three-step unhelpful premises. 3.2 Representing formulas An AMR formula is composed from a set of atoms together with the ¬ and ∧ logical operators. Since each atom is ground, an AMR formula is a propositional logic formula. Definition 1. Let A be a set of AMR atoms (i.e. ground dyadic predicates of the form r(a,b) where a and b are con- stant symbols). The set of AMR formulas, denoted L, is defined inductively as follows: If α ∈ A, then α ∈ L; If α,β ∈L, then α∧ β ∈L; And if α∈L, then¬α∈L. Given a natural language sentence S, our AMR-to- propositional-logic translator identifies an AMR formula φ that represents S. Example 1. The AMR formula ¬arg0(go, car) represents the sentence “the car does not go”. An abstract formula is also a propositional formula. Definition 2. LetP be a set of propositional letters. The set of abstract formulas, denoted F , is defined inductively as follows: If α∈P , then α∈F ; If α,β ∈F , then α∧β ∈F ; And if α∈F , then¬α∈F . If|A| = |P|, then for each α ∈ L, there is a β ∈ F (and vice versa) such that α and β are isomorphic (i.e. they have the same syntax tree except for the atoms associated with the leaves). For example, ¬x 1 is an abstract formula that is iso- morphic to the AMR formula in Example 1. Given an AMR formula, or an abstract formula, denoted φ, let Atoms(φ) denote the set of atoms used in φ. 3.3 Similarity measures In the next two subsections, we explain how we translate each AMR formula into an abstract formula, which we then use with the PySAT automated reasoner. For the translation, we check whether two atoms in an AMR formula can be regarded as equivalent, and therefore mapped to the same propositional letter in the corresponding abstract formula. For this, if for two AMR atoms α and β, the similarity between the two strings of words corresponding to the two atoms is greater than a threshold τ m (as explained below), then we treat them as equivalent (denoted α ≃ β) in the corresponding abstract formula, and so it is a relaxation of the AMR formula. An embedding of a string of words is a vector v obtained by an injective mapping function E. In our pipeline, the E function is the sentence transformer BAAI general embed- ding model bge-small-en-v1.5 [ Xiao et al., 2024 ] (alterna- tives can easily be used) that encodes a string of words as a high dimension vector. The similarity between two embedding vectors v 1 and v 2 is defined as follows, where θ is the angle between the vec- tors, v 1 · v 2 is is dot product between v 1 ,v 2 , and||v 1 || repre- sents the L2 norm. similarity(v 1 ,v 2 ) = cos(θ) = v 1 · v 2 ||v 1 ||||v 2 || To obtain a string of words corresponding to an AMR atom, we created a set of 29 templates. Each template is based on taking the information in a AMR atom in an AMR formula, and representing that information as a natural language sen- tence. Furthermore, each template is designed for a type of AMR atom (i.e. for the predicate name of the atom). For example, for the AMR atom arg0(play, man), the predicate name is arg0, and so can use a template for arg0 such as “[Y] is the agent performing action [X]” which is a string where [X] and [Y] are placeholders for the first and second arguments of the atom (i.e. play and man in this example). So from this template, we can instantiate it using the dyadic atom to get “man is the agent performing action play” as the natural language sentence to be used for the word embedding. In order to do this, we require the following definition. Definition 3. Let φ be an AMR formula, and let r(a,b) be an AMR atom in φ (i.e. r(a,b) ∈ Atoms(φ)). Also let T be a template for r with placeholders [X] and [Y]. The instantiate function, denoted Inst, is defined as follows: Inst(r(a,b),T ) = I , where I is the instantiation of T in which [X] is replaced by a and [Y] is replaced by b. Some examples of templates are below where the AMR predicate name is given in brackets. • (purpose) “[Y] is the purpose of action [X].” • (time) “[Y] is when action [X] takes place.” • (arg1) “[Y] is the object involved in action [X].”. Next, we use the embedding function E to obtain the sen- tence embeddings of the instantiations of templates. Example 2. Let T = “[Y] is the agent performing ac- tion [X].” be the template for AMR predicate name arg0. Therefore, for the AMR atom arg0(play, child), Inst(arg0(play, child),T ) = “child is the agent perform- ing action play.”. For the following definition of a matching relation, we as- sume that one AMR formula refers to a premise and the other refers to a claim. Definition 4. Let AMR formula φ be a premise and AMR formula ψ be a claim, let α∈ Atoms(ψ) be an AMR atom of the form r(a,b), let T 1 be a template for r, let β ∈ Atoms(φ) be an AMR atom of the form q(c,d), let T 2 be a template for q, let τ m ∈ [0, 1] be the neuro-matching threshold, and let E be an embedding function, The neuro-matching relation, denoted≃, is defined as follows α≃ β iff (β,x)∈ Sim(α) and∀(β ′ ,y)∈ Sim(α),x≥ y where Sim(α) =(β ′ ,x) | β ′ ∈ Atoms(φ) and x > τ m and similarity(E(Inst(α,T 1 )), E(Inst(β ′ ,T 2 ))) = x. This definition finds the best match in the premise (if there is one that has a similarity greater than the neuro-matching threshold) for each AMR atom in the claim: So α ≃ β holds when for all the AMR atoms that occur in the premises β 1 ,...,β n , and their similarity scores s 1 ,...,s n , then β is the AMR atom β i for which s i = max(s 1 ,...,s n ). Example 3. Let the text for the premise be “A tiger is walk- ing in the cage.”, and the text for the claim be “A tiger is moving.”, we have the following AMR formulas. arg0(walk, tiger)∧ location(walk, cage) arg0(move, tiger) So arg0(walk, tiger) ≃ arg0(move, tiger), with tem- plate T for arg0, the following similarities, and τ m = 0.6. similarity(E(Inst(arg0(walk, tiger),T )), E(Inst(arg0(move, tiger),T ))) = 0.8483 After identifying the best match for an AMR atom in a claim, we perform a contradiction check on this matched pair using a Natural Language Inference (NLI) model 4 [ Laurer et al., 2023 ] . The NLI model evaluates a pair of sentences (S 1 ,S 2 ) by identifying three scores each in [0,100] inter- val: s Ent (S 1 ,S 2 ) is the degree to which S 2 is entailed by S 1 ; s Con (S 1 ,S 2 ) is the degree of conflict between S 1 and S 2 ; and s Neu (S 1 ,S 2 ) is the degree to which S 1 and S 2 are unrelated. The model returns the label with the highest score (with a random choice in case of a tie). Definition 5. Let S be the set of all natural language sen- tences, and let C = Ent, Con, Neu be the set of outcomes (entailment, contradiction, and neutral). A natural language inference (NLI) function N : S ×S → C is defined as fol- lows with scores s Ent , s Con , and s Neu for a given pair (S 1 ,S 2 ). N(S 1 ,S 2 ) = arg max σ∈C s σ (S 1 ,S 2 ) Definition 6. Let AMR formula φ be a premise and AMR formula ψ be a claim, let α∈ Atoms(ψ) be an AMR atom of the form r(a,b), let T 1 be a template for r, let β ∈ Atoms(φ) be an AMR atom of the form q(c,d), let T 2 be a template for q, let N be an NLI model, and let τ c ∈ [0, 100] be the neuro- contradict threshold. The neuro-contradict relation ⊥ is defined as follows α⊥ β iffN(Inst(α,T 1 ), Inst(β,T 2 )) = Con and s Con (Inst(α,T 1 ), Inst(β,T 2 ))≥ τ c 4 mDeBERTa-v3-base-xnli-multilingual-nli-2mil7 Example 4. Let the text for the premise be “A tiger is walk- ing in the cage.”, and the text for the claim be “The tiger is sleeping in the cage.”, we have the following AMR formulas. arg0(walk, tiger)∧ location(walk, cage) arg0(sleep, tiger)∧ location(sleep, cage) When τ c = 80, arg0(walk, tiger)⊥ arg0(sleep, tiger), and location(walk, cage) ⊥ location(sleep, cage) hold, assuming the following given the templates T 1 and T 2 for arg0 and location respectively. N(Inst(arg0(walk, tiger),T 1 ), Inst(arg0(sleep, tiger),T 1 )) = Con s Con (Inst(arg0(walk, tiger),T 1 ), Inst(arg0(sleep, tiger),T 1 )) = 85 N(Inst(location(walk, cage),T 2 ), Inst(location(walk, cage),T 2 )) = Con s Con (Inst(location(walk, cage),T 2 ), Inst(location(walk, cage),T 2 )) = 82 In general, the≃ and⊥ relations are reflexive but not sym- metric. 3.4 Translating AMR into abstract formulas We now consider how we can translate each AMR formula into an abstract formula. The first aim is to represent each AMR atom by an abstract atom of the form x i in order to facilitate use by a PySAT solver, and the second aim is to take advantage of the neuro-matching and neuro-contradict relations to simplify and constrain the abstract formula. For example, if we have a premise x 1 ∧x 2 ∧x 3 and a claim x 1 ∧x 4 and x 3 and x 4 are very similar concepts, then we can change the claim to x 1 ∧x 3 , and then show entailment holds using the CNF versions of these relaxed formulas with PySAT. Simi- larly, if we a premise x 5 ∧ x 6 and a claim x 7 , and the x 5 ⊥x 7 relationship holds, then we can change the claim to¬x 5 . Definition 7. Given a set of AMR formulas Φ, and a set of neuro-matching and neuro-contradict relationships Ψ, the function g : A → P ∪¬x | x ∈ P is a mapping for Φ and Ψ iff for all φ,φ ′ ∈ Φ, for all α ∈ Atoms(φ), for all β ∈ Atoms(φ ′ ), (1) α ≃ β ∈ Ψ iff g(α) = g(β); and (2) α⊥ β ∈ Ψ iff g(α) =¬g(β). For tautology⊤, g(⊤) =⊤. The above definition ensures that if there are similar atoms, according to≃, (resp. contradictory atoms, according to⊥), then they are translated to the same atom (resp. complemen- tary literals) in the abstract formulas. Example 5. Let φ 1 = arg1(car, red)∧ arg2(car, fast) and φ 2 = arg1(car, red).Let Φ= φ 1 ,φ 2 . A mapping g for Φ is g(arg1(car, red)) = x 1 and g(arg2(car, fast)) = x 2 . Example 6. Continuing Example 3, g(arg0(walk, tiger)) = g(arg0(move, tiger) = x 1 g(location(walk, cage)) = x 2 Example 7. Continuing Example 4, g(arg0(sleep, tiger)) =¬g(arg0(walk, tiger) =¬x 1 g(location(sleep, cage)) = ¬g(location(walk, cage)) =¬x 2 Next we specify how an AMR formula is translated into an abstract formula using a mapping function. Definition 8. Let g be a mapping for a set of AMR for- mula Φ and a set of neuro-matching and neuro-contradict relationships Ψ.For φ ∈ Φ, a translation of φ is Tran g (φ) where Tran g is defined as: (1) Tran g (α ∧ β) = Tran g (α) ∧ Tran g (β); (2) Tran g (¬α) = ¬Tran g (α); And (3) Tran g (α) = g(α) when α ∈ A. For Φ, let Tran g (Φ) = Tran g (φ)| φ∈ Φ. Example 8. Continuing Example 5, a translation of φ 1 is x 1 ∧ x 2 and φ 2 is x 1 . So use of embeddings and NLI allow for identification of neuro-matching and neuro-contradict relations, which can then be used to rewrite AMR formulas into abstract formu- las, where the latter are relaxations of the former. So our relaxation methods rewrite the AMR formulas (output from the AMR-to-propositional-logic translator) into abstract for- mulas for use in automated reasoning as described next. 3.5 Automated Reasoning For the automated reasoning, we transform all the abstract formulas (from the previous section) into conjunctive normal form (CNF) using SymPY [ Meurer et al., 2017 ] . Then, we use PySAT [ Ignatiev et al., 2018 ] , which integrates several widely used state-of-the-art SAT solvers as theorem provers to check whether a CNF is consistent. The aim of our pipeline is to identify the relationship be- tween a premise φ (which may be a conjunction of explicit premise and one or more intermediate premises) and a claim ψ. To prove whether φ entails ψ, we need to determine whetherφ⊢ ψ holds. This is equal to determining whether φ∧¬ψ is inconsistent. To do this, we need to change φ∧¬ψ into a CNF formula, and then we can directly use PySAT to check consistency. Similarly, to prove whether φ contradicts ψ, we need to determine whether φ,ψ ⊢⊥ holds. To do this, we need to change φ∧ ψ into a CNF formula, and then we can directly use PySAT to check consistency. 4 Datasets and Evaluation To evaluate our pipeline, we used two datasets (ARCT and ANLI) which we describe next. ARCT The Argument Reasoning Comprehension Task dataset (ARCT) is a benchmark dataset designed to evaluate the ability of an NLP model to identify the implicit reason- ing (warrant) connecting a claim to its supporting premise [ Habernal et al., 2018 ] . Each data instance consists of a claim, a premise, two candidate implicit premises, where one is helpful (correct) and one is unhelpful (incorrect), and a bi- nary label indicating which is the helpful premise. The task requires selecting which premise correctly justifies why the premise supports the claim. ANLI The Abductive Natural Language Inference dataset (ANLI), an Abductive Commonsense Reasoning challenge, evaluates the ability of an NLP model to use abductive rea- soning for inferring the most plausible explanation given in- complete observations [ Bhagavatula et al., 2019 ] . Each in- stance presents an incomplete story beginning with two ob- PremiseThey add a lot to the piece and I look for- ward to reading comments. ClaimComment sections have not failed. HelpfulComments sections are a welcome distrac- tion from my work. UnhelpfulComments sections always distract me from my work. Table 1: An example from the ARCT dataset PremiseJane was a professor teaching piano to stu- dents. ClaimJane spent the morning sipping coffee and reading a book. HelpfulNone of Jane’s students had a lesson that day. UnhelpfulTwo of Jane’s students were early for their lessons. Table 2: An example from the ANLI dataset servations (O1 and O2 s.t. O2 happens after O1) and pro- vides two possible hypotheses (H1 and H2) that bridge the narrative gap. The task is to select the hypothesis that gives the most coherent/plausible explanation for the events. We treat O1 (resp. O2) as the explicit premise (resp. claim), and treat the most coherent/plausible explanation (resp. the other explanation) as the helpful (resp. unhelpful) implicit premise. Because our pipeline allows for the use of multiple steps of (helpful) intermediate premises, we needed to augment the ARCT and ANLI datasets (using the generation method presented in Section 3.1) to generate one-, two-, and three- steps, of helpful and unhelpful premises. So when we evalu- ated our pipeline, we suspended the first step of the pipeline, and just used the implicit premises in the augmented dataset (either the helpful premises or the unhelpful premises being used with the explicit premises when determining whether the claim is entailed). To evaluate the performance of our pipeline, we trans- formed the datasets into data with a binary classification. Each data example was transformed into two individual data points: one was the premise combined with the helpful im- plicit premise and the claim with a gold label indicating en- tailment, and the other was the premise combined with the unhelpful implicit premise and the claim with a gold label in- dicating non-entailment. For example, given the example in Table 2 we obtained two data points as follows: • (Premise) Jane was a professor teaching piano to stu- dents; (Implicit premise) None of Jane’s students had a lesson that day; (Claim) Jane spent the morning sipping coffee and reading a book; (Label) Entailment. • (Premise) Jane was a professor teaching piano to stu- dents; (Implicit premise) Two of Jane’s students were early for their lessons; (Claim) Jane spent the morn- ing sipping coffee and reading a book; (Label) Non- entailment. We used this transformed data in our neuro-symbolic DatasetClassStep typeBest F1 τ m τ c ANLI 0 original0.670.880 1-step0.720.680 2-step0.730.580 3-step0.750.680 1 original0.440.55100 1-step0.570.5590 2-step0.640.6100 3-step0.670.5580 ARCT 0 original0.670.6580 1-step0.710.780 2-step0.710.7580 3-step0.740.790 1 original0.190.680 1-step0.440.6590 2-step0.530.690 3-step0.590.6590 Table 3: Best F1-Score and by Dataset, Class (non-entailment is 0 and entailment is 1), and Step type (where original means that the helpful/unhelpful intermediate premises given in the dataset, 1- (resp. 2- and 3-) step means using the response from prompting the LLM for one (resp. two and three) steps of helpful/unhelpful intermediate premises. Step typeANLI datasetARCT dataset none0.5300.293 original0.5580.303 1-step0.6450.478 2-step0.6730.518 3-step0.7330.563 Table 4: Accuracy for entailment with different options for dealing with implicit premises where none means no intermediate premises were used, original means that the helpful intermediate premise given in the dataset, and 1- (resp. 2- and 3-) step means using the re- sponse from prompting the LLM for one (resp. two and three) steps of intermediate premises. pipeline, where φ was the logical formula of the conjunc- tion of the premise and implicit premise(s), and ψ was the logical formula of the claim. Thus, entailment (resp. non- entailment) meant the prediction was entailment (resp. either contradiction or neutral). 5 Results For each dataset, we investigated how performance changed with different neuro-matching thresholds τ m from 0.5 to 1, and three different neuro-contradict thresholds τ c (viz. 80, 90, and 100). We randomly selected 200 data items from each dataset, giving a total of 400 items, with 200 for each class, for the original one-step (from the datasets), and one-, two-, and three-step (from the augmented datasets) separately. Figure 3 shows the overall performance of our pipeline. Here, we see that the multi-step (especially 3-step) implicit premises yield the highest accuracy at moderate τ m values 0.50.550.60.650.70.750.8 0.5 0.6 0.7 Neuro-Matching Threshold (τ m ) Accuracy Performance with the ANLI dataset 0.50.550.60.650.7 0.750.8 0.5 0.6 0.7 Neuro-Matching Threshold (τ m ) Accuracy Performance with the ARCT dataset original (τ c = 80)original (τ c = 90) original (τ c = 100)1-step (τ c = 80) 1-step (τ c = 90)1-step (τ c = 100) 2-step (τ c = 80)2-step (τ c = 90) 2-step (τ c = 100)3-step (τ c = 80) 3-step (τ c = 90)3-step (τ c = 100) Figure 3: Overall accuracy (entailment and non-entailment) for dif- ferent options for the implicit premises for the ANLI and ARCT datasets. Original means that the helpful/unhelpful intermediate premises given in the dataset, One- (resp. Two- and Three-) step means using the response from prompting the LLM for one (resp. two and three) steps of helpful/unhelpful intermediate premises. (0.55–0.65). We also see that this is consistent across both datasets, with the choice of τ c significantly modulating this result, especially at lower τ m thresholds. A lower τ c (e.g., 80) makes the model more sensitive to potential contradic- tions, allowing it to correctly classify more non-entailment cases at the cost of potentially misclassifying some true en- tailments, which is why it often yields the highest peak ac- curacy. Conversely, a higher τ c (100) requires near-certainty for identifying contradiction, making the pipeline more con- servative; this often results in a lower accuracy curve, as seen in the ARCT dataset where the results for τ c = 100 consis- Implicit Premise A: Torn webs re- sult from trapped prey escaping. arg1(result, escape) ∧ arg0(escape, prey)∧ arg1(trap, prey)∧ arg2(result, web) ∧ arg1(tear, web) Implicit Premise B: Small insect fled. arg0(flee, small insect) Implicit Premise C: Wind tears a spiderweb. arg1(tear, spiderweb)∧ arg0(wing, tear) Claim: A large insect escaped recently. arg0(escape, large insect)∧ time(escape, recent) Premise: The spiderweb is torn. arg1(tear, spiderweb) Support arg0(escape, large insect) ≃ arg0(escape, prey) time(escape, recent) ≃ arg0(escape, prey) Contradict arg0(escape, large insect) ⊥ arg0(flee, small insect) Neutral Neutral Figure 4: A structured argument graph analyzing possible causes for a torn spiderweb. The claim suggests a large insect escaped recently, which is supported by Implicit Premise A (relating torn webs to prey escape) but contradicted by Implicit Premise B (small insect fled). Implicit Premise C (environmental damage) and the premise alone (torn web) remain neutral to the claim. The labels on the arcs show neuro-matching relations that hold for the support relation, and the neuro-contradiction relation that holds for the contradiction relation. In this example, Implicit Premise A together with the neuro-matching relation provides the decoding of the enthymeme. So adding the AMR formulae for the Implicit Premise A to the AMR formulae for the Premise, plus the neuro-matching relations, entails the claim. The black arrow from the Premise to a implicit premise denotes the combination of the Premise and implicit premise. tently under-perform those for lower τ c values. This effect is most pronounced in the ANLI dataset, where the perfor- mance spread between different τ c values for the same step count is substantial, indicating the inherent ambiguity in the dataset benefits from a tuned contradiction detection mecha- nism, whereas the more well-defined structure in the ARCT dataset shows less sensitivity to τ c variations. In general, τ c acts as a crucial second tuning parameter (in addition to τ m ) that manages the trade-off between recall of entailment and precision of non-entailment, with an optimal balance typi- cally found at τ c = 80 or 90 for maximizing overall accu- racy. Table 3 summarizes the best F1-scores for each class and each number of implicit premises for the two datasets. Full F1-scores data is in the Appendix. To investigate how the accuracy of entailment changes with different implicit premises, starting from no implicit premise, then moving to helpful premises from the dataset, followed by our one-, two-, and three-step implicit premises. We set the parameters for both datasets based on the results mentioned above. For the ANLI dataset, we set τ m = 0.55 and τ c = 90; for the ARCT dataset, we set τ m = 0.65 and τ c = 90. We randomly selected 400 data items labeled as entailment from the two datasets. Table 4 shows entailment accuracy across both datasets shows a clear improvement as the number of steps in implicit premises increases. The one-step implicit premises generated by the LLM exhibit better accuracy than the original one-step implicit premises from the two datasets. This trend highlights the critical role of multi-step reasoning in enhancing pipeline performance on entailment tasks, with performance on the ANLI dataset generally achieving higher accuracy than on the ARCT dataset across all conditions, sug- gesting inherent differences in dataset difficulty. 6 Discussion This is the first proposal for translating textual arguments into logical arguments that incorporates a method for ob- taining the implicit formulae required for logical decoding of enthymemes. We evaluated our pipeline on a relatively complex datasets with significant implicitness. It achieved a balanced precision-recall performance on the entailment/non- entailment tasks and with the distinct benefit that our pipeline provides an explicit decoding of enthymemes. Using our pipeline, we can provide a graphical representa- tion of possible decodings, as illustrated in Figure 4. We can see the relaxations that have been assumed (neuro-matching relations and contradict neuro-matching relation), the user can then judge whether the relaxations are reasonable from a commonsense perspective. In this example, for the sup- port arc, the two neuro-matching relations were sufficient for showing that the abstract formula representing Implicit Promise A is sufficient for entailing the Claim. Similarly, for the contradict arc, the neuro-contradict relation is sufficient for showing that the abstract formula representing Implicit Premise B is sufficient for contradicting the Claim. Note, in general, a contradict arc does not necessarily require neuro- contradict arcs. In some examples, neuro-matching relation- ships, or both types of relationships, may be required. In future work, we will investigate the use of syntactic sugar to improve the presentation of the logical formulas in structured enthymeme graphs. Also, in future work, we will investigate using automated reasoning methods for further types of analysis of the logical arguments and counterargu- ments such as types of support between arguments, relevance of arguments [ Black and Hunter, 2012 ] , or degree of similar- ity between arguments [ Amgoud and David, 2021 ] . References [ Amgoud and David, 2021 ] LeilaAmgoudandVictor David. Similarity measures based on compiled arguments. In Proceedings of ECSQARU’21, volume 12897 of LNCS, pages 32–44. Springer, 2021. [ Atkinson et al., 2017 ] Katie Atkinson, Pietro Baroni, Mas- similiano Giacomin, Anthony Hunter, Henry Prakken, Chris Reed, Guillermo Ricardo Simari, Matthias Thimm, and Serena Villata. Towards artificial argumentation. AI Magazine, 38(3):25–36, 2017. [ Banarescu et al., 2013 ] Laura Banarescu, Claire Bonial, Shu Cai, Madalina Georgescu, Kira Griffitt, Ulf Herm- jakob, Kevin Knight, Philipp Koehn, Martha Palmer, and Nathan Schneider. Abstract Meaning Representation for sembanking. In Proceedings of the 7th Linguistic An- notation Workshop and Interoperability with Discourse, pages 178–186. Association for Computational Linguis- tics, 2013. [ Ben-Naim et al., 2025 ] Jonathan Ben-Naim, Victor David, and Anthony Hunter. An Axiomatic Study of a Modular Evaluation of Enthymeme Decoding in Weighted Struc- tured Argumentation. In Proceedings of KR’25, pages 110–120, 10 2025. [ Besnard et al., 2014 ] Philippe Besnard, Alejandro Gar- cia, Anthony Hunter, Sanjay Modgil, Henry Prakken, Guillermo Simari, and Francesca Toni. Introduction to structured argumentation.Argument & Computation, 5(1):1–4, 2014. [ Bhagavatula et al., 2019 ] Chandra Bhagavatula, Ronan Le Bras, Chaitanya Malaviya, Keisuke Sakaguchi, Ari Holtz- man, Hannah Rashkin, Doug Downey, Scott Wen-tau Yih, and Yejin Choi. Abductive commonsense reasoning. CoRR, abs/1908.05739, 2019. [ Black and Hunter, 2012 ] Elizabeth Black and Anthony Hunter. A relevance-theoretic framework for construct- ing and deconstructing enthymemes. Journal of Logic and Computation, 22(1):55–78, 2012. [ Bos, 2016 ] Johan Bos. Squib: Expressive power of Ab- stract Meaning Representations. Computational Linguis- tics, 42(3):527–535, September 2016. [ Chanin and Hunter, 2023 ] David Chanin and Anthony Hunter. Neuro-symbolic commonsense social reasoning. arXiv preprint arXiv:2303.08264, 2023. [ David and Hunter, 2025 ] Victor David and Anthony Hunter. A logic-based framework for decoding enthymemes in argument maps involving implicitness in premises and claims. In Proceedings of IJCAI’25, pages 4445–4453. IJCAI Organization, 2025. [ de Saint-Cyr, 2011 ] Florence Dupin de Saint-Cyr. Handling enthymemes in time-limited persuasion dialogs. In Pro- ceedings of SUM’11, volume 6929 of LNCS, pages 149– 162. Springer, 2011. [ DeepSeek-AI, 2025 ] DeepSeek-AI. Deepseek-v3.2: Push- ing the frontier of open large language models, 2025. [ Feng and Hunter, 2025 ] Xuyao Feng and Anthony Hunter. Formalizing simple natural language arguments using ab- stract meaning representation and approximate proposi- tional reasoning. In Proceedings of ICTAI’25. IEEE Press, 2025. [ Habernal et al., 2018 ] Ivan Habernal, Henning Wachsmuth, Iryna Gurevych, and Benno Stein. The argument rea- soning comprehension task: Identification and reconstruc- tion of implicit warrants. In Proceedings of NAACL’18, pages 1930–1940. Association for Computational Linguis- tics, 2018. [ Hosseini et al., 2014 ] S. Hosseini, S. Modgil, and O. Ro- drigues.Enthymeme construction in dialogues using shared knowledge. In Proceedings of COMMA’14, vol- ume 266 of FAIA, pages 325–332. IOS Press, 2014. [ Hovy et al., 2006 ] Eduard Hovy, Mitchell Marcus, Martha Palmer,Lance Ramshaw,and Ralph Weischedel. OntoNotes:The 90% solution.In Proceedings of NAACL’06, pages 57–60. Association for Computational Linguistics, 2006. [ Hunter, 2007 ] Anthony Hunter. Real arguments are approx- imate arguments. In Proceedings of AAAI’07, page 66–71. AAAI Press, 2007. [ Hunter, 2022 ] Anthony Hunter.Understanding en- thymemes in deductive argumentation using semantic distance measures.In Proceedings of AAAI’22, pages 5729–5736. AAAI Press, 2022. [ Ignatiev et al., 2018 ] Alexey Ignatiev, Antonio Morgado, and Joao Marques-Silva. PySAT: A Python toolkit for pro- totyping with SAT oracles. In Proceedings of SAT’18, vol- ume 10929 of LNCS, pages 428–437. Springer, 2018. [ Kasper, 1989 ] Robert T. Kasper. A flexible interface for linking applications to Penman’s sentence generator. In Proceedings of a Workshop: Speech and Natural Lan- guage, 1989. [ Kingsbury and Palmer, 2002 ] Paul Kingsbury and Martha Palmer. From TreeBank to PropBank. In Proceedings of LREC’02. European Language Resources Association (ELRA), 2002. [ Langkilde and Knight, 1998 ] Irene Langkilde and Kevin Knight. Generation that exploits corpus-based statistical knowledge. In Proceedings of COLING’98, pages 704– 710. Association for Computational Linguistics, 1998. [ Laurer et al., 2023 ] Moritz Laurer, Wouter Van Atteveldt, Andreu Casas, and Kasper Welbers. Less annotating, more classifying: Addressing the data scarcity issue of super- vised machine learning with deep transfer learning and BERT-NLI. Political Analysis, pages 1–33, June 2023. [ Lee et al., 2021 ] Young-Suk Lee, Ram ́ on Fernandez As- tudillo, Thanh Lam Hoang, Tahira Naseem, Radu Florian, and Salim Roukos. Maximum bayes smatch ensemble dis- tillation for AMR parsing. CoRR, abs/2112.07790, 2021. [ Leiva et al., 2023 ] Diego S. Orbe Leiva, Sebastian Got- tifredi, and Alejandro J. Garc ́ ıa. Automatic knowledge generation for a persuasion dialogue system with en- thymemes. International Journal of Approximate Reason- ing, 160:108963, 2023. [ Leiva et al., 2025 ] Diego S. Orbe Leiva, Alejandro Javier Garc ́ ıa, and Sebastian Gottifredi. Principles for assump- tions generation in enthymeme-based dialogue. Journal of Artificial Intelligence Research, 83, 2025. [ Meurer et al., 2017 ] Aaron Meurer, Christopher P. Smith, Mateusz Paprocki, Ond ˇ rej ˇ Cert ́ ık, Sergey B. Kirpichev, Matthew Rocklin, Amit Kumar, Sergiu Ivanov, Jason K. Moore, Sartaj Singh, Thilina Rathnayake, Sean Vig, Brian E. Granger, Richard P. Muller, Francesco Bonazzi, Harsh Gupta, Shivam Vats, Fredrik Johansson, Fabian Pedregosa, Matthew J. Curry, Andy R. Terrel, ˇ St ˇ ep ́ an Rou ˇ cka, Ashutosh Saboo, Isuru Fernando, Sumith Kulal, Robert Cimrman, and Anthony Scopatz. Sympy: symbolic computing in python. PeerJ Computer Science, 3:e103, January 2017. [ Panisson et al., 2022 ] Alison R. Panisson, Peter McBurney, and Rafael H. Bordini. Towards an Enthymeme-Based Communication Framework in Multi-Agent Systems. In Proceedings of KR’22, pages 267–277, 2022. [ Singh et al., 2022 ] Keshav Singh,Naoya Inoue,Far- jana Sultana Mim, Shoichi Naito, and Kentaro Inui. IRAC: A domain-specific annotated corpus of implicit reasoning in arguments. In Proceedings of LREC’22, pages 4674– 4683. European Language Resources Association, 2022. [ Sviridova et al., 2025 ] Ekaterina Sviridova, Elena Cabrio, and Serena Villata.Mining implicit arguments for reasoning:A survey.Argument & Computation, 0(0):19462174251344764, 2025. [ Wei et al., 2022 ] Jason Wei, Xuezhi Wang, Dale Schuur- mans, Maarten Bosma, brian ichter, Fei Xia, Ed H. Chi, Quoc V Le, and Denny Zhou. Chain of thought prompting elicits reasoning in large language models. In Advances in Neural Information Processing Systems, 2022. [ Wei et al., 2023 ] Kaiwen Wei, Xian Sun, Zequn Zhang, Li Jin, Jingyuan Zhang, Jianwei Lv, and Zhi Guo. Im- plicit event argument extraction with argument-argument relational knowledge. IEEE Transactions on Knowledge and Data Engineering, 35(9):8865–8879, 2023. [ Xiao et al., 2024 ] Shitao Xiao, Zheng Liu, Peitian Zhang, Niklas Muennighoff, Defu Lian, and Jian-Yun Nie. C- pack: Packed resources for general chinese embeddings. In Proceedings of SIGIR’24, page 641–649. Association for Computing Machinery, 2024. [ Xydis et al., 2020 ] A. Xydis, C. Hampson, S. Modgil, and E. Black. Enthymemes in dialogues. In Proceedings of COMMA’20, volume 326 of FAIA, pages 395–402. IOS Press, 2020. Appendix In this appendix, we provide the following. • F1 scores with the ANLI dataset (Figure 5). • Recall with the ANLI dataset (Figure 6). • Precision with the ANLI dataset (Figure 7). • F1 scores with the ARCT dataset (Figure 8). • Recall with the ARCT dataset (Figure 9). • Precision with the ARCT dataset (Figure 10). • Prompt for generating helpful and unhelpful chains of reasoning (Figure 11). 0.50.550.60.650.70.750.8 0.5 0.6 0.7 0.8 Neuro-Matching Threshold (τ m ) F1-Score F1-Score for Class 0 by Different Steps of Implicit Premise 0.50.550.60.650.70.750.8 0 0.2 0.4 0.6 Neuro-Matching Threshold (τ m ) F1-Score F1-Score for Class 1 by Different Steps of Implicit Premise original (τ c = 80)original (τ c = 90) original (τ c = 100)1-step (τ c = 80) 1-step (τ c = 90)1-step (τ c = 100) 2-steps (τ c = 80)2-steps (τ c = 90) 2-steps (τ c = 100)3-steps (τ c = 80) 3-steps (τ c = 90)3-steps (τ c = 100) Figure 5: F1-score by Different Steps of Implicit Premise of the ANLI dataset 0.50.550.60.650.70.750.8 0.5 0.6 0.7 0.8 0.9 1 Neuro-Matching Threshold (τ m ) Recall Recall for Class 0 by Different Steps of Implicit Premise 0.50.550.60.650.70.750.8 0 0.2 0.4 0.6 Neuro-Matching Threshold (τ m ) Recall Recall for Class 1 by Different Steps of Implicit Premise original (τ c = 80)original (τ c = 90) original (τ c = 100)1-step (τ c = 80) 1-step (τ c = 90)1-step (τ c = 100) 2-steps (τ c = 80)2-steps (τ c = 90) 2-steps (τ c = 100)3-steps (τ c = 80) 3-steps (τ c = 90)3-steps (τ c = 100) Figure 6: Recall by Different Steps of Implicit Premise of the ANLI dataset 0.50.550.60.650.70.750.8 0.4 0.5 0.6 0.7 Neuro-Matching Threshold (τ m ) Precision Precision for Class 0 by Different Steps of Implicit Premise 0.50.550.60.650.70.750.8 0 0.2 0.4 0.6 0.8 1 Neuro-Matching Threshold (τ m ) Precision Precision for Class 1 by Different Steps of Implicit Premise original (τ c = 80)original (τ c = 90) original (τ c = 100)1-step (τ c = 80) 1-step (τ c = 90)1-step (τ c = 100) 2-steps (τ c = 80)2-steps (τ c = 90) 2-steps (τ c = 100)3-steps (τ c = 80) 3-steps (τ c = 90)3-steps (τ c = 100) Figure 7: Precision by Different Steps of Implicit Premise of the ANLI dataset 0.50.550.60.650.70.750.8 0.6 0.65 0.7 0.75 Neuro-Matching Threshold (τ m ) F1-Score F1-Score for Class 0 by Different Steps of Implicit Premise 0.50.550.60.650.70.750.8 0 0.2 0.4 0.6 Neuro-Matching Threshold (τ m ) F1-Score F1-Score for Class 1 by Different Steps of Implicit Premise original (τ c = 80)original (τ c = 90) original (τ c = 100)1-step (τ c = 90) 1-step (τ c = 100)1-step (τ c = 80) 2-steps (τ c = 80)2-steps (τ c = 90) 2-steps (τ c = 100)3-steps (τ c = 80) 3-steps (τ c = 90)3-steps (τ c = 100) Figure 8: F1-score by Different Steps of Implicit Premise of the ARCT dataset 0.50.550.60.650.70.750.8 0.8 0.85 0.9 0.95 1 Neuro-Matching Threshold (τ m ) Recall Recall for Class 0 by by Different Steps of Implicit Premise 0.50.550.60.650.70.750.8 0 0.2 0.4 0.6 Neuro-Matching Threshold (τ m ) Recall Recall for Class 1 by Different Steps of Implicit Premise original (τ c = 80)original (τ c = 90) original (τ c = 100)1-step (τ c = 80) 1-step (τ c = 90)1-step (τ c = 100) 2-steps (τ c = 80)2-steps (τ c = 90) 2-steps (τ c = 100)3-steps (τ c = 80) 3-steps (τ c = 90)3-steps (τ c = 100) Figure 9: Recall by Different Steps of Implicit Premise of the ARCT Dataset 0.50.550.60.650.70.750.8 0.4 0.5 0.6 0.7 Neuro-Matching Threshold (τ m ) Precision Precision for Class 0 by Different Steps of Implicit Premise 0.50.550.60.650.70.750.8 0.4 0.6 0.8 Neuro-Matching Threshold (τ m ) Precision Precision for Class 1 by Different Steps of Implicit Premise original (τ c = 80)original (τ c = 90) original (τ c = 100)1-step (τ c = 80) 1-step (τ c = 90)1-step (τ c = 100) 2-steps (τ c = 80)2-steps (τ c = 90) 2-steps (τ c = 100)3-steps (τ c = 80) 3-steps (τ c = 90)3-steps (τ c = 100) Figure 10: Precision by Different Steps of Implicit Premise of the ARCT Dataset G e n e r a t e t w o d i s t i n c t c h a i n s o f r e a s o n i n g b a s e d on t h e p r e m i s e a n d c l a i m p r o v i d e d b e l o w . F o l l o w t h e s e i n s t r u c t i o n s c a r e f u l l y . ** P r e m i s e : * * p r e m i s e ** C l a i m : * * c l a i m ** I n s t r u c t i o n s : * * − ** H e l p f u l C h a i n : * * G i v e o n e / t w o / t h r e e s t a t e m e n t s t h a t r e p r e s e n t t h e s t e p s o f r e a s o n i n g s t a r t i n g f r o m t h e p r e m i s e s a n d f i n i s h i n g w i t h t h e c l a i m ( s p l i t by f u l l s t o p ) , a v o i d u s i n g p r o n o u n a n d r e p e a t i n g c l a i m ( e a c h s t a t e m e n t u n d e r 10 w o r d s ) − ** Non− H e l p f u l C h a i n : * * G i v e o n e / t w o / t h r e e s t a t e m e n t s t h a t r e p r e s e n t t h e s t e p s o f r e a s o n i n g s t a r t i n g f r o m t h e p r e m i s e s a n d f i n i s h i n g w i t h t h e n e u t r a l o r c o n t r a d i c t o r y o f c l a i m ( s p l i t by f u l l s t o p ) , a v o i d u s i n g p r o n o u n a n d r e p e a t i n g c l a i m ( e a c h s t a t e m e n t u n d e r 10 w o r d s ) ** O u t p u t F o r m a t : * * Your o u t p u t m u s t e x a c t l y m a t c h t h e f o l l o w i n g s t r u c t u r e . Do n o t a d d a n y e x t r a t e x t , h e a d e r s , o r e x p l a n a t i o n s . P r e m i s e : p r e m i s e C l a i m : c l a i m H e l p f u l : [ i n s e r t h e l p f u l r e a s o n i n g c h a i n h e r e ] Non− H e l p f u l : [ i n s e r t non − h e l p f u l r e a s o n i n g c h a i n h e r e ] R e p l a c e t h e b r a c k e t e d p a r t s w i t h y o u r r e s p o n s e s , e n s u r i n g e a c h c h a i n i s a c o n t i n u o u s s e n t e n c e o r p h r a s e . Figure 11: Prompt