🤖 AI

Comparative Expressivity for Structured Argumentation Frameworks with Uncertain Rules and Premises

This paper introduces a unified notion of expressivity to compare abstract and structured argumentation frameworks with uncertain rules and premises, presenting both negative and positive results that establish the relative capabilities of incomplete abstract frameworks and ASPIC+.

Original authors: Carlo Proietti, Antonio Yuste-Ginel

Published 2026-02-18

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Carlo Proietti, Antonio Yuste-Ginel

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to build a case for a debate, but you aren't 100% sure about all the facts or the rules you're using. Maybe you know your opponent's main point, but you're unsure if a specific piece of evidence exists, or if a particular rule of logic applies in this situation.

This paper is about how to model that uncertainty in computer systems that argue. The authors are comparing two different ways of building these "argument machines" to see which one is more powerful and flexible.

Here is the breakdown using simple analogies:

1. The Two Ways to Build an Argument Machine

The paper compares two paradigms: Abstract and Structured.

The Abstract Approach (The "Black Box" Method):
Imagine you have a list of arguments (like "It will rain" or "I have an umbrella") and a list of arrows showing which ones attack each other.
- The Uncertainty: You don't know if certain arguments exist yet. It's like having a box of Lego bricks where some are hidden. You know the box contains a red brick and a blue brick, but you aren't sure if the green brick is in there.
- The Problem: This method is simple, but it's a bit "dumb." It treats every argument as a single, unchangeable block. It doesn't know why an argument exists or what it's made of.
The Structured Approach (The "Lego Blueprint" Method):
Imagine building a house. You have specific rules (bricks must be laid in rows) and specific materials (wood, glass, concrete).
- The Uncertainty: You might be unsure if you have the "glass" (a premise) or if the "rule" about laying bricks in rows actually applies (an inference rule).
- The Power: This method is detailed. It knows that if you are missing the "glass," the whole window argument falls apart. It understands the ingredients of the argument.

2. The Big Question: Which is Better?

The authors asked: "Can the simple 'Black Box' method do everything the detailed 'Lego Blueprint' method can do?"

They introduced a concept called Expressivity. Think of this as the "imagination power" of the system.

High Expressivity: The system can imagine a huge variety of possible worlds (scenarios where different facts are true or false).
Low Expressivity: The system is limited; it can only imagine a few specific scenarios.

3. The Findings: The "Goldilocks" Hierarchy

The authors ran a series of tests and found a clear hierarchy, like a ladder of power:

The Bottom Rung (Simple Abstract):
The basic "Black Box" method is the weakest. It can't capture the complexity of the "Lego Blueprint." If you try to translate a detailed Lego model into a simple black box, you lose information. It's like trying to describe a complex cake recipe by just saying "it's a dessert." You lose the details of the eggs, flour, and sugar.
The Middle Rung (Structured with Uncertain Rules):
The "Lego Blueprint" method where you aren't sure about the rules (e.g., "Does the rule 'birds fly' apply here?") is more powerful than the simple black box. It can simulate all the scenarios the black box can, plus more.
The Top Rung (Structured with Uncertain Premises):
The "Lego Blueprint" method where you aren't sure about the facts (e.g., "Do we actually have a bird?") is the most powerful of all.
- Wait, isn't the middle one also powerful? Yes, but the authors found that being unsure about the facts (premises) allows for even more complex combinations of scenarios than being unsure about the rules.

The Twist:
The simple black box can be upgraded! If you give the black box a special "dependency tool" (a way to say "If argument A exists, then argument B must exist"), it can finally catch up to the "Rule" version of the structured method. But even with this upgrade, it still can't quite reach the full power of the "Fact" version of the structured method.

4. The "Dependency" Analogy

To make the simple black box smarter, the authors added Dependencies.

Without dependencies: You have a bag of mystery bricks. You can pick any combination.
With dependencies: You have a bag of mystery bricks, but you have a rule: "If you pick the Red brick, you must also pick the Blue brick."
This extra rule allows the simple system to mimic the complex structured system (specifically the one with uncertain rules).

5. Why Does This Matter?

Imagine you are building an AI lawyer or a medical diagnosis bot.

If you use the Simple (Abstract) model, you might miss subtle connections because you treated the argument as a single block.
If you use the Structured model, you can pinpoint exactly why a conclusion is shaky (e.g., "The conclusion is weak because we are missing the 'blood test' fact," not just "The argument is weak").

The Conclusion:
The paper proves that Structured Argumentation is generally more expressive (powerful) than Abstract Argumentation. Specifically, knowing what facts are missing gives you more control over the argument than knowing what rules are missing, and both are more powerful than just guessing which arguments exist in a black box.

However, if you really need to use the simple Abstract model, you can make it work by adding "dependency rules" to it, though it will still have a ceiling on how complex it can get compared to the full Structured model.

In short: If you want to argue with computers about uncertain real-world situations, don't just draw arrows between boxes. Build the arguments out of their ingredients (facts and rules), because that's where the real power lies.

1. Problem Statement

The paper addresses the challenge of modeling qualitative uncertainty in formal argumentation. While uncertainty is crucial for practical applications (e.g., debates, legal reasoning) and theoretical understanding, existing literature largely focuses on abstract argumentation (where arguments are atomic nodes) or structured argumentation (where arguments are built from premises and rules) in isolation.

The core open question is: How do abstract and structured models of argumentation with uncertainty compare in terms of their expressive power?
Specifically, the authors investigate whether abstract frameworks (like Argumentation Frameworks with incomplete arguments) can fully capture the nuances of structured frameworks (like ASPIC+ with uncertain rules or premises), or if information is lost when moving between these paradigms. A key concern is that many abstract frameworks are not "plausible instantiations" of structured ones, leading to a loss of granularity regarding dependencies between argument components.

2. Methodology

The authors employ a systematic approach to compare the relative expressivity of different formalisms. Their methodology consists of two main steps:

Defining a Standard for Abstract Uncertainty:
They utilize Argument-Incomplete Argumentation Frameworks with Dependencies (dep-arg-IAFs). In this model:
- Arguments are split into certain ($AF$) and uncertain ( $A?$ ).
- Uncertainty is resolved via completions (subsets of arguments that form a valid framework).
- Dependencies ( $\Delta$ ) are introduced to constrain completions (e.g., "if argument $A$ is present, then argument $B$ must be present").
- Expressivity is measured by the set of possible completions a formalism can generate.
Lifting Structured Formalisms to the Abstract Level:
They analyze ASPIC+, a prominent structured argumentation framework, under two types of uncertainty:
- Rule-Incompleteness (rul-ISAF): Uncertainty regarding the applicability of inference rules (strict or defeasible).
- Premise-Incompleteness (prem-ISAF): Uncertainty regarding the presence of knowledge base elements (axioms or ordinary premises).
They define completions for these structured frameworks (by selecting subsets of uncertain rules or premises) and map them to their associated abstract Argumentation Frameworks (AFs).
Comparative Analysis:
They define a notion of relative expressivity ( $\mathcal{Y} \preceq \mathcal{X}$ ): Class $\mathcal{Y}$ is at least as expressive as $\mathcal{X}$ if for every framework in $\mathcal{X}$ , there exists a framework in $\mathcal{Y}$ that generates an equivalent set of completions (up to isomorphism). They prove strict inequalities ( $\prec$ ) and non-expressivity ( $\not\preceq$ ) using constructive proofs and counter-examples.

3. Key Contributions

A Novel Notion of Expressivity: The paper introduces a rigorous definition of expressivity that handles both abstract and structured formalisms by comparing their sets of "completions" (possible worlds). This allows for a direct comparison between models that operate at different levels of granularity.
Formalization of Incomplete ASPIC+: The authors provide precise definitions for rul-ISAF (uncertain rules) and prem-ISAF (uncertain premises), extending previous work on incomplete structured argumentation.
Mapping Dependencies to Structure: They demonstrate how dependencies in abstract frameworks (specifically implicative dependencies) correspond to the structural constraints found in incomplete ASPIC+ frameworks.

4. Key Results

The results are summarized in a hierarchy of expressivity (visualized in the paper's Figure 1). The findings can be categorized as follows:

A. Abstract vs. Structured (General)

Structured > Abstract (No Dependencies): Structured frameworks with uncertainty (rul-ISAF and prem-ISAF) are strictly more expressive than standard argument-incomplete frameworks (arg-IAFs) without dependencies.
- Reasoning: Structured frameworks can enforce complex dependencies between arguments (e.g., if rule $r$ is present, argument $A$ exists) that simple arg-IAFs cannot capture without explicit dependency constraints.
Abstract (with Dependencies) > Structured: Frameworks with dependencies (dep-arg-IAFs) are strictly more expressive than structured frameworks.
- Reasoning: While structured frameworks can generate specific dependency patterns, they cannot generate all possible sets of completions that a general dependency-based abstract framework can. Specifically, imp-arg-IAFs (implicative dependencies) can model scenarios that neither rul-ISAF nor prem-ISAF can replicate.

B. Rule-Incompleteness vs. Premise-Incompleteness

Rule-Incompleteness > Premise-Incompleteness: The class of rule-incomplete frameworks (rul-ISAF) is strictly more expressive than premise-incomplete frameworks (prem-ISAF).
- Reasoning: Uncertain rules allow for more complex structural interactions (e.g., chaining uncertain rules) that uncertain premises alone cannot simulate. The authors prove that any prem-ISAF can be translated into an equivalent rul-ISAF, but the reverse is not true.

C. Summary Hierarchy

The expressivity hierarchy established is:
$\text{arg-IAFs} \prec \text{prem-ISAFs} \prec \text{rul-ISAFs} \prec \text{imp-arg-IAFs} \prec \text{dep-arg-IAFs}$

arg-IAFs: Least expressive.
prem-ISAFs: More expressive than arg-IAFs; less than rul-ISAFs.
rul-ISAFs: More expressive than prem-ISAFs; less than imp-arg-IAFs.
imp-arg-IAFs: More expressive than rul-ISAFs; less than full dep-arg-IAFs.
dep-arg-IAFs: Most expressive (can isolate any set of completions).

5. Significance

Theoretical Unification: The paper bridges the gap between abstract and structured argumentation by providing a common metric (expressivity of completions) to compare them. It clarifies the limitations of abstract models when applied to structured contexts.
Guidance for Model Selection: The results inform researchers and practitioners on which formalism to choose based on the complexity of uncertainty in their domain.
- If the domain requires modeling complex dependencies between argument components, simple abstract models are insufficient; structured models or abstract models with explicit dependencies are required.
- If the domain involves uncertain inference rules, a premise-based model is insufficient; a rule-based model is necessary.
Foundations for Future Work: The authors note that these results unify recent studies on uncertain structured argumentation (specifically referencing works by [22] and [15, 16]). The methodology provides a template for analyzing other structured formalisms (e.g., ABA, DeLP) and for extending the analysis to other types of uncertainty (e.g., preferences).

In conclusion, the paper demonstrates that structured argumentation with uncertainty is a powerful middle ground: it is more expressive than basic abstract models but less expressive than abstract models augmented with general dependency constraints. Furthermore, it establishes that uncertainty in rules is fundamentally more expressive than uncertainty in premises within the ASPIC+ framework.