Struct ArgumentationFramework 

pub struct ArgumentationFramework {
    pub arguments: HashMap<u64, Argument>,
    pub attacks: Vec<Attack>,
    pub metadata: u64,
}

Abstract argumentation framework

Fields

arguments: HashMap<u64, Argument>

attacks: Vec<Attack>

metadata: u64

Implementations

impl ArgumentationFramework

pub fn new() -> Self

Create a new empty framework

pub fn add_argument(&mut self, argument: Argument)

Add an argument to the framework

pub fn add_attack(&mut self, attack: Attack)

Add an attack relation

pub fn get_attackers(&self, target_id: u64) -> Vec<&Argument>

Get all arguments that attack a given argument

pub fn get_attacked(&self, attacker_id: u64) -> Vec<&Argument>

Get all arguments that are attacked by a given argument

pub fn grounded_extension(&self) -> HashSet<u64>

Compute grounded extension (unique least fixed point of the characteristic function).

Algorithm (Dung 1995): GE ← ∅ Repeat: 1. Collect all arguments that are defeated by GE (attacked by some member of GE). 2. For every remaining argument a not yet in GE: if every attacker of a is defeated by GE, add a to GE. Until no change.

pub fn preferred_extensions(&self) -> Vec<HashSet<u64>>

Compute preferred extensions (maximal conflict-free sets)

pub fn is_conflict_free(&self, args: &HashSet<u64>) -> bool

Check if a set of arguments is conflict-free (no attacks within the set)

pub fn is_admissible(&self, args: &HashSet<u64>) -> bool

Check if a set of arguments is admissible (conflict-free and defends all its members)

pub fn argument_status(&self, arg_id: u64) -> ArgumentStatus

Compute the argumentation status of an argument

pub fn resolve_skeptically(&self) -> HashSet<u64>

Resolve a debate using skeptical reasoning (intersection of all preferred extensions)

pub fn resolve_credulously(&self) -> HashSet<u64>

Resolve a debate using credulous reasoning (union of all preferred extensions)

pub fn stable_extensions(&self) -> Vec<HashSet<u64>>

Stable extensions (Dung): a conflict-free set that attacks every argument outside it. Computed by testing each conflict-free subset (exponential — bounded by frame size, as abstract frameworks here are small). Every stable extension is also preferred.

pub fn is_stable(&self, args: &HashSet<u64>) -> bool

Is args a stable extension: conflict-free and attacks every argument not in it?

pub fn complete_extensions(&self) -> Vec<HashSet<u64>>

Complete extensions (Dung): an admissible set that contains every argument it defends (its own fixed point under the characteristic function). The grounded extension is the least complete extension; each preferred extension is a maximal complete one.

pub fn defends(&self, args: &HashSet<u64>, arg: u64) -> bool

Does args defend arg (every attacker of arg is attacked by args)?

pub fn is_complete(&self, args: &HashSet<u64>) -> bool

Is args a complete extension: admissible and contains every argument it defends?

Trait Implementations

impl Clone for ArgumentationFramework

fn clone(&self) -> ArgumentationFramework

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ArgumentationFramework

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.