Struct ArgumentationFramework 

pub struct ArgumentationFramework<A: Clone + Eq + Hash> { /* private fields */ }

A Dung-style argumentation framework over argument type A.

Implementations

impl<A: Clone + Eq + Hash> ArgumentationFramework<A>

pub fn new() -> Self

Create an empty framework.

pub fn add_argument(&mut self, a: A)

Add an argument. Adding an argument that already exists is a no-op.

pub fn add_attack(&mut self, attacker: &A, target: &A) -> Result<(), Error>

where A: Debug,

Add an attack from attacker to target. Both must already be present.

Adding the same attack edge twice is a no-op: ArgumentationFramework does not model weighted or multi-edge attacks.

The Debug bound on A lets the error message name the offending argument when one is missing. Arguments are taken by reference to avoid cloning owned types like String or Arc<T> on every call.

pub fn arguments(&self) -> impl Iterator<Item = &A>

Iterate over all arguments in the framework.

pub fn len(&self) -> usize

Number of arguments currently in the framework.

Constant-time. Useful for size-gating exponential enumerators against crate::ENUMERATION_LIMIT before calling them.

pub fn is_empty(&self) -> bool

Whether the framework contains zero arguments.

pub fn attackers(&self, a: &A) -> Vec<&A>

Return the arguments that attack a.

pub fn attacked_by(&self, a: &A) -> Vec<&A>

Return the arguments attacked by a.

impl<A: Clone + Eq + Hash> ArgumentationFramework<A>

pub fn is_conflict_free(&self, s: &HashSet<A>) -> bool

A set s is conflict-free iff no argument in s attacks another in s.

pub fn defends(&self, s: &HashSet<A>, a: &A) -> bool

s defends a iff every attacker of a is itself attacked by some member of s.

pub fn is_admissible(&self, s: &HashSet<A>) -> bool

s is admissible iff it is conflict-free and defends all its members.

impl<A: Clone + Eq + Hash + Ord> ArgumentationFramework<A>

pub fn complete_extensions(&self) -> Result<Vec<HashSet<A>>, Error>

Enumerate all complete extensions via subset search.

Performance: O(2^n) in the number of arguments. Frameworks with more than the internal enumeration limit are rejected with crate::Error::TooLarge; use a SAT-based semantics entry point (future work) for larger instances.

impl<A: Clone + Eq + Hash> ArgumentationFramework<A>

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

Compute the grounded extension.

Returns the unique least complete extension (always exists, always unique).

impl<A: Clone + Eq + Hash + Ord> ArgumentationFramework<A>

pub fn ideal_extension(&self) -> Result<HashSet<A>, Error>

Compute the ideal extension.

Defined as the largest admissible subset of the intersection of all preferred extensions. Unique. The grounded extension is always a subset of the ideal extension.

Returns crate::Error::TooLarge for frameworks above the enumeration limit.

impl<A: Clone + Eq + Hash + Ord> ArgumentationFramework<A>

pub fn extension_to_labelling(&self, ext: &HashSet<A>) -> Labelling<A>

Compute the labelling corresponding to a given extension.

An argument is In iff in the extension; Out iff attacked by something in the extension; Undec otherwise.

pub fn complete_labellings(&self) -> Result<Vec<Labelling<A>>, Error>

Return labellings corresponding to all complete extensions.

Propagates crate::Error::TooLarge from complete_extensions.

pub fn grounded_labelling(&self) -> Labelling<A>

Compute the labelling corresponding to the grounded extension.

pub fn preferred_labellings(&self) -> Result<Vec<Labelling<A>>, Error>

Compute labellings corresponding to all preferred extensions.

pub fn stable_labellings(&self) -> Result<Vec<Labelling<A>>, Error>

Compute labellings corresponding to all stable extensions.

pub fn ideal_labelling(&self) -> Result<Labelling<A>, Error>

Compute the labelling corresponding to the ideal extension.

pub fn semi_stable_labellings(&self) -> Result<Vec<Labelling<A>>, Error>

Compute labellings corresponding to all semi-stable extensions.

impl<A: Clone + Eq + Hash + Ord> ArgumentationFramework<A>

pub fn preferred_extensions(&self) -> Result<Vec<HashSet<A>>, Error>

Enumerate all preferred extensions.

A preferred extension is a subset-maximal admissible set. Every argumentation framework has at least one preferred extension.

Returns crate::Error::TooLarge for frameworks above the enumeration limit.

impl<A: Clone + Eq + Hash + Ord> ArgumentationFramework<A>

pub fn semi_stable_extensions(&self) -> Result<Vec<HashSet<A>>, Error>

Enumerate all semi-stable extensions.

Returns crate::Error::TooLarge for frameworks above the enumeration limit.

impl<A: Clone + Eq + Hash + Ord> ArgumentationFramework<A>

pub fn stable_extensions(&self) -> Result<Vec<HashSet<A>>, Error>

Enumerate all stable extensions.

A stable extension is a conflict-free set S such that every argument not in S is attacked by some member of S. Stable extensions may not exist (e.g., in odd cycles).

Returns crate::Error::TooLarge for frameworks above the enumeration limit.

Trait Implementations

impl<A: Clone + Clone + Eq + Hash> Clone for ArgumentationFramework<A>

fn clone(&self) -> ArgumentationFramework<A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug + Clone + Eq + Hash> Debug for ArgumentationFramework<A>

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

Formats the value using the given formatter.

impl<A: Clone + Eq + Hash> Default for ArgumentationFramework<A>

fn default() -> Self

Returns the “default value” for a type.