A Logic-based Framework for Decoding Enthymemes in Argument Maps Involving Implicitness in Premises and Claims

1 Introduction

There are a number of frameworks for modelling argumentation in logic [Besnard et al., 2014]. They incorporate a formal representation of individual arguments, where the premises imply the claims, and techniques for comparing conflicting arguments. However, real arguments presented by humans usually have insufficient explicit premises to logically infer the claims and/or insufficient explicit claims to logically support or attack the arguments that they are meant to. This is because the proponent of an argument assumes that the proponent and the intended recipient have some shared knowledge (common or commonsense), and this shared knowledge is often not presented explicitly in the argument. An argument with some implicit premises and/or claims is an enthymeme [Walton, 2001; Walton, 2019].

In this paper, we focus on enthymemes arising in argument maps. We assume an argument map is obtained as output from argument mining of a text, e.g. a discussion document,

(see [Lawrence and Reed, 2019] for a review of argument mining). Each node in an argument map denotes an argument (often with some/all of the premises and/or claims being implicit) as illustrated in Figure 1.

Definition 1. Let T be a set of text strings (where each string is a phrase or sentence). An argument map is a tuple (N, P, C, L) where N is a set of nodes; P : N → T ∪{Null} (resp. C : N → T ∪ {Null}) is a text labelling function for premises (resp. claims); And L : N × N → {+,-, ∗} is an arc labelling function, where + (resp. -) represents a support (resp. attack) relationship, and ∗ represents no relationship holds.

Human agents constantly need to understand enthymemes, whether in everyday or professional life, and so we need to replicate this process in computational models of argument. There are proposals for modelling decoding of enthymemes as abduction [Hunter, 2007; Black and Hunter, 2012; Hosseini et al., 2014], and for how this can be undertaken within a dialogue [Black and Hunter, 2008; de Saint-Cyr, 2011b; de Saint-Cyr, 2011a; Xydis et al., 2020; Panisson et al., 2022; Leiva et al., 2023; Xydis et al., 2024]. However, most of these proposals only consider implicitness in premises, and none consider optimization of decoding.

To address these shortcomings, we propose a novel framework that has the following features: (1) A representation of explicit premises (respectively claims) for each node of the argument map as a set of classical logic formulae for the premises (respectively claims) (2) A representation of implicit premises (respectively claims) for each node of the argument map as a set of default rules for the premises (respectively claims); (3) And a mechanism for decoding enthymemes (i.e. identifying the implicit premises and claims) based on maximizing the number of arcs between the logical arguments that agree with the corresponding label in the argument map. In other words, if the argument map has a support (respectively attack) relationship from node n to node m, then the logical argument assigned to n supports (respectively attacks) the logical argument assigned to m. Ideally, there is a (unique) decoding for each enthymeme that satisfies the labelling of arcs in the argument map. If not, we want to make the best compromise for the decoding of the enthymemes.

2 Background

We use L to denote the language of classical logic, α, β, γ, δ, . . . ∈ L for arbitrary formulae of classical logic and ∆, Γ, . . . ⊆ L for arbitrary sets of classical formulae. Let ⊤ (respectively ⊥) denote tautology (respectively contradiction), let ⊢ denote the classical consequence relation, and let Cn be the consequence closure function (i.e. Cn(∆) = {α | ∆ ⊢ α}). For α, β ∈ L, α ≡ β denotes that α and β are equivalent (i.e. {α} ⊢ β and {β} ⊢ α). For ∆, Γ ⊆ L, ∆ ≡ Γ denotes that ∆ and Γ are equivalent (i.e. Cn(∆) = Cn(Γ)).

Our approach is based on default logic [Reiter, 1980]. It is one of the best known and most widely studied formalisations of default reasoning. It offers a very expressive and lucid language, and it captures various kinds of commonsense knowledge [Brewka, 1991; Davis, 2017] that are potentially important in representing implicit knowledge in enthymemes.

In default logic, knowledge is represented as a set of propositional or first-order formulae and a set of default rules for representing default information. A default rule is of the following form (which generalizes natural deduction rules), where α, β and γ are classical formulae.

For this, α is the pre-condition, β is the justification, and γ is the consequent, of the default rule. For convenience, we may represent a default rule inline as α : β/γ. Let D be the set of default rules.

A default theory is a pair (W,D) where W is a set of classical formulae and D is a set of default rules. Default logic extends classical logic. Hence, all classical inferences from the classical information in a default theory are derivable (if there is an extension as defined below). The default theory then augments these classical inferences by default inferences derivable using the default rules: If α is inferred, and ¬β cannot be inferred, then infer γ. The following is a definition for when a default theory has an extension (a set of classical logic formulae that follows from the default theory).

Definition 2. Let (W,D) be a default theory. The operator Pe identifies the conclusions for a given a set of classical

Figure 2: Structure of a default argument where (W p ,Dp ) and (W c ,Dc ) are singular default theories.

formulae E. For this, Pe(E) is the smallest set of classical formulae s.t. the following three conditions are satisfied.

1. W ⊆ Pe(E)
2. Pe(E) = Cn(Pe(E))
3. For each default in α : β/γ ∈ D, the following holds: if α ∈ Pe(E), and ¬β ̸∈ E, then γ ∈ Pe(E)

We refer to E as the satisfaction set, and Pe(E) as the potential extension. Furthermore, E is an extension of (W, D) iff E = Pe(E).

For our definition for default arguments (Definition 4), we need the following subsidiary definition.

Definition 3. A default theory (W,D) is singular iff there is a unique extension of (W,D). When a default theory (W,D) is singular, let Ex(W,D) denote the extension.

Example 1. Let W = {a} and D = {(a : b/b), (b ∨ c : d ∧ f/e)}. The default theory (W,D) is singular and its unique extension is Ex(W,D) = Cn({a, b, e}). In contrast, for D′ = ({(a : b/b), (a : ¬b/¬b)}, (D′ ,W) is not singular, as there are two extensions Cn({a, b}) and Cn({a, ¬b}).

Importantly for our purposes, any default theory with an extension E can be turned into a singular default theory by removing defaults without changing the extension E.

Proposition 1. For a default theory (W,D), if E is an extension of (W,D), and (W,D) is not singular, then there is a default theory (W,D′ ) s.t. D′ ⊆ D and E is an extension of (W,D′ ), and (W,D′ ) is singular 1 .

Example 2. Let D = {a : b/b, a : ¬b/¬b} and W = {a}. So there are two extensions from (W,D) which are E1 = {a, b} and E2 = {a, ¬b}. The subtheory (W,D1) where D1 = {a : b/b} is singular with the extension being E1, and the subtheory (W, D2) where D2 = {a : ¬b/¬b} is singular with the extension being E2.

We use singular default theories in the definition of a default argument (Definition 4) to ensure that the implicit premises (respectively implicit claim) give a single perspective on the explicit premises (respectively explicit claim).

3 Default Arguments

The following definition of default argument is very general. It allows us to represent enthymemes that may have insufficient premises to entail the explicit claim, and/or insufficient claims to attack or support arguments that it is meant to. We will consider constraints on the definition in order to give us appropriate notions of logical argument. We summarize the structure of a default argument in Figure 2.

1 See appendix for proofs and code [David and Hunter, 2025]

-

Definition 4. A default argument is a tuple ⟨W p ,Dp ,W c ,Dc ⟩ where W p ,W c ⊆ L, and Dp ,Dc ⊆ D such that (W p ,Dp ) is singular and (W c ,Dc ) is singular.

For a default argument A = ⟨W p ,Dp ,W c ,Dc ⟩, we refer to W p as the explicit premises, Dp as the implicit premises, W c as the explicit claims, and Dc as the implicit claims. To extract these components, we use the following functions: Ep(A) = W p ; Ip(A) = Dp ; Ec(A) = W c ; and Ic(A) = Dc .

Example 3. The following are examples of default arguments:

Given a default argument A, the support of the argument is the default extension obtained from the implicit and explicit premises, and the consequence of the argument is the default extension obtained from the implicit and explicit claims:

• The support of A is S(A) = Ex(Ep(A), Ip(A)).
• The consequence of A is C(A) = Ex(Ec(A), Ic(A)).

So the support is the set of inferences from the implicit and explicit premises and the consequence is the set inferences from the implicit and explicit claims.

Example 4. Continuing Example 3, for the default argument A to C, we have the following support and consequence.

We explain the definition below as follows: A default argument is valid iff the explicit claims are in the support of the argument (i.e. the extension of the premises); A default argument is implicit premise minimal iff there is no subset of the implicit premises such that the argument is valid; And a default argument is support (respectively consequence) consistent iff the support (respectively consequence) is consistent.

Definition 5. For default argument A: A is valid iff Ec(A) ⊆ S(A); A is implicit premise minimal iff A is valid and there is no D′ ⊂ Ip(A) s.t. Ec(A) ⊆ Ex(Ep(A),D′ ); and A is support consistent (respectively consequence consistent) iff ⊥ ̸∈ S(A) (respectively ⊥ ̸∈ C(A)).

Example 5. For Example 3, A. B, and C, are valid, implicit premise minimal, and support and consequence consistent.

A property of default logic is that an extension of a default theory (W,D) is inconsistent iff W is inconsistent. So for a default argument, the support (respectively consequence) is inconsistent iff the explicit premises (respectively explicit consequence) are inconsistent. Hence, the implicit premises (respectively implicit claims) cannot cause the support (respectively consequence) to be inconsistent.

Example 6. For A = ⟨{a ∧ ¬a}, ∅, {d}, {d : e/e}⟩ is such that ⊥ ∈ S(A) and ⊥ ̸∈ C(A), whereas B = ⟨{a}, {a : b/b}, {d ∧ ¬d}, ∅⟩ is such that ⊥ ̸∈ S(B) and ⊥ ∈ C(B).

Given an argument map, and a set of default arguments, we define a default argument assignment as follows, and illustrate this in Figures 3 and 4.

Definition 6. Let M = (N, P,C,L) be an argument map and let A be a set of default arguments. A default argument assignment for M is a function I : N →A.

We refer to an argument map with a default argument assigned to each node as an instantiated argument map (as illustrated in Figures 3 and 4). So each default argument assignment can be presented as an instantiated argument map.

We now consider some of the options for defining one argument supporting another.

Definition 7. For default arguments A and B, the following are some definitions for A supporting B: A explicit premise supports B iff C(A)∩Ep(B) ̸= ∅; A explicit claim supports B iff C(A) ∩ Ec(B) ̸= ∅; A premise justification supports B iff there exists β ∈ C(A) s.t. there exists α : β/γ ∈ Ip(B); and A claim justification supports B iff there exists β ∈ C(A) s.t. there exists α : β/γ ∈ Ic(B).

Example 7. Consider the following supporting default arguments (left) and supported default arguments (right): A1 explicit premise supports B1; A2 explicit claim supports B2; A3 premise justification supports B3; and A4 claim justification supports B4.

Next, we consider some options for defining one argument attacking another and illustrate them in Figure 5.

Definition 8. For default arguments A and B, the following are some definitions for A attacking B: A undermines B iff there exists ¬β ∈ C(A) s.t. β ∈ Ep(B); A rebuts B iff there exists ¬β ∈ C(A) s.t. β ∈ Ec(B); A undercuts B iff there exists ¬β ∈ C(A) s.t. there exists α : β/γ ∈ Ip(B); and A overcuts B iff there exists ¬β ∈ C(A) s.t. there exists α : β/γ ∈ Ic(B).

A default argument provides a richer representation of an argument than available with other approaches to structured argumentation. As illustrated in Figure 2, this includes the following features which together go beyond other formalisms: (1) Delineation of implicit information connecting premises and claims (i.e. the set Dp is a set of defaults that represents the implicit information in the premises); (2) Logical mechanism for disabling connection between premises and claims (i.e. the justification of each default rule can be negated by the claims of another argument, thereby attacking the connection between the premises and claims); (3) Delineation of implicit information connecting one argument with another (i.e. the set Dc is a set of defaults that represents the implicit information in the claims); (4) Logical mechanism for disabling connection between one argument and another (i.e. the justification of each default rule can be negated by the claims of another argument, thereby attacking the connection between that argument and other arguments).

Definitions 7 and 8 are only some of the possible definitions for support and attack. Whatever definition we use for support and attack, if A is the set of logical arguments, then R+ ⊆ (A×A) (respectively R- ⊆ (A×A)) denotes the set of pairs of logical arguments (A,B) where A supports (respectively attacks) B. Also, let R∗ be the set of pairs of logical argument where A does not support nor attack B (i.e., R∗ = (A × A) \ (R+ ∪ R-)).

The definition for a default argument is very general. As discussed in the next section, it allows for the representation and decoding of enthymemes. We leave to further work the presentation of further interesting classes of default argument, and of further types of attack and support relationship, that can be captured in this framework.

4 Decoding Enthymemes

An enthymeme is an argument with missing premises and/or claims. We start by considering types of enthymeme involving missing premises.

Definition 9. A default argument A is a premise enthymeme iff A is not valid. Additionally, if A is a premise enthymeme and Ip(A) = ∅, then A is an acute premise enthymeme, and if A is a premise enthymeme and Ip(A) = ∅ and Ic(A) = ∅, then A is a full enthymeme.

To illustrate, each default argument in the instantiated argument map in Figure 4 is a full enthymeme.

When we have an argument map M = (N, P, C, L), we assume that for each node n ∈ N, we can use natural language processing on the text P(n) and C(n) to obtain a full enthymeme for that node. So each explicit premise and explicit claim is obtained by translating the text into formulae of classical logic. This gives us a default argument assignment Ie as an initial enthymeme assignment where every default argument that is assigned is a full enthymeme (as illustrated in the instantiated argument map in Figure 4).

Next, we consider types of enthymeme involving missing claims. This is more complicated as we need to consider the relationship of an argument with other arguments.

Definition 10. Let R+ (resp. R-) be a support (resp. attack) relation. For A,B ∈ A, A is a support enthymeme (resp. attack enthymeme) to B iff (A,B) ̸∈ R+ (resp. (A,B) ̸∈ R-). Additionally, if A is a support enthymeme (resp. attack enthymeme) to B, and Ic(A) = ∅, then A is an acute support enthymeme (resp. acute attack enthymeme) to B. If A is a support enthymeme, or attack enthymeme, to B, then A is a claim enthymeme to B.

To illustrate, each default argument in Figure 4 is an acute support enthymeme, and an acute attack enthymeme, to every other default argument in this figure. In this example, no default argument supports or attacks any other.

Next, we consider decoding a premise enthymeme as an abduction problem (drawing on [Eiter et al., 1997]). For this, we assume a default knowledgebase, denoted K, which is a set of default rules. For premise enthymeme A, we want to find a subset of K to add to Ip(A) for it to be valid as follows.

Proposition 2. For default knowledgebase K, the problem of identifying a default argument C for a premise enthymeme A s.t. (1) Ip(C) \ Ip(A) ⊆ K, (2) Ep(A) = Ep(C), (3) Ec(A) = Ec(C), and (4) C is valid, is in ΣP2 .

The above result does not consider implicitness in the claim: If we have a default argument A that is a support enthymeme, or attack enthymeme, for a default argument B, then we need to take B into account in the decoding.

Proposition 3. Let R+ (resp. R-) be a support (resp. attack) relation according to Definition 7 (resp. Definition 8). Let A be a support enthymeme (resp. attack enthymeme) to B. For default knowledgebase K, the problem of identifying a default argument C s.t. (1) Ic(C) \ Ic(A) ⊆ K, (2) Ep(A) = Ep(C), (3) Ec(A) = Ec(C), and (4) (C, B) ∈ R+ (respectively (C, B) ∈ R-), is in ΣP2 .

We want to use the argument map to determine which arguments are claim enthymemes that we need to decode accordingly: If according to the argument map, L(n,m) = + (respectively L(n,m) = -) holds for a pair of nodes n and m, and the default argument A assigned to n, and the default argument B assigned to m, are such that A is a support enthymeme (respectively attack enthymeme) to B, then we want to decode A by adding default rules to the implicit claims of A so that it then supports (respectively attacks) B accordingly.

A further issue is that the choice of implicit premises for each argument can affect what is possible for the choice of implicit claims for the other arguments, as illustrated next.

Example 8. Consider the initial enthymeme assignment where the left (resp. right) node is n1 (resp. n2). From default knowledgebase K = {(a1 ∧ a2 : a3/a4), (a1 ∨ a2 : a4/a4), (⊤ : b1/b1), (b1 ∨ b2 : ¬a3/¬a3)}, suppose we assign A1 = ⟨{a1, a2}, {(a1 ∨ a2 : a4/a4)}, {a4}, ∅⟩ to n1 and A2 = ⟨∅, {(⊤ : b1/b1)}, {b1}, {(b1∨b2 : ¬a3/¬a3)}⟩ to n2, then A2 does not undercut A1. But, we can assign A3 = ⟨{a1, a2}, {(a1 ∧ a2 : a3/a4)}, {a4}, ∅⟩ to n1, and then A2 does undercut A3.

-

To address the issues raised above, we treat decoding of enthymemes as an optimization problem, in the next section.

5 Optimization of Decoding

Ideally, for an argument map M = (N, P, C, L), and an initial enthymeme assignment Ie, we want to find a default argument assignment I that respects the labelling of arcs (i.e.

L). This means that for each arc (n,m) in the argument map, and for each label x ∈ {+,-, ∗}, the following holds L(n,m) = x iff ((I(n), I(m)) ∈ Rx ). So the assignment I would ensure that there is only attack (respectively support) between two default arguments when there is an attack (respectively support) between the corresponding nodes in the argument map, and there is no relation otherwise.

The ideal situation described above cannot be guaranteed in practice. We may be unable to choose a default argument assignment that respects all the arcs in the argument map (as illustrated in Figure 6, where we fail to obtain either an attack or support, and in Figure 7 where we get the required support relations, but also an undesired attack).

We say B is a decoding candidate of full enthymeme A iff B is valid and Ep(A) = Ep(A) and Ec(A) = Ec(B). If there is a decoding candidate B of full enthymeme A, let Cands(K,A) be the set of decoding candidates of A from default knowledgebase K, otherwise let Cands(K,A) = {A}. For an initial enthymeme assignment Ie, a decoding assignment Id is such that, for each n ∈ N, Id(n) ∈ Cands(K, Ie(n)). For an argument map M and a default knowledge base K, let Assigns(M,K) be the set of decodings assignments for M given K.

We score each decoding assignment Id ∈ Assigns(M,K) in terms of the proportion of pairs of nodes in the argument map that are correctly identified as support, attack, or no relationship. First, we define the following set of pairs of nodes that are correctly assigned by Id according to the labelling function L: Correct(R+, R-, Id, L) = {(ni, nj) | for all x ∈ {+,-, ∗}, if (Id(ni), Id(nj)) ∈ Rx , then L(ni, nj) = x}. So 0 ≤ |Correct(R+,R-, Id,L)| ≤ |N × N|. Then, the accuracy of each assignment Id, is defined as follows: If Correct(R+, R-, Id, L) = ∅, then Acc(R+, R-, Id, N, L) = 0, otherwise, Acc(R+, R-, Id, N, L) =

The decoding optimization problem is choosing the decoding assignment Id that maximizes the number of arcs correct w.r.t. to the labelling. For example, for Figure 6, an optimal decoding assignment is I(n1) = A1, I(n2) = B1, and I(n3) = C1, which has one of two arcs correct w.r.t. the labelling in the argument map. So the decoding optimization problem is defined as follows where an optimal solution is a decoding assignment Id with maximum accuracy.

Unfortunately, using the above formula to the optimal decoding assignments is impractical in general since it would involve generating all the decoding assignments. For an argument map M, default knowledgebase K, and initial enthymeme assignment Ie, the cardinality of Assigns(M,K) is ∏n∈N |Cands(K, Ie(n))|, and so if there are many decoding candidates per node, the number of decoding assignments would soon be unmanageable.

To address this problem, we show how we can reduce this optimization problem to a partial MaxSAT problem. Our approach is to translate the possible decoding assignments of the argument map into a set of hard constraints, and then let the choice of arcs be managed by soft constraints. The aim is to maximize the number of arcs that are consistent with the constraints of the possible decoding assignments. For this, we need a set of atoms from which to construct the constraints. Given a default knowledge base K and enthymeme A, each element of Cands(K, A) is treated as an atom, which we refer to as a candidate atom. To illustrate, for Figure 6, the set of candidate atoms is {A1, B1, B2, C1, C2}.

We also need atoms to represent information about the relationships between decoding candidates for each enthymeme A. For default arguments B and C, we require atoms of the form U B C which represents B ∈ Cands(K, Ie(n)), and C ∈ Cands(K, Ie(m)), and x ∈ {+,-, ∗}, and (B,C) ∈ Rx , then L(n,m) ̸= x. In other words, U B C denotes that for the candidate B (respectively C) for a node n (respectively m), the logical relationship from B to C disagrees with the label on the arc from n to m. We refer to each U B C atom as an undesired atom. To illustrate, for Figure 6, the set of undesired atoms is {U B2 A1 , U C1 B1 , U C1 B2 , and U C2 B1 }.

For support relation R+, attack relation R-, default knowledgebase K, initial enthymeme assignment Ie, and labelling function L, let Undes(R+,R-,K, Ie,L) denote the set of undesired atoms (i.e. {U B C | for all x ∈ {+,-, ∗}, if there are n,m ∈ N such that B ∈ Cands(K, Ie(n)), and C ∈ Cands(K, Ie(m)), and (B, C) ∈ Rx , then L(n, m) ̸= x}).

For simplifying the presentation in this paper, we assume the sets R+, R-, and R∗ , are disjoint. In other words, we assume that there are no decoding candidates B and C such that B is both an attacker and a supporter of C. However, in realworld argumentation, this is a possibility, and the methods in this paper can easily be generalized to deal with this.

Given a set of candidate atoms and a set of undesired atoms, we define the constraints as follows.

Definition 11. For Cands(K, Ie(n)) = {B1, . . . , Bk}, where n ∈ N, and for each U B C ∈ Undes(R+,R-,K, Ie,L), Hard1 to Hard3 are hard constraints, and Soft1 is a soft constraint:

• Hard1. B1 ∨ . . . ∨Bk
• Hard2. ¬Bi ∨¬Bj for i, j ∈ {1, . . . , k} s.t. i ̸= j
• Hard3. ¬C ∨¬B ∨U B C
• Soft1. ¬U B C

We explain these constraints as follows: (Hard1) For every node in the argument map, one of the candidate atoms has to be true (i.e. there is an assignment of a decoding candidate for each node); (Hard2) For every node, at most one of the candidates atoms for that node can be true (i.e. there cannot be multiple decoding candidates assigned to the same node); and (Hard3) For every undesired atom, either the undesired atom is true, or one of the candidate atoms associated with that undesired atom is false (i.e. either there is an arc in argument map that has a label that does not agree with the corresponding relationship between the two decoding candidates, or one of those decoding candidates is false); (Soft1) Each soft constraint is the negation of an undesired atom, and so satisfying a soft constraint means making the undesired atom false. Ideally, we want a model that satisfies all four types of constraint. If this is not possible, we seek a model of the hard constraints, and as many of the soft constraints as possible. Hence, we are seeking to maximize the number of undesired atoms that are false.

Given an argument map, and a set of decoding candidates for each node, we obtain the constraints as specified above. These are then given to a partial MaxSAT solver which then finds the models that satisfy the hard constraints, and maximizes the number of soft constraints satisfied. Each of these models specifies a decoding assignment. For a model, each candidate atom true in the model denotes the decoding candidate that is assigned to a node in the argument map by the decoding assignment.

Example 9. Consider Figure 6 where the decoding candidates for n1 (respectively n2 and n3) are {A1}, (respectively {B1, B2}, and {C1, C2}), where R+ = {(B2, A2)} and R- = {(C1, B1)}. The hard constraints are as follows:

The soft constraints are {¬U B2 A1 , ¬U C1 B1 , ¬U C1 B2 , ¬U C2 B1 }. The three optimal MaxSAT models are {A1, B2, C2, U B2 A1 }, {A1, B1, C1, U C1 B1 }, and {A1, B1, C2, U C2 B1 }, giving three optimal decoding assignments I1, I2, and I3 as follows: I1(n1) = A1, I1(n2) = B2, I1(n3) = C2, I2(n1) = A1, I2(n2) = B1, I2(n3) = C1, I3(n1) = A1, I3(n2) = B1, and I3(n3) = C2.

Example 10. Consider Figure 7 where the decoding candidates for n1 (respectively n2 and n3) are {A1, A2}, (respectively {B1, B2}, and {C1, C2}), and where R+ = {(B1, A1), (C1, B1)} and R- = {(C1, A1)}. So we have the following formulae as hard constraints,

and {¬U B1 A2 , ¬U B2 A1 , ¬U B2 A2 , ¬U C1 B2 , ¬U C2 B1 , ¬U C2 B2 , ¬U C1 A1 } as soft constraints. The optimal MaxSAT models are {A1, B1, C1, U C1 A1 }, {A1, B1, C2, U C2 B1 }, and {A2, B1, C1, U B1 A2 }, giving optimal decoding assignments I1, I2, and I3: I1(n1) = A1, I1(n2) = B1, I1(n3) = C1, I2(n1) = A1, I2(n2) = B1 I2(n3) = C2, I3(n1) = A2, I3(n2) = B1, and I3(n3) = C1.

In the next proposition, we show that the partial MaxSAT approach finds the same optimal decoding assignments as the Acc function. For this, we require some subsidiary notation. Let Const(M, K) be a tuple C = (H, S) where H is a set of hard constraints and S is a set of soft constraints for argument map M and knowledgebase K as defined in Definition 11, and for a tuple of hard and soft constraints C = (H, S), let Enum(C) be the set of pairs (X, V ) where X is a model, represented by a set of literals true in the model, that satisfies the hard constraints H and V is the number of weak constraints in S not satisfied by X. Also, let Trans(X) denote the decoding assignment Id where for each n ∈ N, Id(n) = A and X ∩ Cands(K, Ie(n)) = {A}. So Trans(X) selects the decoding candidate for the node that appears in the model.

Proposition 4. For argument map M = (N, P,C,L), support relation R+ (resp. attack relation R-), and default knowledgebase K, there is (X, V ) ∈ Enum(Const(M,K)) s.t. for all (X′ , V ′ ) ∈ Enum(Const(M,K)), X ≤ X′ iff there is Id ∈ arg maxId∈Assigns(M,K) Acc(R+, R-, Id, N, L) s.t. Trans(X) = Id and Acc(R+,R-, Id,N,L) = (1 - V )/|N|2 .

In order to investigate the viability of our approach, we implemented a system (see supplementary material for code) that takes an argument map, and the attack and support relations between a set of decodings, and determines an optimal decoding assignment using the PySAT MaxSAT library [Ignatiev et al., 2018] running on a Windows 11 laptop with an AMD Ryzen 7 5700U processer and 8GB RAM. For evaluation, we randomly generated argument maps with probability of 0.1 of a support or attack between each pair of nodes, and for each pair of nodes, we randomly generated the relationships between candidate decodings with a probability of 0.9 of the decodings agreeing with a support or attack label between the nodes. The results in Figure 8 show the time taken increases exponentially with the number of nodes in the argument map, and the number of decodings per node.

Even for a larger argument map with 100 nodes, and 50 candidates per node, the time is below 3 seconds. Handling 100 nodes is practically useful as human-generated argumentation often involves fewer than 100 arguments (e.g. [Lynch et al., 2012]). Handling 50 decodings per node also seems useful as it would support a large default knowledgebase for decoding. We will investigate this in future work.

Our partial MaxSAT method is significantly better than a naive approach based on constructing and evaluating all the logical assignment functions using Equation 2. We implemented the naive approach in python on the same machine. The results in Table 1 show that the naive approach only works for a much smaller number of candidates and nodes.

6 Discussion

In this paper, we have provided a logic-based framework for representing the explicit and implicit aspects of each argument in an argument map. We assume that the text in an argument map can be used to give the initial enthymeme assignment. With the advent of deep learning and large language models, it appears feasible to develop robust, and scalable, methods for translating the natural language text into logic (e.g. [Singh et al., 2020; Levkovskyi and Li, 2021; Lu et al., 2022; Pan et al., 2023; Olausson et al., 2023; Lalwani et al., 2024; Lee et al., 2025]. Therefore, it ap- Number of nodes in argument map pears feasible to translate the text that appears in the premises and claims of the nodes in the argument map into formulae of classical logic and therefore assign a full enthymeme to each node. Our proposal allows for the full enthymemes in an initial enthymeme assignment to be formalized, and then systematically decoded using a default knowledgebase. Using default logic as the basis for representing implicit knowledge provides a rich and clear formalism. Optimal decoding assignments can be generated and compared, and differences between a decoding, and the original argument map, can be investigated. So our methods offer automated analysis of the output of argument mining by clarifying the implicitness. This is a first step towards investigating the ambiguity and uncertainty arising with enthymemes in real-world argumentation. Whilst, we have only discussed the propositional version of default logic in this paper, the first-order version of default logic can be used directly with our proposal for richer representation and reasoning with arguments.

Figure 8: Experimental results for average time taken for finding an optimal decoding assignment for a randomly generated argument map (average of 100 randomly generated argument maps). Each line is for c ∈ {10, 15, 20, 25} candidate decodings per node.

Our approach subsumes deductive argumentation with classical logic since classical formalae are a special case of normal default rules where the precondition is tautology. As a result it is straightforward to capture (and extend upon) a wide range of attack relationships [Besnard and Hunter, 2001; Gorogiannis and Hunter, 2011] and support relationships [Hunter, 2023]. In contrast to ASPIC+ [Modgil and Prakken, 2014], assumption-based argumentation (ABA) [Toni, 2014], and proposals for using default logic for modelling arguments [Prakken, 1993; Santos and Martins, 2008], our proposal clearly demarks the implicit premises and implicit claims in a structured argument representation of an enthymeme, and it goes beyond these proposals by offering a wide range of definitions for support and attack between arguments. More importantly, our proposal introduces the modelling of implicit claims, and how decoding can be optimized in order to maximize the agreement with the labeling of an argument map.

Acknowledgements

The work by Victor David was supported by the French government, managed by the Agence Nationale de la Recherche under the Plan d'Investissement France 2030, as part of the Initiative d'Excellence d'Universit´e Cˆote d'Azur under the reference ANR-15-IDEX-01.