Package org.tweetyproject.arg.bipolar.syntax

Class BipolarArgumentationFramework

java.lang.Object
org.tweetyproject.commons.BeliefSet<Argument,DungSignature>
org.tweetyproject.arg.dung.syntax.DungTheory
org.tweetyproject.arg.bipolar.syntax.BipolarArgumentationFramework
All Implemented Interfaces:
Comparable<DungTheory>, Iterable<Argument>, Collection<Argument>, ArgumentationFramework<Argument>, BeliefBase, GeneralGraph<Argument>, Graph<Argument>
public class BipolarArgumentationFramework extends DungTheory
This class implements a bipolar abstract argumentation theory with support and attack relation.
Author:
Lars Bengel
See Also:
  • "Cayrol C., A. Cohen, and M.-C. Lagasquie-Schiex. 'Higher-order interactions (bipolar or not) in abstract argumentation: A state of the art'. Handbook of Formal Argumentation Vol. 2, 2021."
  • "Cohen A., S. Gottifredi, A. J. Garcia, and G. R. Simari. 'A survey of different approaches to support in argumentation systems'. Knowledge Engineering Review, 29(5):513–550, 2014."

  • Constructor Details

    • BipolarArgumentationFramework

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

    • BipolarArgumentationFramework

      public BipolarArgumentationFramework(BipolarArgumentationFramework graph)
      Construct new BAF from given graph
      Parameters:
      graph - some graph (must be an instance of BAF)

  • Method Details

    • isCoherent

      public boolean isCoherent(Collection<Argument> args)
      Determines whether 'args' is coherent, i.e., whether there exists no argument that is both (indirectly) supported and attacked (either supported or indirectly) by 'args'
      Parameters:
      args - some set of arguments
      Returns:
      "true" iff 'args' is coherent

    • isStronglyConflictFree

      public boolean isStronglyConflictFree(Collection<Argument> args)
      Determines whether 'args' is strongly conflict-free, i.e., whether 'args' is conflict-free wrt. supported and indirect attacks
      Parameters:
      args - some set of arguments
      Returns:
      "true" iff 'args' is strongly conflict-free

    • isStronglyDefendedBy

      public boolean isStronglyDefendedBy(Collection<Argument> ext, Argument arg)
      Determines whether 'ext' strongly defends 'arg', i.e., whether 'arg' is defended under consideration of supported and indirect attacks
      Parameters:
      ext - some set of arguments
      arg - some argument
      Returns:
      "true" iff 'arg' is strongly defended by 'ext'

    • isCoherentAdmissible

      public boolean isCoherentAdmissible(Collection<Argument> args)
      Determines whether 'args' is coherent admissible, i.e., whether 'args' is coherent and strongly defends all its arguments
      Parameters:
      args - some set of arguments
      Returns:
      "true" iff 'args' is coherent admissible

    • isCoalition

      public boolean isCoalition(Collection<Argument> args)
      Determines whether 'args' is a coalition, i.e., whether 'args' is a maximal conflict-free set of arguments that is connected via the support relation.
      Parameters:
      args - some set of arguments
      Returns:
      "true" if 'args' is a coalition of this BAF

    • getCoalitions

      public Collection<Collection<Argument>> getCoalitions()
      Computes the set of all coalition of this BAF A coalition is a maximal conflict-free set of arguments that is connected via the support relation.
      Returns:
      the set of coalitions

    • getCoalitionGraph

      public DungTheory getCoalitionGraph()
      Computes the coalition graph for this BAF. A coalition is a maximal conflict-free set of arguments that is connected via the support relation. There is an attack between two coalitions iff there is an attack between members of each coalition.
      Returns:
      the coalition graph for this BAF

    • getAssociatedTheory

      public DungTheory getAssociatedTheory()
      Returns the corresponding abstract argumentation framework where all supported and indirect attacks are included directly
      Returns:
      an argumentation framework

    • getAssociatedTheory

      public DungTheory getAssociatedTheory(Support.Type type)
      Induces an argumentation framework by resolving the complex attacks of the given support interpretation
      Parameters:
      type - the support interpretation
      Returns:
      the argumentation framework induced via the given support interpretation

    • isSupportedAttack

      public boolean isSupportedAttack(Argument arg1, Argument arg2)
      Determine if there is a supported attack from arg1 to arg2
      Parameters:
      arg1 - some argument
      arg2 - some argument
      Returns:
      "true" if there is a supported attack from arg1 to arg2

    • isIndirectAttack

      public boolean isIndirectAttack(Argument arg1, Argument arg2)
      Determine if there is an indirect attack from arg1 to arg2
      Overrides:
      isIndirectAttack in class DungTheory
      Parameters:
      arg1 - some argument
      arg2 - some argument
      Returns:
      "true" if there is an indirect attack from arg1 to arg2

    • isMediatedAttack

      public boolean isMediatedAttack(Argument arg1, Argument arg2)
      Determine if there is a mediated attack from arg1 to arg2
      Parameters:
      arg1 - some argument
      arg2 - some argument
      Returns:
      "true" if there is a mediated attack from arg1 to arg2

    • getSupportedAttacks

      public Collection<Attack> getSupportedAttacks()
      Computes the set of supported attacks of this BAF
      Returns:
      the set of supported attacks of this BAF

    • getIndirectAttacks

      public Collection<Attack> getIndirectAttacks()
      Computes the set of indirect attacks of this BAF
      Returns:
      the set of indirect attacks of this BAF

    • getMediatedAttacks

      public Collection<Attack> getMediatedAttacks()
      Computes the set of mediated attacks of this BAF
      Returns:
      the set of mediated attacks of this BAF

    • getSupported

      public Collection<Argument> getSupported(Collection<Argument> ext)
      Compute the set of arguments supported by ext
      Parameters:
      ext - some set of arguments
      Returns:
      the set of arguments supported by ext

    • getSupporters

      public Collection<Argument> getSupporters(Collection<Argument> ext)
      Compute the set of arguments supporting by ext
      Parameters:
      ext - some set of arguments
      Returns:
      the set of arguments supporting by ext

    • getSupported

      public Collection<Argument> getSupported(Argument arg)
      Compute the set of arguments supported by arg
      Parameters:
      arg - some argument
      Returns:
      the set of arguments supported by arg

    • getSupporters

      public Collection<Argument> getSupporters(Argument arg)
      Compute the set of arguments supporting by arg
      Parameters:
      arg - some argument
      Returns:
      the set of arguments supporting by arg

    • add

      public boolean add(Support supp)
      Adds the given support to this bipolar argumentation framework.
      Parameters:
      supp - a support
      Returns:
      "true" if the set of supports has been modified.

    • addSupport

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

    • addAllSupports

      public boolean addAllSupports(Collection<? extends Support> c)
      Adds the set of supports to this framework.
      Parameters:
      c - a collection of supports
      Returns:
      "true" if this framework has been modified.

    • getSupports

      public Collection<Support> getSupports()
      Returns the set of supports of this framework
      Returns:
      the set of supports

    • compareTo

      public int compareTo(BipolarArgumentationFramework o)
      Compare to other instance based on hash code
      Parameters:
      o - another BAF instance
      Returns:
      the difference in hash code

    • hashCode

      public int hashCode()
      Specified by:
      hashCode in interface Collection<Argument>
      Overrides:
      hashCode in class DungTheory

    • prettyPrint

      public String prettyPrint()
      Pretty prints this BAF
      Overrides:
      prettyPrint in class DungTheory
      Returns:
      String representation of this BAF

    • isSupportedBy

      public boolean isSupportedBy(Argument arg1, Argument arg2)
      Check whether arg1 is directly supported by arg2
      Parameters:
      arg1 - some argument
      arg2 - some argument
      Returns:
      'true' if arg1 is directly supported by arg2