From Data to Arguments: A Unified Paradigm for Explainable Artificial Intelligence

Explainable Artificial Intelligence (XAI) represents an active discipline dedicated to clarifying the internal mechanisms of AI systems, thereby fostering stakeholder confidence and advancing the deployment of accountable technology. A primary theoretical hurdle within XAI involves engineering techniques capable of producing clear, accessible interpretations without sacrificing scalability or operational performance in intricate domains. While rule-based methodologies offer a framework for decoding AI-driven conclusions, they are prone to becoming overly complex in dense environments, which diminishes both their comprehensibility and computational scalability. Furthermore, these approaches frequently overlook contrastive logic, which leaves observers unable to discern why a specific outcome was prioritized over alternatives. To resolve this underlying scientific problem, this research investigates the fusion of computational argumentation—a specialized domain of AI that replicates cognitive processes through defeasible reasoning—with rule-based XAI architectures. Computational argumentation provides a mechanism whereby arguments derived from structured rules can be invalidated or withdrawn when confronted with conflicting evidence. Consequently, this framework offers a compelling avenue for refining rule-based systems to yield more transparent AI models. Despite the synergistic benefits of combining rule-based structures with computational argumentation, academic inquiry into their synthesis remains sparse. Accordingly, this paper also targets the practical engineering challenge of realizing this conceptual integration within functional AI software. This investigation utilizes the Logic Learning Machine (LLM)—a specialized rule-extraction methodology—and introduces a modular framework designed to map input rules directly into a structured argumentation network via state-of-the-art argumentation techniques. Empirical evaluations performed on various binary classification problems from the UCI Machine Learning Repository validate the utility of this combined model. The LLM strategy proved highly proficient at extracting a compact, interpretable collection of if-then rules characterized by minimal antecedent premises, all while sustaining strong predictive accuracy across all evaluated datasets. Concurrently, the argumentation-based models delivered classification performance comparable to the native if-then rule configurations, achieving this through a streamlined rule set while offering vastly superior explainability. Ultimately, this work delivers an innovative framework for the automated and streamlined generation of arguments and their internal conflicts directly from raw data, simultaneously addressing fundamental theoretical and practical barriers to propagate argumentation frameworks within the XAI landscape.

Explainable Artificial Intelligence (XAI) is a prominent field of research concentrated on decoding how machine learning models formulate specific inferences. A core objective of this discipline is the design and execution of methodologies that extract highly interpretable and explicit models from empirical data. To be effective, these models must simultaneously maintain elevated predictive precision, structural transparency, and complete intelligibility for human operators. Cultivating these attributes is essential for bolstering human reliance on automated systems and ensuring the development of ethical, dependable AI architectures [1, 2]. Among the diverse paradigms within XAI, rule-based approaches occupy a significant position. The foundational logic behind utilizing rules is their intrinsic accessibility and clarity to human users, which aids in demystifying the internal inferential logic governing complex AI models [3]. For instance, traditional decision trees are capable of generating explicit if-then logic tracks [4], whereas systems rooted in fuzzy logic yield nuanced fuzzy rules [5]. Even so, these rule sets can become intensely convoluted when applied to high-dimensional scenarios, introducing substantial bottlenecks regarding cognitive readability and computational scalability. As an illustration, while deep decision trees often exhibit high precision, their extensive branching produces protracted, overly complex rules that are unmanageable for human review. Additionally, such paradigms routinely fail to supply contrastive rules [3], which are vital for helping users understand the precise reasons why a model favored one specific prediction over an alternative option [6]. For this reason, a fundamental theoretical challenge in XAI centers on creating methodologies that deliver clear, understandable explanations while remaining scalable and functional in highly intricate settings.

An established branch of artificial intelligence is automated reasoning, which translates human intellectual processes into computational workflows. Within this domain, computational argumentation stands out as a specialized sub-field focused on operationalizing these cognitive models [7, 8]. From a technical standpoint, defeasible reasoning operates as a form of non-monotonic logic [9, 10] that evaluates distinct rationale—frequently structured as rules or "arguments"—within an interactive, dialogical framework [11]. This specific architecture accommodates the formal revocation of previously established assertions or conclusions when new data or counter-arguments emerge to invalidate them. As a result, computational argumentation represents a highly suitable mechanism for designing efficient XAI protocols [12]. This compatibility stems from its foundational syntax (rules and arguments) paired with its capacity to simulate human reasoning when navigating uncertain, conflicting, or contrastive knowledge states. Computational argumentation is therefore exceptionally well-suited for interpretability tasks [13] and serves as an optimal baseline for constructing explainable AI frameworks [14]. Yet, despite the clear complementary advantages of rule-based systems and computational argumentation, research at their nexus remains minimal [15]. This investigation directly addresses the practical challenge of implementing this conceptual fusion within operational AI tools. Specifically, the study contributes to this domain by exploiting the unique capabilities of a rule-extraction algorithm known as the Logic Learning Machine (LLM) [16] to extract crisp if-then rules, which are subsequently converted into a structured argumentation framework [7] utilizing advanced computational argumentation techniques. A exploratory comparative evaluation is detailed for classification operations across datasets of varying scales. For every dataset, if-then rules are generated via the LLM technique to target a designated target class. In instances where an individual data record satisfies multiple, conflicting rules, these discrepancies are handled via two distinct paradigms. The first approach utilizes the Standard Applied Procedure, a traditional heuristic mechanism that weights individual rules based on their breadth of coverage (generality) and their historical error rate (precision). The definitive prediction for any given data instance is determined by identifying the target classification that accumulates the highest cumulative weight from all validated rules. The second paradigm resolves these conflicts through the deployment of computational argumentation frameworks.

Rule-based explainable artificial intelligence

The core obstacle restricting the widespread acceptance of most AI-driven frameworks is their lack of comprehensibility, commonly referred to as the black-box dilemma. This phenomenon describes the immense difficulty encountered by both specialists and non-expert users when attempting to comprehend the underlying reasoning pathways of these systems and how their final outputs are produced. Explainable Artificial Intelligence (XAI) is an accelerating discipline dedicated to rendering these opaque AI structures transparent, interpretable, and intelligible, among other essential traits [15]. A multitude of methodologies have been engineered and operationalized, with numerous alternative strategies currently under development. As an illustration, certain investigators [17] have worked toward establishing grey-box architectures, which aim to inject structural interpretability into otherwise uninterpretable models. While completely transitioning a black-box system into a fully transparent white-box model is not always attainable or practical, XAI acts as an intermediary solution by making black-box architectures more accessible and transparent through a variety of explanatory techniques. Another distinct category within these approaches comprises rule-based methodologies [15]. These frameworks are uniquely compelling because rules reflect the standard logical formulations utilized in human cognition to validate assertions, and they are widely acknowledged to possess high levels of clarity and explanatory value. Specifically, within this domain, systems that formulate if-then rules—such as Decision Trees (DTs) [18] and the Logic Learning Machine (LLM) [19]—provide an effective strategy for constructing predictive systems whose deductive paths can be readily parsed and understood, thereby serving as a foundation for justification and interpretation. This benefit is principally due to their capacity to regulate the upper limits of antecedent conditions and error thresholds assigned to individual rules, which minimizes the total quantity of generated rules while sustaining a powerful predictive performance [20]. This methodology has been deployed across diverse biomedical scenarios [21], including the investigation of gene expression profiles for oncological diagnosis [22] and the prediction of clinical disease risks [23].

Even though rule-based paradigms provide highly advantageous characteristics for extracting interpretable architectures from empirical data, they exhibit poor capabilities when managing contrastive logical paths and internal conflicts. Restated, they frequently lack structured approaches for managing rules that conflict within their antecedent configurations or their consequent spaces, which prevents them from formulating comprehensive explanations for users. A comprehensive literature review outlines multiple tactics designed to resolve contradictions within rule-based tools [24]. The CN2 algorithm [25] addresses rule contradictions by calculating, for each individual rule r and every available target class o, the exact quantity of training instances belonging to class o that are encompassed by rule r; the target class exhibiting the highest frequency is subsequently designated as the system's prediction. Another prevalent method for mitigating rule conflict is the voting mechanism [26, 27]. In this setup, every applicable rule submits a vote toward its designated target class scaled by a weight equivalent to the historical probability of that specific class; these votes are mathematically aggregated, and the target class accumulating the greatest total probability is selected as the definitive prediction. Alternative techniques for navigating rule-based contradictions are detailed in [28, 29]. In the former study, the authors propose leveraging the training data situated precisely at the intersection of the conflicting rules to determine the appropriate output class. If no training data exists within that intersection, partitioning logic is introduced to divide the rules into as few non-empty subsets as possible, which are then used to identify the most probable output class. The latter study introduces Double Induction, an approach designed to generate completely new rules derived from the training samples captured by the conflicting rule sets. These newly formulated rules are subsequently used to categorize the unlabelled data record. This strategy has been further developed into an updated framework known as Recursive Induction [24]. An alternative technique for resolving contradictions between active rules is the Standard Applied Procedure, which is the specific methodology utilized in this investigation. Within this approach, the assigned weight of a given rule is determined by its breadth of coverage and its accuracy across the training partition, relative to how these performance metrics compare against other rules targeting the identical classification output.

 Argument-based XAI and defeasible reasoning

Computational argumentation inherently addresses the limitations outlined above and maintains a direct, fundamental relationship with Explainable Artificial Intelligence [13]. This connection is established because XAI strategies are strengthened by clarifying and defending the deductive assertions made by AI frameworks. Concurrently, computational argumentation focuses on developing systems that systematically link these outputs to the underlying empirical evidence that justifies them. Specifically, architectures grounded in computational argumentation are capable of demonstrating the step-by-step logical sequence through which an AI model arrives at a definitive conclusion, thereby delivering transparent justifications to human operators [12]. This operational clarity provides a distinct benefit over alternative white-box architectures, such as those relying on Bayesian networks. The argument-based strategy is predominantly qualitative, centering on the underlying composition and logical flow of individual arguments, whereas the Bayesian network approach [30] is quantitative, emphasizing statistical inference and the algorithmic management of uncertainty. Its reasoning pathway is more mathematical and relies strictly on the foundational language of probability theory. Choosing between these distinct methodologies depends on the intrinsic attributes of the problem under analysis, alongside the specific requirements regarding structural interpretability and the preferred style of reasoning. In short, although both the argument-based framework and the Bayesian network approach can be categorized as white-box models due to their interpretable designs, they differ fundamentally in their underlying logical methodologies.

The theoretical intersection between XAI techniques and computational argumentation is extensively examined in [31]. Along these lines, arguments can be effectively utilized to map out the specific rationales that prompt an autonomous agent to execute a given action, while argumentation semantics serve to isolate the permissible arguments within a scenario involving disaster response rescue robots [32]. A specialized field where computational argumentation can dramatically enhance the interpretability and transparency of AI-driven systems is medical informatics [33]. Argumentative frameworks possess structural traits and behavioral features that closely mirror the cognitive workflows routinely executed by humans to reason, justify conclusions, and explain decisions under conditions of uncertainty, such as those found in clinical informatics. Specifically, due to their multi-faceted dialectical states, they are capable of producing diverse analytical abstractions that are profoundly integrated with the concepts of explanation and justification [31]. This sophisticated dialectical status can be realized by implementing formalized argumentation semantics [34-37] as demonstrated in [38]. In essence, these semantics operate as targeted strategies for resolving underlying conflicts among competing arguments, which are frequently represented in the form of rules [39]. Prior work has attempted to deploy these techniques to construct predictive models, mapping automated choices directly into an argumentation framework governed by predefined attack configurations between individual arguments (logical rules) [14, 18]. These systematic attack relationships between arguments can generate highly justifiable decisions, clearly revealing the exact sequential steps taken to reach them. Conceptually, this framework introduces the strengths of symbolic, non-monotonic logic into empirical, data-driven predictive systems. Even so, it frequently encounters bottlenecks regarding its total inferential capacity when applied across heterogeneous tasks. Recent investigations [13, 40] have attempted to combine machine learning (ML) models with argumentation frameworks, aiming to pair the predictive strength of the former with the explanatory utility of the latter. Reviewing these dynamics suggests that the integrated approach proposed here could yield more transparent systems while successfully preserving robust classification accuracy.

 Argument-based XAI

Explainable Artificial Intelligence and computational argumentation are deeply intertwined, as evidenced by recent trends where argumentation is increasingly applied to supply explanatory frameworks for AI systems [13]. This natural alignment stems from the reality that XAI methodologies benefit heavily from clarifying and defending their computational outputs, whereas argumentation provides a rigorous mathematical mechanism for anchoring any automated decision to the specific evidence that supports it. Argumentation is capable of outlining, in a step-by-step fashion, exactly how an AI system arrives at a given conclusion, thereby elucidating predictions for human operators [12]. A clear illustration of this cooperative dynamic is detailed in [31], which delivers a comprehensive review of XAI frameworks developed via computational argumentation methods, alongside an argument-based paradigm for engineering interpretable Beliefs-Desires-Intentions (BDI) agents. Correspondingly, in a multi-agent environment featuring search-and-rescue robotics, arguments were harnessed to represent the distinct motivations an autonomous agent could use to validate a specific choice. Argumentation semantics were then employed to establish which of these motivations could be legitimately accepted [32]. This fundamental bridge between explainable AI (XAI) and argumentation is driven by the requirement that the former must clarify and defend its outputs, while the latter yields a practical, computational suite of tools designed to link any automated inference directly to its validating evidence [12]. Computational argumentation has also been leveraged to generate dialectically explainable predictions [41]. Specifically, a dedicated framework was engineered to extract argumentative debates directly from raw data tracks, ensuring that their final dialectical configurations correspond directly to actionable predictions, such as classifications that can be explained through dialectical discourse. In this setting, the debates consist of data-derived informational components that may not be linguistic in nature but function as arguments because they are dialectically linked—for example, by expressing disagreement regarding assigned data classifications. This interactive, dialectical engagement with argument-driven systems can significantly improve human comprehension and reinforce the development of trustworthy AI. In a manner analogous to structured debates, dialogue games based on arguments and their shifting dialectical statuses can be effectively tailored to satisfy the specific explanatory requirements of users [42]. Furthermore, the deployment of computational argumentation has been evaluated within the domain of medical informatics, given the intense contemporary interest in designing explainable AI to assist with clinical decision-making and diagnostic tasks, while simultaneously factoring in operational risks and liabilities for medical practitioners [33]. Closely aligned with this, argumentative frameworks—by virtue of their dialectical traits—possess operational qualities and characteristics that closely replicate the cognitive processes routinely performed by humans to reason and explain, particularly within medical environments.

This section outlines the theoretical frameworks underpinning the chosen methodology.

Rule generator: the logic learning machine

Operating as a rule-based methodology, the Logic Learning Machine (LLM) maps input data into a Boolean domain. In this space, distinct Boolean functions—corresponding to each potential output class—are reconstructed using a subset of their truth tables via the approach presented in [16]. This technique extracts easily interpretable rules through Boolean function synthesis, executing across four core phases: (a) Discretization; (b) Latticization or Binarization; (c) Positive Boolean function; and (d) Rule generation.

Discretization

During this initial phase, continuous variable domains are mapped into discrete spaces via the function 𝜓_𝑗:𝑋_𝑗→𝕀_𝑀, where Xj represents the domain of the j-th variable and 𝕀_𝑀={1,…,𝑀} denotes the set of positive integers bounded by M. This mapping process must maintain the original order of the data points. Specifically, if xij≤xkj, it is required that (𝑥_𝑖)≤𝜓_𝑗(𝑥_𝑘),∀𝑖=1,…,𝑑. The mapping function 𝜓𝑗 can be characterized by a vector 𝛾_𝑗=(𝛾₁,…,𝛾_𝑚−1) such that:

Establishing the optimal thresholds for this discretization can be framed as a minimization problem. The objective is to reduce the total number of cutoffs to a minimum while satisfying the constraint outlined in the previous equation. To formally define this optimization, let 𝜏_𝑗𝑙 and 𝑋_𝑗𝑖𝑘 be introduced for 𝑗∈{1,…,𝑑} and 𝑖,𝑘∈{1,…,𝑁} and 𝑙∈{1,…,𝛼_𝑗}. Here, 𝑋_𝑗𝑖𝑘 represents the index set l where 𝑥_𝑖𝑗<𝜌_𝑗𝑙<𝑥_𝑘𝑗 and 𝜏_𝑗𝑙  represents binary values indicating whether 𝜌_𝑗𝑙 serves as a valid cutoff for the j-th variable:

Accordingly, the optimization model is formulated as:

When the underlying training data contains inconsistencies, the discretization procedure must simultaneously minimize both these ambiguities and the overall cutoff count. This is achieved by softening the constraints through auxiliary variables that regulate constraint violations. Conversely, stricter boundaries can be enforced by requiring that data points from opposing classes are partitioned by a minimum of q>1 unique variables. Given that this optimization problem involves a high volume of variables, it can become computationally expensive. A practical strategy for identifying a near-optimal solution is to implement a heuristic greedy technique, such as Attribute Driven Incremental Discretization (ADID) [43, 44]. The ADID algorithm relies on the concept of effective distance, denoted as 𝑑_eff, which calculates how many inputs partition two distinct data points:

Based on this effective distance, a pair of data points 𝑥_𝑖,  is definitively separated if 𝑑_eff(𝑥_𝑖,𝑥_𝑘)≥𝑞. For every potential threshold candidate, the following components are defined:

• The subsets , containing the data points partitioned by the threshold 𝜌_𝑗𝑙:

• A counter 𝑣_𝑗𝑙  that tracks the volume of data points definitively partitioned by 𝜌_𝑗𝑙:

• The metric 𝑤_𝑗𝑙 evaluating the aggregate effective distance between separate classes that are definitively partitioned by 𝜌_𝑗𝑙:

Utilizing these parameters, the ADID heuristic initializes with an empty set. Iteratively, it introduces the specific cutoff that maximizes 𝑣𝑗𝑙, utilizing the minimization of 𝑤𝑗𝑙 as a secondary selection criterion. Following each addition, 𝑣𝑗𝑙 and 𝑤𝑗𝑙 undergo recalculation relative to the newly integrated threshold. This iterative expansion continues until 𝑣_𝑗𝑙=0∀𝜌_𝑗𝑙. After isolating the optimal thresholds from \rhoj, their exact boundaries can be adjusted by calculating the median point between adjacent boundary instances, as formulated below:

Prior to executing the binarization stage, categorical features must be transformed. This conversion is more straightforward than continuous variable handling, requiring only the assignment of a unique integer to represent each categorical state.

Binarization

This phase focuses on converting each discretized space into a binary format via a mapping function 𝜙:→{0,1}^𝑀𝑗, where  represents the domain of the j-th variable and {0,1}^𝑀𝑗 represents a bit string containing a single bit for every potential value within . It is critical that this mapping preserves data ranking, meaning 𝑢<𝑣 holds if and only if (𝑢)<𝜙(𝑣), where the standard ordering sequence for z and 𝑤∈{0,1}^𝑀𝑗 is structured as:

When the condition in the formula above is met, z is said to cover w. A highly effective approach for 𝜙_𝑗  is inverse-only coding. For every 𝑘∈𝐼 , this technique generates a binary string ℎ∈{0,1}^𝑀𝑗 wherein all bits are set to 1, save for the k-th position, which is set to 0. As an illustration, if xij=3 within the domain I5, the mapping yields (𝑥_𝑖)=11011. Consequently, (𝑥_𝑖)=𝑧_𝑖,, where 𝑧_𝑖  is constructed by joining the outputs of 𝜙_𝑗(𝑥) for 𝑗=1,…,𝑑. The transformed training dataset is thus represented as 𝑆′=, where 𝑧_𝑖∈{0,1}^𝐵, and 𝐵 = 𝑀_𝑗.

Synthesis of the boolean function

The post-binarization training set S' can be partitioned into distinct subsets matching their respective target classes: T accumulates instances (𝑧_𝑖,)  where yi=1, while F groups the remaining instances where yi=0. The sets T and F serve as localized representations of the truth table for the target Boolean function f that needs to be modeled. Adhering to the terminologies established in [45], several notations are defined:

• Standard Boolean algebra relies on the logical operators AND, OR, and NOT to construct functions; excluding the NOT operator simplifies this structure into a Boolean lattice. The remainder of this discussion focuses exclusively on the Boolean lattice framework.

• The logical summation (OR) and multiplication (AND) across a series of m components are represented by:

• A conjunctive clause is categorized as an implicant of a target function f if it satisfies the relationship 𝑧_𝑗≤𝑓, where each constituent component zj represents a literal.

To extract these implicants, the LLM framework utilizes a method known as Shadow Clustering [46], which isolates implicants for f by evaluating the Boolean lattice {0,1}^𝐵. This algorithm targets a specific node within the lattice diagram and isolates base vertices (T,) by tracing downward paths. Moving lower from one node to another corresponds to switching a single bit component from 1 to 0. A base vertex is integrated into A if any subsequent downward step transitions into a node situated within the lower shadow of an element w∈ F. The process initiates from a node chosen among the subsets 𝑧∈𝑇⊂{0,1}^𝐵 that do not encompass any point a∈ A where a≤ z. The routine completes once every element in T encompasses at least one element in A. Because the resulting set A frequently contains redundant components, it must undergo a simplification phase to yield A*, which provides the Positive Disjunctive Normal Form (PDNF) for the positive Boolean function.

Multiple variations of Shadow Clustering exist, distinguished by the criteria used to select which bit is flipped from 1 to 0 during the downward traversal of the lattice. For instance, Exhaustive Shadow Clustering (ESC) extracts all possible base vertices originating from the initial node. Due to the heavy computational burden of ESC, greedy strategies are generally preferred. These variations alter the i-th component of the active node at each progression to limit the complexity of the resulting function, assessing complexity by both the number of implicants and the count of literals within each implicant. An example is Maximum-covering Shadow Clustering (MSC), which targets the component that maximizes the potential coverage linked to that variable index at each step. Here, the potential coverage gained by flipping index i from 1 to 0 corresponds to the total number of elements 𝑧∈𝑇 where 𝑧_𝑖=0. To isolate the subset 𝐴^∗⊂𝐴, a common approach is to incrementally add elements from A that encompass the highest volume of points in T not yet encompassed by existing members of A*. Ultimately, these synthesized Boolean functions allow for the formulation of logical rules. These rules can be deployed across datasets to generate classifications once any conflicting rule outputs have been resolved, a process detailed in the following subsection.

Rule Generation

Let 𝑟_𝑖  represent the i-th rule. The general architecture of any given rule  _𝑖   can be formally expressed as:

where the symbol ⋀ signifies a logical conjunction (AND), ℱ_𝑖𝑗(𝑣_𝑖𝑗) corresponds to the j-th descriptive attribute alongside its specific assigned value or interval boundary 𝑣_𝑖𝑗  within rule ri, yi represents the target classification outcome linked to rule ri, and mi indicates the aggregate number of antecedent conditions (features) comprising rule ri. The extraction of these logical constructs is driven by the previously established Boolean functions. Specifically, an interpretable classification rule is derived by systematically converting each underlying implicant from the positive Boolean function f. A distinct function is constructed for every separate target class, making the resulting rules entirely dependent on the characteristics of f.

This transformation framework relies directly on the encoding scheme executed during the binarization phase. Because the binary vector z is constructed by merging the outputs of the mapping function \phi(x) for each dimensions 𝑗=1,…,, it can be partitioned into distinct sub-vectors hj for each attribute. Every individual bit zi∈ hj maps to a categorical state if the variable Xj is nominal, whereas it maps to a continuous range if Xj is an ordered variable. For every individual implicant, a conditional statement in an if-then format is constructed by determining the state of each variable Xj via the following criteria:

• If zi=0 across all elements within hj, no restrictive condition regarding attribute Xj is embedded into the rule.

• For nominal attributes Xj, a membership condition Xj∈ V is integrated, where V aggregates the qualitative states matched to each bit where zi=0∈ hj.

• For ordered attributes Xj, a boundary condition Xj∈ V is integrated, where V represents the combination of numeric intervals paired with each bit where zi=0∈ hj.

By convention, when these numeric boundaries are finite, the maximum parameter (upper limit) is included within the rule's constraint, while the minimum parameter (lower limit) is strictly excluded.

The nature and volume of the synthesized rule base can be adjusted using several optimization parameters, including:

• The target quantity of rules allocated per classification outcome, which dictates the cumulative density of the generated rule set;

• The upper limit of permissible conditions per rule, which restricts the total number of antecedent premises from surpassing a predefined cap;

• The maximum permissible error rate (expressed as a percentage) that an individual rule is allowed to exhibit.

Adjusting these configuration metrics allows for precise calibration of the final rule set's operational properties. Rules delineating the alternate target class are formulated simply by transposing the binary indicators, substituting label C0 with 1 and C1 with 0. For multi-class classification scenarios, the overarching problem is broken down into a series of isolated binary sub-problems. Utilizing standard One-vs-Rest (OVR) methodology, the specific class under evaluation in each sub-problem is designated as 1, while all remaining categories are combined and labeled as 0.

Rules aggregator logic: standard applied procedure

During the deployment of a Logic Learning Machine configuration, an unseen test instance might trigger multiple rules that conflict by predicting opposing classification categories. To resolve these conflicts, the definitive classification outcome is determined via the Standard Applied Procedure, an approach rooted in assessing individual rule relevance. To formulate this relevance metric, four baseline counts regarding a given rule r structured as IF THEN must be computed across the training dataset:

• 𝜈_1𝑟 counts the training samples that concurrently satisfy both the antecedent premises and the consequent label of rule r;

• 𝜈_2𝑟 counts the training samples that satisfy the antecedent premises but contradict the consequent label of rule r;

• 𝜈_3𝑟 counts the training samples that fail to satisfy the antecedent premises and also do not match the consequent label of rule r;

• 𝜈_4𝑟 counts the training samples that fail to satisfy the antecedent premises but match the consequent label of rule r.

It should be noted that a given sample xi fulfills the antecedent of rule r only if it simultaneously satisfies every single component condition; conversely, xi fails to fulfill the antecedent if it violates at least one conditional constraint. By synthesizing these four fundamental counts, two distinct performance metrics can be established for any rule r:

• Covering:

  (12)

• Error:

Logically, a higher covering capacity enhances the overall importance and applicability of a rule, whereas an elevated error rate diminishes its dependability. Consequently, the total relevance score of an isolated rule r is derived by combining Cr and Er as follows:

Once this relevance metric has been calculated, it can be leveraged to compute a cumulative score S(xi,c) for each individual class c, quantifying the likelihood that the true label satisfies yi=c:

where the active rule set is defined as ={𝑟|𝑟∈𝑅,𝑟≤𝑥_𝑖,𝑂(𝑟)=𝑐}. In this notation, R represents the entire derived rule repository, r ≤ xi indicates that sample xi triggers the conditions of rule rSplit, and O(r)=c specifies that the conclusion of rule r forecasts class c. Thus, R(xi, c) isolates the specific cohort of rules triggered by xi that unanimously forecast class c.

By evaluating these cumulative scores across all potential classifications, the conditional probability that yi=c can be established:

Ultimately, the final classification assigned to the instance is the specific category that yields the highest conditional probability value:

Rules aggregator logic: computational argumentation

In contrast to traditional expert systems that typically rely on monotonic logic structures to synthesize rules, defeasible reasoning models deploy a non-monotonic logical framework [14]. Systems engineered around this non-monotonic logic are generally organized into sequential processing tiers [40], operating through the following orderly phases: (a) Constructing the structural components of arguments; (b) Mapping the conflicts that arise between these arguments; (c) Appraising the severity and dynamics of these argumentative conflicts; (d) Assigning a dialectical status to each participating argument; and (e) Combining the validated, acceptable arguments to compute a unified final inference (as illustrated on the right side of Figure 1). The formal mechanisms required to execute each of these successive steps are detailed below.

Creation of the structure of arguments

The framework proposed in this study treats the extracted if-then rules directly as defeasible arguments. These arguments correspond to the logical statements produced via the workflow. A key implication of this modeling choice is that the resulting arguments are non-strict, meaning they are subject to retraction or cancellation when countered by conflicting evidence contained within opposing arguments.

Conflicts of arguments

To successfully implement a non-monotonic, defeasible logic system, the interactive dynamics and friction between arguments must be rigorously formalized. Because the rules synthesized by the LLM generator rely on a binary decision-making framework, each rule inevitably points toward one of two competing outcomes or claims, necessitating a clear resolution and exclusion framework. Within abstract argumentation theory, this dynamic can be formalised using the concept of an "attack"—a targeted structural expression of logical conflict. In this context, any argument that yields a particular conclusion inherently attacks any opposing argument that claims a different outcome. In literature, this specific conflict topology is classified as a rebuttal attack, which occurs when the thesis of one argument directly invalidates or negates the conclusion brought forward by another [40, 47].

This relationship forms an initial multipartite argumentation graph, where every argument supporting a given claim mounts an attack against all arguments aligned with a contradictory claim. An abstract example of this structure, featuring two potential output classes y1 and y2, is provided in Figure 2.

Evaluation of conflicts

The generation of an argumentation graph from logical if-then rules can be populated with empirical data, aligning with the concept of instantiation-based argumentation [48]. The activation or dismissal of specific arguments depends on the truth value of their underlying premises. Consequently, this process gives rise to an instantiated abstract argumentation framework, which constitutes a localized subset of the overarching multi-partite argumentation graph. As a result, the conflict relations (attacks) characterized within the comprehensive multi-partite graph are similarly activated. Specifically, attacks function as binary relations where an attack relation becomes active if and only if both the source argument (the attacker) and the target argument (the entity being attacked) are concurrently activated.

Because the multi-partite layout is deliberately structured around dual sets of arguments for binary classification tasks—where each set contains claims supporting an opposing outcome—the consequences of their friction result in two distinct possible outcomes. To refine how these opposing claims are assessed, this research incorporates the concept of an inconsistency budget [49-53]. This budget acts as a specific threshold defining the maximum level of conflict that can be tolerated. Under a designated inconsistency budget 𝛽, the framework only accommodates a collection of attacks if the cumulative sum of their respective weights does not exceed 𝛽.

To assign weights to these arguments, the relevance score derived from each if-then rule (Eq. 14) is utilized. Specifically, the weight assigned to any given attack relation is determined by summing the individual weights of its constituent source and target arguments. The total combined weight of all active attacks within an instantiated framework dictates the upper bound for 𝛽 within the graph. When 𝛽 is restricted, conflict relations must be systematically pruned until the total weight complies with the specified threshold, adhering strictly to the following three sequential priorities (ordered from highest to lowest significance):

• P1: Rebuttal attacks.

• P2: Attacks possessing a lower weight.

• P3: In instances of identical weights, the attack originating from the source argument with the lower weight.

Because the rules produced by the LLM methodology invariably construct multipartite configurations, the primary priority (P1) is established to mitigate the substantial volume of inconsistencies generated by mutual rebuttals. Stated differently, resolving a mutual rebuttal by eliminating an attack link is favored over removing a directional, one-way attack between two distinct arguments. Conversely, eliminating all internal conflicts would cause unresolved scenarios where conflicting arguments favoring different classifications are endorsed simultaneously. Following the mitigation of rebuttals, P2 and P3 function to prioritize the retention of more authoritative arguments, determined by the weight values calculated from rule coverage and error metrics. Once the permissible attacks under a given budget are established, their respective dialectical status can be computed as detailed in the subsequent section.

 Dialectical status of arguments

The evaluation of how arguments defend themselves can be modeled using classical argumentation semantics tailored for Dung-style abstract argumentation frameworks [54]. At this stage of the inferential process, the framework is treated as a directed graph where the vertices (nodes) denote the arguments and the directed edges denote the attack relations, temporarily abstracting away the internal structure of the arguments and the metadata of the attacks. To characterize the dialectical standing of arguments within this network, this study utilizes two distinct categories of semantics: extension-based semantics [39, 54] and ranking-based semantics [55]. Their formal mathematical properties are detailed below.

Extension-Based Semantics

The principles of conflict-freeness and reinstatement serve as the core foundations for extension-based semantics, including standard Dung-style formulations [54] such as grounded and preferred semantics. The formal definitions presented below follow the conventions established in [56, 57].

Definition 1. Let 〈𝐴𝑟,ℛ〉 be an argumentation framework (AF), a,b ∈ Ar and args ⊆ Ar. The following notations are utilized:

•𝑎⁺ as {𝑏 | (𝑎,)∈ℛ}.

•𝑎𝑟𝑔𝑠⁺ as {𝑎 | (𝑎,)∈ℛ for some 𝑎∈𝑎𝑟𝑔𝑠}.

•𝑎⁻ as {𝑏 | (𝑏,)∈ℛ}.

•𝑎𝑟𝑔𝑠⁻ as {𝑏 | (𝑏,)∈ℛ for some 𝑎∈𝑎𝑟𝑔𝑠}.

Here, 𝑎⁺ denotes the set of arguments targeted by a, whereas 𝑎⁻ represents the set of arguments targeting a. Similarly, 𝑎𝑟𝑔𝑠⁺  encompasses all arguments attacked by the set 𝑎𝑟𝑔𝑠⁺, while args^- details the collective set of arguments attacking args.

Definition 2.

Let 〈𝐴𝑟,ℛ〉 be an AF and 𝑎𝑟𝑔𝑠⊆𝐴𝑟. 𝑎𝑟𝑔𝑠 is  conflict-free  iff 𝑎𝑟𝑔𝑠∩𝑎𝑟𝑔𝑠⁺=∅.

Definition 3.

Let 〈𝐴𝑟,ℛ〉 be an AF, 𝐴∈𝐴𝑟 and 𝑎𝑟𝑔𝑠⊆𝐴𝑟. 𝑎𝑟𝑔𝑠  defends  an argument A iff 𝐴⁻⊆𝑎𝑟𝑔𝑠⁺.

Definition 4.

Let 〈𝐴𝑟𝑔,ℛ〉 be an AF and 𝐿𝑎𝑏:𝐴𝑟𝑔→{𝑖𝑛,𝑜𝑢𝑡,𝑢𝑛𝑑𝑒𝑐} be a labeling function. 𝐿𝑎𝑏 is a  reinstatement labeling  iff it satisfies:

·                     ∀𝐴∈𝐴𝑟:(𝐿𝑎𝑏(𝐴)=𝑜𝑢𝑡≡∃𝐵∈𝐴𝑟:(𝐵 defends 𝐴∧𝐿𝑎𝑏(𝐵)=𝑖𝑛)) and

·                     ∀𝐴∈𝐴𝑟:(𝐿𝑎𝑏(𝐴)=𝑖𝑛≡∀𝐵∈𝐴𝑟:(𝐵 defends 𝐴⊃𝐿𝑎𝑏(𝐵)=𝑜𝑢𝑡))

Definition 5.

Let 𝐴𝑟𝑔𝑠 be a conflict-free set of arguments, 𝐹:2^{𝐴𝑟𝑔𝑠}→2^{𝐴𝑟𝑔𝑠} a function such that (𝐴𝑟𝑔𝑠)={𝐴 | 𝐴 is defended by 𝐴𝑟𝑔𝑠} and 𝐿𝑎𝑏:𝐴𝑟𝑔𝑠→{𝑖𝑛,𝑜𝑢𝑡,𝑢𝑛𝑑𝑒𝑐} a reinstatement labeling function. Also consider (𝐿𝑎𝑏) short for {𝐴∈𝐴𝑟𝑔𝑠 | 𝐿𝑎𝑏(𝐴)=𝑖𝑛}, 𝑜𝑢𝑡(𝐿𝑎𝑏) short for {𝐴∈𝐴𝑟𝑔𝑠 | 𝐿𝑎𝑏(𝐴)=𝑜𝑢𝑡} and 𝑢𝑛𝑑𝑒𝑐(𝐿𝑎𝑏) short for {𝐴∈𝐴𝑟𝑔𝑠 | 𝐿𝑎𝑏(𝐴)=𝑢𝑛𝑑𝑒𝑐}.

•

𝐴𝑟𝑔𝑠 is  admissible  if 𝐴𝑟𝑔𝑠⊆𝐹(𝐴𝑟𝑔𝑠).

•

𝐴𝑟𝑔𝑠 is a  complete  extension if 𝐴𝑟𝑔𝑠=𝐹(𝐴𝑟𝑔𝑠).

•

(𝐿𝑎𝑏) is a  grounded  extension if 𝑢𝑛𝑑𝑒𝑐(𝐿𝑎𝑏) is maximal, or 𝑖𝑛(𝐿𝑎𝑏) is minimal, or 𝑜𝑢𝑡(𝐿𝑎𝑏) is minimal.

•

(𝐿𝑎𝑏) is a  preferred  extension if 𝑖𝑛(𝐿𝑎𝑏) is maximal or 𝑜𝑢𝑡(𝐿𝑎𝑏) is maximal.

Argumentation semantics, including the grounded and preferred variants, offer a systematic approach for determining the justification or dialectical status of an argument. Under these formal frameworks, an argument achieves a justified status if it successfully counteracts its attackers. Extension-based criteria thus present a formal stance for categorizing arguments into accepted, rejected, or undecided categories. An extension (a coherent set of acceptable arguments) is capable of defending its components against external counterarguments and maintaining internal logical consistency, even when evaluated against competing perspectives [36]. The grounded semantics yields an extension that reflects a skeptical strategy, making minimal commitments and consistently identifying a unique extension. Conversely, preferred semantics reflects a more credulous strategy, exhibiting a bolder stance toward argument acceptance by allowing for the generation of multiple distinct extensions.

Ranking-Based Semantics

Ranking-based approaches represent another prominent category within abstract argumentation semantics [55]. Rather than evaluating acceptability through the binary isolation of argument extensions, this paradigm establishes a relative ordering among arguments. By avoiding the rigid categorization of arguments as strictly validated or dismissed, it offers a more nuanced, graded evaluation directly derived from the structural topology of the framework. This methodology effectively resolves several structural limitations inherent to extension-based paradigms. Specifically, it accounts for scenarios where multiple distinct attacks exert the same cumulative impact as a single attack, addresses the uniform valuation often assigned to valid arguments, and allows for direct ordinal comparisons between arguments that would otherwise share an identical status. The underlying formalisms detailed below follow the conventions established in [55].

Definition 6. A  ranking-based semantics  σ associates with any argumentation framework 𝐴𝐹=〈𝐴𝑟𝑔𝑠,𝑎𝑡𝑡〉 a ranking  on 𝐴𝑟𝑔𝑠, where  is a binary relation which is total (∀𝑎,𝑏∈𝐴𝑟𝑔𝑠,𝑎  𝑏 or 𝑏  𝑎) and transitive (∀𝑎,𝑏,𝑐∈𝐴𝑟𝑔𝑠,𝑎  𝑏 and 𝑏  𝑐, then 𝑎  𝑐). 𝑎  𝑏 means that a is at least as acceptable as b and 𝑎  𝑏 means a is strictly more acceptable than b.

As introduced in [58], ranking-based semantics compute a quantitative metric for each argument based on the density of its direct attackers. To achieve this, a categorizer function is mathematically defined as follows:

Definition 7. Let 〈𝐴𝑟𝑔𝑠,𝑡〉 represent an argumentation framework. The mapping 𝐶𝑎𝑡:𝐴𝑟𝑔𝑠→(0,1] denotes the categorizer function, formulated as:

Definition 8. Given an argumentation framework 〈𝐴𝑟𝑔𝑠,𝑡𝑡〉  and the categorizer function 𝐶𝑎𝑡:𝐴𝑟𝑔𝑠→(0,1], a ranking-based categorizer semantics determines an ordering  over Args such that  ∀𝑎,𝑏∈𝐴𝑟𝑔𝑠,𝑎  𝑏 iff 𝐶𝑎𝑡(𝑎)≥𝐶𝑎𝑡(𝑏).

Accrual of acceptable arguments and final inference

The concluding phase of this defeasible reasoning pipeline requires the generation of a definitive inference. Two straightforward scenarios can resolve this process: (i) an extension-based semantics yields a single extension in which all constituent arguments uniformly endorse the same claim, or (ii) the highest-ranked arguments identified by a ranking-based semantics converge on an identical claim. In both situations, the system designates the claim backed by these accepted or top-ranked arguments as the final inference. If neither condition is satisfied, the framework applies the following specialized, ad hoc resolution strategies depending on the active semantic model:

• Extension-based semantics:

  • If an extension contains conflicting arguments that support divergent claims, it is discarded from the final decision-making process because it fails to offer a coherent, singular perspective. Such an outcome typically indicates that the selected inconsistency budget was overly restrictive. Consequently, the final inferential status is marked as undecided.

  • In cases where the system generates multiple valid extensions, their relative validity is measured by the total count of accepted arguments within each extension. This step intentionally omits individual argument weights, as they have already been factored into the initial attack relations. This simplified, constrained approach serves to mitigate undecided deadlocks when utilizing credulous paradigms (such as preferred semantics) that routinely yield multiple extensions. Ultimately, the defeasible reasoning sequence terminates without a decision if all competing extensions contain an identical number of arguments.

• Ranking-Based semantics:

  • The final inference is classified as undecided if the categorizer function produces an identical maximum score for top-ranked arguments that back opposing claims.

An illustrative example of argument generation across varying inconsistency budgets, along with the corresponding dialectical status under different semantics, is displayed in Figure 3. Only the configuration in graph 3 generates non-empty extensions where the active arguments converge on the same claim. Similarly, under the categorizer semantics, only graphs 1 and 3 yield top-ranked arguments that support an identical conclusion.

This research focuses on maximizing automation when constructing argument-based models from raw data, completely eliminating the need for manual curation. This automated architecture is realized by deploying a specialized Logic Learning Machine (LLM) rule-extractor [16] to synthesize logical if-then rules directly from data. Subsequently, formal computational argumentation methodologies are leveraged to organize these extracted rules into a structured argumentation framework [7]. The resulting multipartite graph is hypothesized to offer significantly higher explainability and interpretability compared to unorganized rule lists.

This core hypothesis is evaluated by comparing the predictive performance of the baseline LLM method against the integrated computational argumentation pipeline. To verify the generalizability of this approach across varied binary classification tasks, the pipeline is evaluated using four open-access benchmark datasets of diverse sample sizes and structural dimensionalities. The formal hypothesis is structured as follows:

Hypothesis 1. IF defeasible argument-based models are built with if-then rules generated by the LLM technique AND their conflictuality is handled with argument-based semantics (preferred, grounded, categorizer), then, these models will achieve similar predictive capacity (recall, precision, accuracy, Younden’s index, % of undecidedness) to those built with the Standard Applied Procedure on the same rule sets for four distinct binary classification tasks.

The experimental design constructed to validate this hypothesis is mapped out in Figure 4, which integrates the corresponding evaluation phases directly into the process flow.

Four benchmark datasets were acquired from the UCI Machine Learning Repository for this empirical study (and accessed on 6 June 2024): CARS, CENSUS, BANK, and MYOCARDIAL. These repositories serve as standard benchmarks within the machine learning domain. They were selected due to their open-access availability, highly divergent feature spaces and sample sizes (Table 1), and skewed class distributions—a characteristic that replicates real-world data imperfections.

Minimal preprocessing was performed to unify the format of these datasets. For the CARS repository, the target class outcomes acc, good, and vgood were consolidated into a single acc class to formulate a binary classification problem. For the CENSUS dataset, any rows containing missing attributes across any features were purged. The BANK dataset was utilized without any prior modifications. Within the MYOCARDIAL dataset, the ZSN (chronic heart failure) variable was designated as the target feature; attributes containing missing data exceeding a 5% threshold were eliminated, and no data interpolation was implemented. Table 1 summarizes the structural dimensions of the finalized datasets utilized in the subsequent testing phases.

The Logic Learning Machine architecture is executed using the proprietary Rulex Platform software. The computational argumentation pipeline is implemented using the open-source ArgFrame framework [38]. The raw textual if-then rules generated by the LLM pipeline are processed via a custom Python parser to convert them into the JSON format required by the ArgFrame system.

The predictive models derived from the baseline LLM method (Table 2) and the argument-based frameworks (Table 3) are evaluated using standard classification metrics. Performance is benchmarked via accuracy, precision, recall, Youden’s index, and the percentage of undecided instances to ensure a multi-dimensional assessment. Two key components are prioritized for each dataset: (i) the physical size of the resulting models and (ii) their overall inferential capacity. Model size serves as a quantitative proxy for explainability, based on the premise that compact information repositories are inherently more interpretable than massive rule sets. Meanwhile, inferential capacity explicitly reflects the predictive power and accuracy of the models.

To guarantee a rigorous performance analysis and assess the generalizability of the results, specific execution parameters for both methods (LLM and computational argumentation) are systematically varied. In the LLM configuration, individual rules are restricted to a maximum of 4 premises to preserve human readability. Additionally, the maximum permissible rule error threshold is tested at two distinct levels: 10% and 25%. Introducing this error tolerance helps mitigate overfitting and optimizes the rule count, directly supporting the model's interpretability. Furthermore, these error boundaries allow the argument-based models to resolve contradictions efficiently while maintaining strong inferential capacity with fewer total rules.

For the argument-based configurations, three distinct semantic evaluations are carried out: (1) preferred semantics, reflecting a credulous model common in defeasible argumentation; (2) grounded semantics, offering a conservative, skeptical model; and (3) categorizer semantics, incorporating a ranking-based paradigm into the matrix. Furthermore, multiple thresholds are established for the maximum inconsistency budget, since the rules generated by the LLM technique are structurally prone to creating numerous mutual rebuttals. Setting an inconsistency budget is therefore critical to prevent excessive rates of unresolvable or undecided instances. Three explicit budget boundaries are evaluated: 25% (an aggressive restriction focusing only on critical attacks), 50% (a balanced approach), and 90% (a permissive approach designed to preserve structural connections by removing only a minimal number of attacks). Tables 2 and 3 detail the complete list of models and their respective parameter values.

This section categorizes the experimental outcomes according to the four designated datasets. Each dataset undergoes an individual assessment focused on predictive performance (evaluated via recall, precision, accuracy, Youden’s index, and the percentage of undecided instances) alongside structural model dimensions (quantified by the volume of rules/arguments and corresponding attacks). Finally, a comprehensive synthesis presents overarching insights, with a particular emphasis on the explainability of the models.

CARS dataset

The total volume of rules and attacks derived from the CARS dataset is detailed in Table 4, organized by the two distinct error thresholds applied. The resulting frameworks remain relatively compact regarding the number of established rules, even when a high 𝛽 value is introduced. Figure 5 illustrates the outcomes associated with the selected classification metrics. Notably, the maximum error threshold appeared to exert no substantial influence on the outcomes (comparing cases a–d against e–h in Figure 5), demonstrating that the rules generated via the LLM methodology maintained stability even at the highest allowable parameter.

Regarding the argument-based frameworks, configuring the inconsistency budget 𝛽 to 50% successfully resolved every instance of undecided inferences (see cases b and f in Figure 5). Nevertheless, all alternative configurations of 𝛽 yielded inferences with a maximum of 28% undecided cases, while simultaneously matching or exceeding the baseline performance metrics (precision, recall, accuracy, and Youden’s index) of the comparative baseline models (H1 or H2). This indicates that the argument-based frameworks are capable of adequately managing the viability of the if-then rules regardless of the specific argumentation semantics utilized, owing to the minimal rate of undecidedness. When non-zero percentages of undecided instances occurred, an enhancement in overall model performance was also discernible (comparing case b against {a,c,d}, and case f against {e,g,h} in Figure 5).

CENSUS dataset

As indicated in Table 5, the volume of rules and attacks produced by the LLM methodology for the CENSUS dataset was notably greater than the quantities observed for the CARS dataset. This outcome aligns with expectations given the larger feature set characteristic of this dataset. Furthermore, the inconsistency budget 𝛽 succeeded in substantially decreasing the volume of attacks (Table 5), thereby rendering certain argument-based models more streamlined than others.

In terms of inferential performance, Figure 6 displays the outcomes for the CENSUS dataset. Consistent with the CARS dataset observations, the maximum error threshold per rule exerted no pronounced effect on overall model performance (comparing cases a–d against e–h in Figure 6). Additionally, it is important to note the stable inferences generated by argument-based models utilizing grounded semantics coupled with a high 𝛽, though this occurred at the expense of an increased proportion of undecided instances (cases c, d, g, and h in Figure 6). This demonstrates that the identification of undecided cases remained functional for this dataset; however, particular percentages proved excessively high for the models to be considered practical (ranging between 60% and 93%). This elevated proportion of undecided cases reflects a denser concentration of rules extracted per record within this dataset, highlighting the need for enhanced conflict resolution strategies. Setting lower 𝛽 values succeeded in mitigating these instances while keeping the remaining performance metrics (excluding precision) close to those of the baseline models (H1 or H2). The decrement in precision is presumably linked to class imbalance within the data, indicating that the argument-based frameworks were less optimal regarding positive predictions. Nonetheless, these models delivered acceptable outcomes, suggesting that performing a grid search across a range of inconsistency budgets serves as a viable approach for optimizing conflict resolution in large, highly contested environments.

BANK dataset

The outcomes connected to the data from the BANK dataset are compiled in Table 6 and Figure 7. Several identical trends identified in the evaluation of the prior two datasets remain apparent. These include an elevated quantity of rules and attacks driven by the expanded feature set, a minimized attack count at lower 𝛽 levels, and an increased proportion of undecided instances at elevated 𝛽 levels.

The primary distinction occurs within the argument-based frameworks when the inconsistency budget 𝛽 is set precisely to 50%. In this specific scenario, all undecided instances were completely reduced to 0, yielding performance metrics that closely align with the baseline models (H1 or H2). This confirms that the argumentation semantics successfully resolved conflicting states without compromising inferential capacity when utilizing a 50% 𝛽. This finding is significant as it reinforces the practical utility of the if-then rules extracted by the proposed argument-based models.

MYOCARDIAL dataset

Lastly, even though the MYOCARDIAL dataset contains the most extensive set of features, the resulting number of rules and attacks (Table 7) did not exhibit a marked increase relative to the previous datasets. This implies that the LLM approach did not exploit all available attributes, yielding rule structures and premises comparable to those observed previously. Figure 8 illustrates the inferential capacity of the models, revealing consistent patterns found across the other datasets. These include the finding that the maximum permitted error threshold per rule does not alter performance; that robust inferences are generated by argument-based models using grounded semantics with elevated 𝛽 values; and that argumentation semantics successfully mitigate conflicting states without degrading inferential power when a 50% 𝛽 is used. The application of lower 𝛽 values to minimize undecided outcomes while preserving robust metrics across all other dimensions is especially noteworthy. The recurrence of these consistent trends across distinct datasets confirms the generalizability of these insights, which are evaluated further in the subsequent section.

Summary and discussion

The LLM methodology for extracting if-then rules demonstrated remarkable efficiency across all models synthesized from the four designated datasets, particularly regarding rule volume, the mean number of premises, and overall model performance. Generating argument-based frameworks from these rule sets yielded minor improvements in the predictive strength of the models developed for the CARS dataset, which possessed a restricted number of features. Conversely, the remaining datasets characterized by higher feature dimensionality demanded additional fine-tuning. This necessity arose primarily from the multipartite architecture of the underlying argumentation networks (graphs) established by the extracted if-then rules, which triggered widespread contradictions when multiple rules were simultaneously activated. The primary technique utilized to mitigate these active conflicts was the inconsistency budget parameter, 𝛽. This specific metric establishes a priority hierarchy among attacks based on argument relevance, which is computed via the LLM approach using the coverage and error margins of the rules. The experimental outcomes indicated that modulating 𝛽 successfully eliminated less significant attacks, thereby minimizing undecided inferences and enhancing model accuracy. This highlights the indispensable function of the inconsistency budget when unified with the LLM approach.

On the whole, regarding predictive capacity, the argument-based frameworks constructed from the if-then rules of the Logic Learning Machine and structured through the argumentation pipeline performed comparably to models utilizing the identical rule set but unified via the Standard Applied Procedure. Realizing this performance parity was the primary requirement to validate the initial hypothesis that argument-based frameworks can deliver equivalent inferential capacity while remaining inherently more explainable than basic, unstructured rule lists. This superior explainability is derived from the dialectical classifications attributed to arguments—specifically accepted, rejected, or undecided—coupled with the highly interpretable workflows utilized to generate final inferences. These underlying mechanisms correspond more closely with human cognitive processes when navigating uncertainty and contradictory data. Furthermore, argumentation graphs are arguably more compact and visually accessible than a standard list of rules, potentially increasing both the explainability and interpretability of the inferential systems. Although explainability and interpretability represent two attributes that were not empirically quantified but rather treated as target ideals, future user studies could evaluate these dimensions more rigorously by utilizing psychometric assessments, as demonstrated in [59].

Another vital feature of these argumentation graphs is their adherence to the GLOCAL characteristic of AI systems outlined within the eXplainable Artificial Intelligence domain [4, 60]. Consequently, they accommodate a global perspective and conceptual understanding of the inferential workflows while concurrently providing local explanations through the evaluation of single-activated arguments from the input data along with their interconnected dependencies. Furthermore, argumentation graphs serve as inferential instruments for articulating contrastive explanations [6]. By leveraging the concept of attacks occurring between conflicting arguments (the rules), contrastive explanations can be practically deployed. This strategy enables contrastive scenarios to be offered as complementary justifications; it clarifies why a specific final inference constitutes the most rational deduction relative to alternative choices. The framework clarifies the underlying rationale validated by accepted arguments and contrasts it against the rationale dismissed by rejected arguments. Correspondingly, when accepted arguments validate conflicting assertions—thereby generating a contrastive scenario—an argumentation graph facilitates an understanding of why a definitive inference cannot be reached, which ultimately precipitates a state of undecidedness. This condition can be counteracted via human oversight and domain expertise. For instance, by evaluating the accepted arguments and their corresponding attacks, a human analyst can investigate alternative hypotheses by manually omitting, adjusting, or introducing arguments to monitor the resulting shifts in the final inference. This flexibility is supported by the absence of topological constraints on the argumentation graphs, which allows external knowledge to be seamlessly integrated.

This study demonstrated the feasibility of integrating the Logic Learning Machine (LLM), a specialized rule generation engine, with argument-based frameworks, an explicit paradigm designed for modeling contradictions among rules. Accordingly, this research addresses a core challenge within XAI: the development of data-driven inferential methodologies that deliver transparent, interpretable outcomes while preserving scalability and efficacy in complex domains. Specifically, the practical insights were derived from an empirical assessment comparing the Standard Applied Procedure—the baseline conflict resolution mechanism used by Logic Learning Machines—against diverse argument-based frameworks constructed from LLM-generated rules using a selection of widely recognized benchmarking datasets. The fundamental objective was to leverage a resilient, general-purpose procedure for extracting rules from data while resolving their internal contradictions through computational argumentation, a paradigm specialized for executing defeasible reasoning and managing conflicts rationally.

Additionally, the dialectical status assigned to each individual argument within these argumentation frameworks streamlined the evaluation of the global and local interpretability of these argument-based models. The study demonstrated how contrastive explanations can be systematically formulated. The comparative analysis revealed that the LLM functions as a stable, robust architecture for generating rules that can be successfully adapted into arguments, even under the modification of parameters linked to the argument-based models. The findings also indicated that argument-based models can match the predictive power of the standard LLM methodology while offering more explainable inferential workflows that align more closely with human reasoning under uncertainty. This methodology is applicable to any binary classification problem. While the datasets evaluated in this research belong to the financial, medical, and automotive sectors, the insights are not confined to these domains and can be extrapolated more broadly. Future research directions involve scaling these experiments to more complex, non-binary classification tasks and optimizing the systemic integration between the Logic Learning Machine and computational argumentation frameworks. In the wider context of XAI, it would likewise be advantageous to explicitly contextualize this proposed integration of LLM and computational argumentation relative to alternative transparent and interpretable methodologies, including those outside the scope of traditional knowledge-based systems.

None

None

None

None

Daniel Fischer, Laura Meier, Stefan Koch & Thomas Braun contributed to this work.

Authors and affiliations

Department of Explainable AI and Argumentation, Faculty of Engineering, University of Freiburg, Freiburg, Germany
Daniel Fischer & Laura Meier

Department of Data-Driven Rule Generation and Argumentation, Faculty of Engineering, Technical University of Munich, Munich, Germany
Stefan Koch

Department of Unified XAI Paradigms, Faculty of Engineering, University of Kiel, Kiel, Germany
Thomas Braun

Corresponding author

Correspondence to Daniel Fischer

Open Access The author(s) retain copyright. This article is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License. It may be shared and adapted for non-commercial purposes with appropriate attribution, an indication of changes, and distribution of adaptations under the same license. Third-party material may be subject to separate terms identified in its credit line. View the license at https://creativecommons.org/licenses/by-nc-sa/4.0/.