Paper deep dive
Identifying Implicit Premises for Logical Reconstruction of Argument Graphs
Xuyao Feng, Anthony Hunter
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 90%
Last extracted: 8/20/2026, 5:11:41 AM
Summary
This paper proposes a neuro-symbolic pipeline for the logical reconstruction of argument graphs by identifying implicit premises (enthymemes). The method uses Large Language Models (LLMs) to generate intermediate implicit premises, which are then translated into propositional logic via Abstract Meaning Representation (AMR). The system employs similarity measures and Natural Language Inference (NLI) to relax and map AMR atoms to abstract logical formulas, finally using an automated reasoner (PySAT) to determine entailment, contradiction, or neutrality relationships between explicit premises and claims.
Entities (11)
Relation Signals (8)
Neuro-symbolic pipeline → uses → LLM
confidence 95% · we propose a neuro-symbolic pipeline that uses large language models (LLMs) to generate intermediate implicit premises
Neuro-symbolic pipeline → evaluatedon → Microtext Argumentative Corpus
confidence 93% · Our approach is evaluated on the Microtext Argumentative Corpus.
LLM → generates → Enthymeme
confidence 92% · uses large language models (LLMs) to generate intermediate implicit premises
Neuro-symbolic pipeline → determines → Entailment
confidence 90% · show the logical relationships between them (entailment, contradiction, or neutrality)
Neuro-symbolic pipeline → determines → Contradiction
confidence 90% · show the logical relationships between them (entailment, contradiction, or neutrality)
Neuro-symbolic pipeline → translates → AMR
confidence 90% · AMR-to-Propositional-Logic Translator... translating AMR graphs into first-order logic
Neuro-symbolic pipeline → uses → PySAT
confidence 90% · Automated Reasoner (based on PySAT)
LLM → instanceof → DeepSeek V3.2
confidence 88% · The LLM used is DeepSeek v3.2
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:The logical reconstruction of argument graphs from natural language text is challenging because of the prevalence of enthymemes (i.e., arguments with implicit premises). There are natural language processing methods for identifying enthymemes in text, and there are symbolic methods based on abduction for identifying missing premises in a logical representation of enthymemes. However, there is a need for methods to generate implicit premises to logically show a known entailment or contradiction relationship between a pair of statements. To address this, we propose a neuro-symbolic pipeline that uses large language models (LLMs) to generate intermediate implicit premises that are translated into logical formulae and used with logical formulae representing explicit premises and explicit claims to show the logical relationships between them (entailment, contradiction, or neutrality). Our approach is evaluated on the Microtext Argumentative Corpus.
Tags
Links
- Source: https://arxiv.org/abs/2608.18821v1
- Canonical: https://arxiv.org/abs/2608.18821v1
Trouble viewing inline? Open PDF directly →
Full Text
41,526 characters extracted from source content.
Expand or collapse full text
Identifying Implicit Premises for Logical Reconstruction of Argument Graphs Xuyao Feng 0009-0009-0888-6233 Thanks: Corresponding Author: Xuyao Feng, xuyao.feng.20@ucl.ac.uk. Anthony Hunter 0000-0001-5602-7446 Address: Department of Computer Science, University College London, United Kingdom Abstract The logical reconstruction of argument graphs from natural language text is challenging because of the prevalence of enthymemes (i.e., arguments with implicit premises). There are natural language processing methods for identifying enthymemes in text, and there are symbolic methods based on abduction for identifying missing premises in a logical representation of enthymemes. However, there is a need for methods to generate implicit premises to logically show a known entailment or contradiction relationship between a pair of statements. To address this, we propose a neuro-symbolic pipeline that uses large language models (LLMs) to generate intermediate implicit premises that are translated into logical formulae and used with logical formulae representing explicit premises and explicit claims to show the logical relationships between them (entailment, contradiction, or neutrality). Our approach is evaluated on the Microtext Argumentative Corpus. keywords Argument graph -symbolic -sense reasoning reasoning and 1 Introduction The logical reconstruction of argument graphs from natural language text is a fundamental challenge in computational argumentation. Such reconstructions aim to formalize the underlying inferential structure of arguments, representing components (premises, claims) as nodes and their semantic relationships—such as entailment (support), contradiction (attack), or neutrality—as edges in a graph. However, this task is complicated by the widespread occurrence of enthymemes: arguments that are logically incomplete due to omitted, implicit premises [14, 4]. For example, the inference from the premise “the weather report predicts rain” to the claim “you should take an umbrella” hinges on an unstated rule such as “if the weather report predicts rain, one should take an umbrella”. Without recovering these hidden links, any automated reconstruction of the argument graph remains partial and potentially misleading. There are methods based on natural language processing for identifying enthymemes in text [12, 26, 29, 27], and there are methods based on formal logic for identifying missing premises in a logical representation of an enthymeme using abduction from a logical knowledge base [14, 4, 15, 2, 7]. There are also methods for identifying missing premises from previous moves in a logical representation of a dialogue [3, 9, 13, 31, 24, 22, 21]. However, the crucial task of identifying missing premises from common and commonsense knowledge remains challenging. In recent work, we have begun to bridge the gap between argument mining [19] and symbolic methods by translating free-text enthymemes into logic and then using neuro-symbolic reasoning based on sentence embeddings to classify the relationship between a pair of formulae as entailment, contradiction, or neutral [10]. Subsequently, we used an LLM to generate implicit premises that, when translated into logic, can be used to determine whether an explicit claim follows from an explicit premise using neuro-symbolic reasoning [11]. This paper builds on our prior work (i.e., [11]) by prompting an LLM to generate implicit premises that logically establish a known entailment or contradiction relationship between an explicit premise and an explicit claim. In other words, given a premise-claim pair and its relation label (entailment, contradiction, or neutral), can we identify the implicit premise that makes the logical connection explicit? Furthermore, this paper uses the Microtext Argumentative Corpus [25], which is a more challenging dataset than those used in our previous work, for the evaluation. Our results indicate that our pipeline significantly enhances the quality and logical coherence of argument graph reconstruction, providing a crucial step toward scalable and accurate logical analysis of argumentative text. The remainder of this paper is structured as follows: Section 2 reviews background in logical argumentation and enthymeme resolution. Section 3 details our neuro-symbolic pipeline for generating implicit premises. Section 4 describes our experiments with datasets, and Section 5 discusses implications and future work. 2 Abstract meaning representation This section reviews abstract meaning representation (AMR) and how we can translate it into propositional logic. Abstract meaning representation (AMR) is a semantic representation language for representing sentences as rooted, labelled, directed, and acyclic graphs (DAGs) [1]. AMR is intended to assign the same AMR graph to similar sentences, even if they are not identically worded. Negation is represented via the :polarity relation. For example, Figure 1 represents “The boy does not want to go.” The numbers after the instance name (such as want-01 above) denote a particular OntoNotes or PropBank semantic frame [17]. 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”). (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 -)) array[]l (w / want-01& (w / want-01\\ 28.45274pt :arg0 (b / boy)& 28.45274pt :arg0 (b / boy)\\ 28.45274pt :arg1 (g / go-01& 28.45274pt :arg1 (g / go-01\\ 56.9055pt :arg0 b))& 56.9055pt :arg0 b\\ & 56.9055pt :polarity -)) array Figure 1: AMR for the sentence “The boy wants to go.” (left) and “The boy does not want to go.” (right). Text-to-AMR Parser In our pipeline, we use the IBM Transition AMR parser11 1 https://github.com/IBM/transition-amr-parser/tree/master to load the pre-trained ensemble AMR 3.0 model (AMR3-joint-ontowiki-seed43), which combines smatch-based ensembling techniques with ensemble distillation [20] to translate each sentence of text into an AMR graph. AMR-to-Propositional-Logic Translator An advantage of AMR is that we can easily transform an AMR graph into first-order logic formulas using the Bos algorithm [5]. There is an open-source Python library based on the Bos algorithm, the AMR-to-logic converter [6], for translating AMR graphs into first-order logic. We extended this library to create our AMR-to-propositional-logic translator by rewriting each first-order logic formula as a propositional logic formula and grounding out the existentially quantified variables with new constants. We refer to each such propositional formula as an AMR formula. For the above example, the propositional logic formula is simplified as follows. (,)∧¬((,)∧(,)) array[]l arg0(want,boy) 2.84526pt (arg1(want,go) arg0(go,boy)) array For our pipeline, we assume the usual definitions for propositional logic. We start with a set of propositional atoms (letters), and we construct formulas in the usual way using the connectives for negation ¬ , conjunction ∧ , disjunction ∨ , implication →, and biconditional ↔ . 3 Pipeline A set of sentences and a true label (entailment, contradiction, or neutral) 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, contradiction, or neutral) Figure 2: Our neuro-symbolic pipeline where the input is a set of natural language sentences (e.g., a premise, implicit premises, and a claim), and the output is a label. Our neuro-symbolic pipeline22 2 https://github.com/fxy-1117/COMMA2026, which is summarized in Figure 2, consists of five main components: An LLM to generate intermediate implicit premises (Section 3.1); A text-to-AMR parser (Section 2); An AMR-to-propositional-logic translator (Section 2); A set of methods for relaxing the propositional formulas (Sections 3.3 and 3.4); And an automated reasoner based on PySAT (Section 3.5). 3.1 Generate implicit premises We employ a large language model (LLM) to generate implicit premises by providing it with an explicit premise, a claim, and the label indicating whether the claim follows from or contradicts the premise. The model is then prompted to produce either one or six intermediate reasoning steps that make explicit how the claim is derived from or contradicts the premise. These intermediate steps form a chain of reasoning, as explored in [28], which incrementally bridges the gap between the explicit premise and claim. As the number of steps increases, the reasoning exposes finer logical connections and provides additional detail on how the claim either follows from or contradicts the premise. The LLM used is DeepSeek v3.2 [8], and our prompt is presented with the code. 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 formulas which we handle in Sections 3.3 and 3.4. 3.2 Representing formulas An AMR formula is composed of a set of atoms together with the ¬ and ∧ logical operators. Since each atom is ground, an AMR formula is a propositional logic formula. Let A be a set of AMR atoms (i.e. ground dyadic predicates of the form r(a,b)r(a,b) where a and b are constant 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. Let P 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 isomorphic 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 _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 Emb. In our pipeline, the Emb function is the sentence transformer BAAI general embedding model bge-small-en-v1.5 [30] (alternatives can easily be used) that encodes a string of words as a high-dimensional vector. The similarity between two embedding vectors v1v_1 and v2v_2 is defined as follows, where θ is the angle between the vectors, v1⋅v2v_1· v_2 is the dot product of v1v_1 and v2v_2, and ‖v1‖||v_1|| represents the L2 norm. (v1,v2)=cos(θ)=v1⋅v2‖v1‖‖v2‖ Sm(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 an AMR atom in an AMR formula and representing that information as a natural language sentence. 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 we 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 1. Let ϕφ be an AMR formula, and let r(a,b)r(a,b) be an AMR atom in ϕφ (i.e. r(a,b)∈(ϕ)r(a,b)∈ Atoms(φ)). Also let T be a template for r with placeholders [X][ X] and [Y][ Y]. The instantiate function, denoted Inst, is defined as follows: (r(a,b),T) Inst(r(a,b),T) = I, where I is the instantiation of T in which [X][ X] is replaced by a and [Y][ Y] is replaced by b. Some examples of templates are given below, with the AMR predicate name. • ( 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 Emb to obtain the sentence embeddings of the instantiations of templates. Example 2. Let T = “[Y] is the agent performing action [X].” be the template for the AMR predicate name arg0. Therefore, for the AMR atom (,) arg0(play,child), ((,),T) Inst( arg0(play,child),T) = “child is the agent performing action play.” For the following definition of a matching relation, we assume that one AMR formula refers to a premise and the other refers to a claim. Definition 2. Let an AMR formula ϕφ be a premise and an AMR formula ψ be a claim, let α∈(ψ)α∈ Atoms(ψ) be an AMR atom of the form r(a,b)r(a,b), let T1T_1 be a template for r, let β∈(ϕ)β∈ Atoms(φ) be an AMR atom of the form q(c,d)q(c,d), let T2T_2 be a template for q, let τm∈[0,1] _m∈[0,1] be the neuro-matching threshold, and let Emb be an embedding function. The neuro-matching relation, denoted ≃ , is defined as follows, where (α) Near(α) = (β′,x)∣β′∈(ϕ)\(β ,x) β ∈ Atoms(φ) and x>τmx> _m and (((α,T1)),((β′,T2)))=x Sm( Emb( Inst(α,T_1)), Emb( Inst(β ,T_2)))=x\. α≃β iff (β,x)∈(α) and ∀(β′,y)∈(α),x≥y array[]lα β iff (β,x)∈ Near(α) and ∀(β ,y)∈ Near(α),x≥ y array This definition finds the best premise match above the threshold for each claim atom. Thus, if the premise atoms are β1,…,βn _1,…, _n with scores s1,…,sns_1,…,s_n, then α≃βα β holds when β=βiβ= _i and si=max(s1,…,sn)s_i= (s_1,…,s_n). Example 3. Let the text for the premise be “A tiger is walking in the cage.”, and let the text for the claim be “A tiger is moving.” We have the following AMR formulas. (,)∧(,)(,) array[]c arg0(walk,tiger) location(walk,cage)\\ arg0(move,tiger) array So (,)≃(,) arg0(walk,tiger) arg0(move,tiger), with template T for arg0, the following similarity, and τm=0.6 _m=0.6. ((((,),T)),(((,),T)))=0.8483 array[]l Sm( Emb( Inst( arg0(walk,tiger),T)), Emb( Inst( arg0(move,tiger),T)))=0.8483 array 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) model33 3 mDeBERTa-v3-base-xnli-multilingual-nli-2mil7 [18]. The NLI model evaluates a pair of sentences (S1,S2)(S_1,S_2) by identifying three scores, each in the [0,100] interval: sEnt(S1,S2)s_Ent(S_1,S_2) is the degree to which S2S_2 is entailed by S1S_1; sCon(S1,S2)s_Con(S_1,S_2) is the degree of conflict between S1S_1 and S2S_2; and sNeu(S1,S2)s_Neu(S_1,S_2) is the degree to which S1S_1 and S2S_2 are unrelated. The model returns the label with the highest score (with a random choice in case of a tie). Definition 3. Let S be the set of all natural language sentences, and let =Ent,Con,NeuC=\Ent,Con,Neu\ be the set of outcomes (entailment, contradiction, and neutrality). A natural language inference (NLI) function :×→ NLinf:S×S is defined as follows, with scores sEnts_Ent, sCons_Con, and sNeus_Neu for a given pair (S1,S2)(S_1,S_2). (S1,S2)=argmaxσ∈sσ(S1,S2) NLinf(S_1,S_2)= _σ s_σ(S_1,S_2) Definition 4. Let an AMR formula ϕφ be a premise and an AMR formula ψ be a claim, let α∈(ψ)α∈ Atoms(ψ) be an AMR atom of the form r(a,b)r(a,b), let T1T_1 be a template for r, let β∈(ϕ)β∈ Atoms(φ) be an AMR atom of the form q(c,d)q(c,d), let T2T_2 be a template for q, let NLinf be an NLI function, and let τc∈[0,100] _c∈[0,100] be the neuro-contradict threshold. The neuro-contradict relation ⟂ is defined as follows α⟂β iff ((α,T1),(β,T2))=Con and sCon((α,T1),(β,T2))≥τc array[]lα β\ iff NLinf( Inst(α,T_1), Inst(β,T_2))=Con and s_Con( Inst(α,T_1), Inst(β,T_2))≥ _c array Example 4. Let the text for the premise be “A tiger is walking in the cage.”, and let the text for the claim be “The tiger is sleeping in the cage.” We have the AMR formulas. (,)∧(,)(,)∧(,) array[]c arg0(walk,tiger) location(walk,cage)\\ arg0(sleep,tiger) location(sleep,cage) array When τc=80 _c=80, (,)⟂(,) arg0(walk,tiger) arg0(sleep,tiger), and (,)⟂(,) location(walk,cage)\! \! location(sleep,cage) hold, given the following outputs for templates T1T_1 and T2T_2 for arg0 and location, respectively. (((,),T1),((,),T1))=ConsCon(((,),T1),((,),T1))=85(((,),T2),((,),T2))=ConsCon(((,),T2),((,),T2))=82 array[]c NLinf( 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\\ \\ NLinf( Inst( location(walk,cage),T_2), Inst( location(sleep,cage),T_2))=Con\\ s_Con( Inst( location(walk,cage),T_2), Inst( location(sleep,cage),T_2))=82 array The ≃ relation is reflexive and symmetric, whereas the ⟂ relation is irreflexive and symmetric. 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. Similarly, if we have 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 5. Given a set of AMR formulas Φ , and a set of neuro-matching and neuro-contradict relationships Ψ , the function g:→∪¬x∣x∈g: A→ P∪\ x x∈ P\ is a mapping for Φ and Ψ iff for all ϕ,ϕ′∈Φφ,φ ∈ , for all α∈(ϕ)α∈ Atoms(φ), for all β∈(ϕ′)β∈ Atoms(φ ), (1) α≃β∈Ψ iff g(α)=g(β)α β∈ iff g(α)=g(β); and (2) α⟂β∈Ψ iff g(α)=¬g(β)α β∈ iff g(α)= g(β). For the tautology ⊤ , g(⊤)=⊤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. complementary literals) in the abstract formulas. Example 5. For ϕ1=(,)∧(,) _1= arg1(car,red) arg2(car,fast), ϕ2=(,) _2= arg1(car,red), and Φ=ϕ1,ϕ2 =\ _1, _2\, a mapping g is g((,))=g( arg1(car,red))= x_1 and g((,))=g( arg2(car,fast))= x_2. Example 6. Continuing Ex 3, let g be a mapping g((,))=g( location(walk,cage))= x_2 and g((,))=g((,))=g( arg0(walk,tiger))=g( arg0(move,tiger))= x_1. Example 7. Continuing Ex 4, g((,))=¬g((,))=¬g( arg0(sleep,tiger))= g( arg0(walk,tiger))= x_1 and g((,))=¬g((,))=¬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 6. Let g be a mapping for a set of AMR formulas Φ and a set of neuro-matching and neuro-contradict relationships Ψ . For ϕ∈Φφ∈ , a translation of ϕφ is g(ϕ) Tran_g(φ) where g Tran_g is defined as: (1) g(α∧β)=g(α)∧g(β) Tran_g(α β)= Tran_g(α) Tran_g(β); (2) g(¬α)=¬g(α) Tran_g( α)= Tran_g(α); and (3) g(α)=g(α) Tran_g(α)=g(α) when α∈α∈ A. For Φ , let g(Φ) Tran_g( ) = g(ϕ)∣ϕ∈Φ\ Tran_g(φ) φ∈ \. Example 8. Continuing Ex 5, a translation of ϕ1 _1 is ∧ x_1 x_2 and a translation of ϕ2 _2 is x_1. The use of embeddings and NLI allows for the identification of neuro-matching and neuro-contradict relations, which can then be used to rewrite AMR formulas into abstract formulas, 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 formulas 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 [23]. Then, we use PySAT [16], 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 between a premise ϕφ (which may be a conjunction of an explicit premise and one or more intermediate premises) and a claim ψ. Proving that ϕφ entails ψ is equivalent to determining whether ϕ∧¬ψφ ψ is inconsistent. Similarly, to prove whether ϕφ contradicts ψ, we need to determine whether ϕ∧ψφ ψ is inconsistent. 4 Experiments To evaluate our pipeline, we used the Microtext Argumentative Corpus, which we describe next, in three experiments. Method The Microtext Argumentative Corpus [25] is a resource specifically designed for argument mining research. The corpus consists of 112 short, self-contained argumentative texts, split into 576 segments, which have been manually annotated by expert annotators to identify argument components (viz., a central claim, claims, and premises) and the support or attack relationships (rebuttal and undercut) between them. Figure 3 is an argument graph of an example from the corpus. 1: I think it’s possible for older people to be better parents. 2: They have had time to mature more and learn about themselves. 4: so they can provide for a child. 3: They’re more likely to have steady careers going. 5: Some might say being too old risks the child being disabled. 6: but insisting all babies be perfect is demanding the impossible; 7: as well as demeaning to people already living who are disabled. support support undercut rebuttal support Figure 3: Argument graph example (text number 008) where Segment 1 is the central claim. It is directly supported by Segment 2 and Segment 4. Segment 3, in turn, provides support for Segment 4. The claim is challenged by Segment 5, which rebuts it, but this rebuttal is itself undercut by Segments 6 and 7. To evaluate our pipeline, we translated the Microtext dataset into a three-class dataset by generating premise-claim pairs from argument segments: From the argument graph representation (of an argumentative text in the Microtext dataset), each arc gives a premise-claim pair where the segment in the source (resp. target) node is the premise (resp. claim). The label for each premise-claim pair is assigned using the original Microtext dataset: Entailment (entent) for a support relation from premise to claim; Contradiction (concon) for a rebuttal or undercut relation from premise to claim; and Neutral (neuneu) for segments S1S_1 and S2S_2 with no relationship between them and with (S1,S2)=Neu NLinf(S_1,S_2)=Neu with confidence sNeu(S1,S2)≥99s_Neu(S_1,S_2)≥ 99 (recall that NLinf is the NLI function). Example 9. For the argument graph in Figure 3, we get the following labelling: the Entailment label for (2,1)(2,1), (4,1)(4,1), and (3,4)(3,4); the Contradiction label for (5,1)(5,1) and (6&7,5)(6\&7,5), where &\& denotes a conjunction of segments; and the Neutral label for (3,5)(3,5) and (3,1)(3,1). We designed a sequence of three experiments to evaluate the reasoning capabilities of our pipeline. First, we established a baseline by using the reformatted three-class dataset in our pipeline without generating any implicit premises. Second, we introduced single-step implicit premise generation (as described in Section 3.1) to the pipeline. In the first and second experiments, we investigated different choices for the neuro-matching threshold τm _m and the neuro-contradiction threshold τc _c. Third, using the optimal choices for τm _m and τc _c from the second experiment, we generated six-step implicit premise chains (as described in Section 3.1) and evaluated their performance using cumulative chains from 1 to 5 steps (i.e. first just step 1, second conjunction of steps 1 and 2, third conjunction of steps 1, 2 and 3, etc.) to analyze the impact of multi-step reasoning on classification performance. Note that the sixth step is always discarded because very often it is a redundant repetition of the claim. Table 1 is an example of the data format (reformatted Microtext data and implicit premises) used across all three experiments. Reformatted Premise: Landfills also produce a lot of odor Microtext Claim: Landfills are bad for handling our trash data Label: Entailment Experiment 1 No Implicit Premise Experiment 2 Single implicit premise: Odor is a negative environmental impact. Experiment 3 Multi-step chain of implicit premises: (Step 1) Odor indicates poor waste decomposition; (Step 2) Decomposition releases harmful gases; (Step 3) These gases pollute the surrounding air; (Step 4) Air pollution harms human health; (Step 5) Health hazards show inadequate waste management; (Step 6) Inadequate management makes landfills a bad solution. Table 1: Example of the data format across all three experiments. The reformatted and implicit data for each argumentative text is translated into AMR formulae, then into abstract formulae, and finally evaluated using automated reasoning, as explained for the pipeline in Section 3. 0.50.50.550.550.60.60.650.650.70.70.750.750.80.80.330.330.360.360.390.390.420.420.450.450.480.480.510.51τm _mAccuracyExp2, τc=80 _c=80Exp2, τc=90 _c=90Exp2, τc=100 _c=100Exp1, τc=80 _c=80Exp1, τc=90 _c=90Exp1, τc=100 _c=100 Figure 4: Results for Experiment 1 (no implicit premises) and Experiment 2 (single implicit premise): Accuracy across different τm _m and τc _c values (solid lines: Experiment 2; dashed lines: Experiment 1). As it is a three-class classification task, random classification would tend to have an accuracy of 0.333. 0011223344550.30.30.350.350.40.40.450.450.50.50.550.550.60.60.650.650.70.7Number of steps of implicit premises usedScorecon preccon recent precent recneu precneu recaccuracy Figure 5: Experiment 3 (using 1 to 5 steps of implicit premises): Precision (prec) and recall (rec) scores for all three classes and overall accuracy across different steps (τm _m=0.6, τc _c=80). Results For all three experiments, we used the same subset of the reformatted data (as described in the methods), comprising 140 randomly selected items per class (420 items total). In the first two experiments, we evaluated performance across a range of neuro-matching thresholds τm _m (from 0.5 to 0.8) and three neuro-contradiction thresholds τc _c (viz. 80, 90, and 100). As shown in Figure 4, a comparative analysis of model performance reveals distinct optimal thresholds for each experiment. Experiment 1 achieved peak accuracy (∼ 0.426) at τm=0.55 _m=0.55 and τc=80 _c=80, while Experiment 2 attained its highest accuracy (∼ 0.512) at τm=0.6 _m=0.6 and τc=90 _c=90. In both cases, accuracy declined steadily as τm _m increased beyond these values. The parameter τc _c exhibited a modest influence on performance, with lower values generally yielding marginally better results. Class-level F1-scores revealed important patterns: in Experiment 1, the con and ent classes performed best at τm=0.55 _m=0.55, while in Experiment 2, these classes showed good F1 scores within the range τm=0.5 _m=0.5–0.6. The neu class demonstrated stronger F1 performance at higher thresholds, particularly beyond τm=0.6 _m=0.6. Notably, lower τc _c values resulted in better con performance without significantly degrading the ent results and neu results. Based on the above findings, we selected τm=0.6 _m=0.6 and τc=80 _c=80 (rather than τc=90 _c=90) for Experiment 3 to prioritize better performance for both con and ent classes while maintaining reasonable overall accuracy. As shown in Figure 5, the use of an increasing number of reasoning steps as implicit premises leads to consistent improvements in both class-specific metrics and overall accuracy under fixed thresholds (τm=0.6 _m=0.6, τc=80 _c=80). The con class demonstrates a particularly notable improvement: precision increases from 0.49 to 0.52, while recall nearly doubles from 0.31 to 0.52, indicating substantially improved detection capability. Similarly, the ent class exhibits steady gains, with precision and recall rising from approximately 0.44 and 0.34, respectively, to 0.51. The neu class shows a different pattern: while recall remains consistently high at 0.63 across all step counts because we do not generate implicit-premise steps for the neutral class, precision improves markedly from 0.39 to 0.63, reflecting enhanced prediction confidence for this majority class. Overall accuracy increases from 0.426 to 0.555, reaching its peak at 4 steps before a slight decrease at 5 steps, suggesting optimal performance is achieved with four steps of implicit premise integration. By step 5, precision and recall converge across all classes, indicating a more balanced classifier. However, using 4 steps provides the optimal trade-off between overall accuracy and metric stability. These results demonstrate that multi-step reasoning improves model performance, especially for minority classes. 5 Discussion This paper presents the first framework to systematically generate implicit premises that logically justify a known semantic relation (e.g., entailment or contradiction) between an explicit premise and a claim. Given a premise-claim pair and its relation label, our method identifies the implicit premise that makes the logical connection explicit. We evaluated our pipeline on a dataset with substantial implicit reasoning. The approach achieved strong, balanced performance across all three classes in classification tasks, with the additional benefit of providing logically reconstructed arguments. Whilst the results are promising, there is a need to further improve the pipeline’s performance, perhaps by focusing on better ways to prompt an LLM for appropriate implicit premises. In future work, we will investigate using this pipeline for end-to-end logical argument mining by directly processing plain text to identify relations through neuro-symbolic translation, thereby enabling the systematic generation of logical argument graphs from unstructured text. References [1] L. Banarescu, C. Bonial, S. Cai, M. Georgescu, K. Griffitt, U. Hermjakob, K. Knight, P. Koehn, M. Palmer, and N. Schneider (2013) Abstract Meaning Representation for sembanking. In Proc. Linguistic Annotation Workshop and Interoperability with Discourse, p. 178–186. Cited by: §2. [2] J. Ben-Naim, V. David, and A. Hunter (2025) An Axiomatic Study of a Modular Evaluation of Enthymeme Decoding in Weighted Structured Argumentation. In Proc. KR’25, p. 110–120. Cited by: §1. [3] E. Black and A. Hunter (2008) Using enthymemes in an inquiry dialogue system. In Proc. AAMAS’08, p. 437–444. Cited by: §1. [4] E. Black and A. Hunter (2012) A relevance-theoretic framework for constructing and deconstructing enthymemes. Journal of Logic and Computation 22 (1), p. 55–78. Cited by: §1, §1. [5] J. Bos (2016) Squib: expressive power of Abstract Meaning Representations. Computational Linguistics 42 (3), p. 527–535. Cited by: §2. [6] D. Chanin and A. Hunter (2023) Neuro-symbolic commonsense social reasoning. arXiv 2303.08264. Cited by: §2. [7] V. David and A. Hunter (2025) A logic-based framework for decoding enthymemes in argument maps involving implicitness in premises and claims. In Proc. IJCAI’25, p. 4445–4453. Cited by: §1. [8] DeepSeek-AI (2025) DeepSeek-v3.2: pushing the frontier of open large language models. arXiv 2512.02556. Cited by: §3.1. [9] F. Dupin de Saint-Cyr (2011) Handling enthymemes in time-limited persuasion dialogs. In Proc. SUM’11, LNCS, Vol. 6929, p. 149–162. Cited by: §1. [10] X. Feng and A. Hunter (2025) Formalizing simple natural language arguments using abstract meaning representation and approximate propositional reasoning. In Proc. ICTAI’25, p. 238–245. Cited by: §1. [11] X. Feng and A. Hunter (2026) Making implicit premises explicit in logical understanding of enthymemes. arXiv 2603.06114. Cited by: §1, §1. [12] I. Habernal, H. Wachsmuth, I. Gurevych, and B. Stein (2018) The argument reasoning comprehension task: identification and reconstruction of implicit warrants. In Proc. NAACL’18, p. 1930–1940. Cited by: §1. [13] S. Hosseini, S. Modgil, and O. Rodrigues (2014) Enthymeme construction in dialogues using shared knowledge. In Proceedings of COMMA’14, FAIA, Vol. 266, p. 325–332. Cited by: §1. [14] A. Hunter (2007) Real arguments are approximate arguments. In Proc. AAAI’07, p. 66–71. Cited by: §1, §1. [15] A. Hunter (2022) Understanding enthymemes in deductive argumentation using semantic distance measures. In Proc. AAAI’22, p. 5729–5736. Cited by: §1. [16] A. Ignatiev, A. Morgado, and J. Marques-Silva (2018) PySAT: A Python toolkit for prototyping with SAT oracles. In Proc. SAT’18, LNCS, Vol. 10929, p. 428–437. Cited by: §3.5. [17] P. Kingsbury and M. Palmer (2002) From TreeBank to PropBank. In Proc. LREC’02, p. 1989–1993. Cited by: §2. [18] M. Laurer, W. Van Atteveldt, A. Casas, and K. Welbers (2023) Less annotating, more classifying: addressing the data scarcity issue of supervised machine learning with deep transfer learning and BERT-NLI. Political Analysis, p. 1–33. External Links: ISSN 1047-1987, 1476-4989 Cited by: §3.3. [19] J. Lawrence and C. Reed (2019) Argument mining: A survey. Computational Linguistics 45 (4), p. 765–818. Cited by: §1. [20] Y. Lee, R. F. Astudillo, T. L. Hoang, T. Naseem, R. Florian, and S. Roukos (2021) Maximum bayes smatch ensemble distillation for AMR parsing. ArXiv 2112.07790. Cited by: §2. [21] D. S. O. Leiva, A. J. García, and S. Gottifredi (2025) Principles for assumptions generation in enthymeme-based dialogue. Journal of Artificial Intelligence Research 83. Cited by: §1. [22] D. S. O. Leiva, S. Gottifredi, and A. J. García (2023) Automatic knowledge generation for a persuasion dialogue system with enthymemes. International Journal of Approximate Reasoning 160, p. 108963. Cited by: §1. [23] A. Meurer, C. P. Smith, M. Paprocki, O. Čertík, S. B. Kirpichev, M. Rocklin, A. Kumar, S. Ivanov, J. K. Moore, S. Singh, T. Rathnayake, S. Vig, B. E. Granger, R. P. Muller, F. Bonazzi, H. Gupta, S. Vats, F. Johansson, F. Pedregosa, M. J. Curry, A. R. Terrel, Š. Roučka, A. Saboo, I. Fernando, S. Kulal, R. Cimrman, and A. Scopatz (2017) SymPy: symbolic computing in python. PeerJ Computer Science 3, p. e103. External Links: ISSN 2376-5992 Cited by: §3.5. [24] A. R. Panisson, P. McBurney, and R. H. Bordini (2022) Towards an enthymeme-based communication framework in multi-agent systems. In Proc. KR’22, p. 267–277. Cited by: §1. [25] A. Peldszus and M. Stede (2016) An annotated corpus of argumentative microtexts. In Proc. European Conference on Argumentation, p. 801–816. Cited by: §1, §4. [26] K. Singh, N. Inoue, F. S. Mim, S. Naito, and K. Inui (2022) IRAC: a domain-specific annotated corpus of implicit reasoning in arguments. In Proc. LREC’22, p. 4674–4683. Cited by: §1. [27] E. Sviridova, E. Cabrio, and S. Villata (2025) Mining implicit arguments for reasoning: a survey. Argument & Computation 17 (1), p. 3–27. Cited by: §1. [28] J. Wei, X. Wang, D. Schuurmans, M. Bosma, B. Ichter, F. Xia, E. H. Chi, Q. V. Le, and D. Zhou (2022) Chain of thought prompting elicits reasoning in large language models. In Proc. NeurIPS’22, p. 24824–24837. Cited by: §3.1. [29] K. Wei, X. Sun, Z. Zhang, L. Jin, J. Zhang, J. Lv, and Z. Guo (2023) Implicit event argument extraction with argument-argument relational knowledge. IEEE Transactions on Knowledge and Data Engineering 35 (9), p. 8865–8879. Cited by: §1. [30] S. Xiao, Z. Liu, P. Zhang, N. Muennighoff, D. Lian, and J. Nie (2024) C-pack: packed resources for general chinese embeddings. In Proc. SIGIR’24, p. 641–649. Cited by: §3.3. [31] A. Xydis, C. Hampson, S. Modgil, and E. Black (2020) Enthymemes in dialogues. In Proc. COMMA’20, p. 395–402. Cited by: §1.