Class NecessityArgumentationFramework

java.lang.Object
org.tweetyproject.commons.BeliefSet<BArgument, DungSignature>
org.tweetyproject.arg.bipolar.syntax.AbstractBipolarFramework
org.tweetyproject.arg.bipolar.syntax.NecessityArgumentationFramework
All Implemented Interfaces:
Comparable<NecessityArgumentationFramework>, Iterable<BArgument>, Collection<BArgument>, BeliefBase, GeneralGraph<BArgument>, Graph<BArgument>
public class NecessityArgumentationFramework extends AbstractBipolarFramework implements Comparable<NecessityArgumentationFramework>
This class implements a bipolar abstract argumentation framework with necessities. ie. if an argument a supports b, then the acceptance of a is required for the acceptance of b. If a set of arguments E supports an argument b, then the acceptance of b requires the acceptance of at least one argument of E.

See

Nouioua. AFs with Necessities: Further Semantics and Labelling Characterization. 2013

and

Polberg, Oren. Revisiting Support in Abstract Argumentation Systems. 2014
Author:
Lars Bengel

  • Constructor Details

    • NecessityArgumentationFramework

      public NecessityArgumentationFramework()
      Default constructor; initializes empty sets of arguments, attacks and supports

    • NecessityArgumentationFramework

      public NecessityArgumentationFramework(EvidentialArgumentationFramework eaf)
      creates a necessity argumentation framework from the given evidential argumentation framework
      Parameters:
      eaf - a bipolar evidential argumentation framework

    • NecessityArgumentationFramework

      public NecessityArgumentationFramework(DeductiveArgumentationFramework daf)
      creates a necessity argumentation framework from the given deductive argumentation framework
      Parameters:
      daf - a bipolar deductive argumentation framework

  • Method Details

    • isAcceptable

      public boolean isAcceptable(BArgument argument, Collection<BArgument> ext)
      checks whether ext defends argument a set of arguments S defends an argument a iff S u {a} is coherent and S attacks each coherent set T, which attacks a
      Specified by:
      isAcceptable in class AbstractBipolarFramework
      Parameters:
      argument - some argument
      ext - a set of arguments
      Returns:
      "true" if ext defends argument

    • getDeactivatedArguments

      public Set<BArgument> getDeactivatedArguments(Collection<BArgument> argumentSet)
      computes the set of deactivated arguments of argumentSet a set of arguments S deactivates an argument a iff either S attacks a or S does not support a
      Parameters:
      argumentSet - a set of arguments
      Returns:
      the set of deactivated arguments

    • isStronglyCoherent

      public boolean isStronglyCoherent(Collection<BArgument> argumentSet)
      checks whether the given set of arguments is strongly coherent in this argumentation framework a set of arguments is strongly coherent iff it is coherent an conflict-free
      Parameters:
      argumentSet - a set of arguments
      Returns:
      "true" if argumentSet is strongly coherent

    • isCoherent

      public boolean isCoherent(Collection<BArgument> argumentSet)
      checks if the set of arguments S is coherent in his argumentation framework S is coherent iff it is closed and N-Cycle-Free
      Parameters:
      argumentSet - a set of arguments
      Returns:
      "true" if argumentSet is coherent

    • isClosed

      public boolean isClosed(Collection<BArgument> argumentSet)
      checks if the given set of arguments is closed under the support relation a set of arguments S is closed iff every argument a in S has support from a non-empty subset of S
      Parameters:
      argumentSet - a set of arguments
      Returns:
      "true" if argumentSet is closed under the support relation

    • isNCycleFree

      public boolean isNCycleFree(Collection<BArgument> argumentSet)
      checks if a set of arguments S is N-Cycle-Free in this argumentation framework ie. if all arguments in S are N-Cycle-Free in S
      Parameters:
      argumentSet - a set of arguments
      Returns:
      "true" the set of arguments isN-Cycle-Free

    • isNCycleFreeIn

      public boolean isNCycleFreeIn(BArgument argument, Collection<BArgument> argumentSet)
      checks if argument is N-Cycle-Free in the set of arguments
      Parameters:
      argument - some argument
      argumentSet - a set of arguments
      Returns:
      "true" if argument in N-Cycle-Free in the set of arguments

    • isConflictFree

      public boolean isConflictFree(Collection<BArgument> argumentSet)
      checks whether the given set is conflict-free wrt. the attack relation
      Parameters:
      argumentSet - a set of arguments
      Returns:
      "true" if argumentSet is Conflict-Free

    • isAttackedBy

      public boolean isAttackedBy(BArgument argument, Collection<BArgument> argumentSet)
      checks whether argument is attacked by any argument in argumentSet
      Parameters:
      argument - some argument
      argumentSet - a set of arguments
      Returns:
      "true" if some argument in argumentSet attacks argument

    • isAttackedBy

      public boolean isAttackedBy(Collection<BArgument> argumentSet1, Collection<BArgument> argumentSet2)
      checks whether some argument in argumentSet1 is attacked by any argument in argumentSet2
      Parameters:
      argumentSet1 - a set of arguments
      argumentSet2 - a set of arguments
      Returns:
      "true" if some argument in argumentSet2 attacks any argument in argumentSet1

    • add

      public boolean add(Support s)
      Description copied from class: AbstractBipolarFramework
      Adds the given support to this argumentation framework.
      Specified by:
      add in class AbstractBipolarFramework
      Parameters:
      s - a support
      Returns:
      "true" if the set of supports has been modified.

    • addSupport

      public boolean addSupport(BArgument supporter, BArgument supported)
      Adds a support from the first argument to the second to this argumentation framework.
      Parameters:
      supporter - some argument
      supported - some argument
      Returns:
      "true" if the set of supports has been modified.

    • addSupport

      public boolean addSupport(ArgumentSet supporter, BArgument supported)
      Adds a support from a set of arguments to an argument to this argumentation framework.
      Parameters:
      supporter - a set of arguments
      supported - some argument
      Returns:
      "true" if the set of supports has been modified.

    • add

      public boolean add(Attack a)
      Description copied from class: AbstractBipolarFramework
      Adds the given attack to this argumentation framework
      Specified by:
      add in class AbstractBipolarFramework
      Parameters:
      a - an attack
      Returns:
      "true" if the set of attacks has been modified.

    • addAttack

      public boolean addAttack(BArgument attacker, BArgument attacked)
      Adds an attack from the first argument to the second to this necessity argumentation system.
      Parameters:
      attacker - some argument
      attacked - some argument
      Returns:
      "true" if the set of attacks has been modified.

    • getSupports

      public Set<Support> getSupports()
      Description copied from class: AbstractBipolarFramework
      Returns all supports of this theory.
      Specified by:
      getSupports in class AbstractBipolarFramework
      Returns:
      all supports of this theory.

    • getAttacks

      public Set<Attack> getAttacks()
      Description copied from class: AbstractBipolarFramework
      Returns all attacks of this theory.
      Specified by:
      getAttacks in class AbstractBipolarFramework
      Returns:
      all attacks of this theory.

    • toEAF

      public EvidentialArgumentationFramework toEAF()
      translates this necessity argumentation framework into an evidential argumentation framework Translation algorithm from: Polberg, Oren. Revisiting Support in Abstract Argumentation Systems. 2014
      Returns:
      the corresponding evidential argumentation framework

    • toDAF

      public DeductiveArgumentationFramework toDAF()
      translates this NAF into the corresponding framework with support in a deductive sense only works for NAFs which contain only binary support relations See Cayrol, Lagasquie-Schiex. Bipolarity in argumentation graphs: Towards a better understanding. 2013
      Returns:
      the corresponding DAF

    • compareTo

      public int compareTo(NecessityArgumentationFramework o)
      Specified by:
      compareTo in interface Comparable<NecessityArgumentationFramework>

    • hashCode

      public int hashCode()
      Specified by:
      hashCode in interface Collection<BArgument>
      Overrides:
      hashCode in class BeliefSet<BArgument, DungSignature>