java.lang.Object
- net.sf.tweety.commons.BeliefSet<Argument,DungSignature>
- - net.sf.tweety.arg.dung.syntax.DungTheory

All Implemented Interfaces:

java.lang.Comparable<DungTheory>, java.lang.Iterable<Argument>, java.util.Collection<Argument>, BeliefBase, Graph<Argument>

Direct Known Subclasses:

ExecutableDungTheory, ProbabilisticArgumentationFramework, SocialAbstractArgumentationFramework, StructuredArgumentationFramework, WeightedDungTheory
```
public class DungTheory
extends BeliefSet<Argument,DungSignature>
implements Graph<Argument>, java.lang.Comparable<DungTheory>
```
This class implements an abstract argumentation theory in the sense of Dung.

See

Phan Minh Dung. On the Acceptability of Arguments and its Fundamental Role in Nonmonotonic Reasoning, Logic Programming and n-Person Games. In Artificial Intelligence, Volume 77(2):321-358. 1995

Author:

Matthias Thimm, Tjitze Rienstra

Field Summary
- Fields inherited from class net.sf.tweety.commons.BeliefSet
  EQUALS_USES_SIGNATURE
- Fields inherited from interface net.sf.tweety.graphs.Graph
  IGNORE_SELFLOOPS, INVERT_SELFLOOPS, REMOVE_SELFLOOPS

Constructor Summary

Constructors
Constructor	Description
`DungTheory()`	Default constructor; initializes empty sets of arguments and attacks
`DungTheory(Graph<Argument> graph)`	Creates a new theory from the given graph.

Method Summary

Modifier and Type	Method	Description
`boolean`	`add(Argument argument)`	Adds the given node to this graph.
`boolean`	`add(Attack attack)`	Adds the given attack to this dung theory.
`boolean`	`add(Attack... attacks)`	Adds the given attacks to this dung theory.
`boolean`	`add(DungTheory theory)`	Adds all arguments and attacks of the given theory to this theory
`boolean`	`add(Edge<Argument> edge)`	Adds the given edge to this graph.
`boolean`	`addAllAttacks(java.util.Collection<? extends Attack> c)`	Adds the set of attacks to this Dung theory.
`boolean`	`addAttack(Argument attacker, Argument attacked)`	Adds an attack from the first argument to the second to thisDdung theory.
`boolean`	`areAdjacent(Argument a, Argument b)`	Returns "true" iff the two nodes are connected by a directed edge from a to b or an undirected edge.
`int`	`compareTo(DungTheory o)`
`boolean`	`contains(java.lang.Object o)`	Returns "true" when this graph contains the given node or edge.
`boolean`	`containsAll(java.util.Collection<?> c)`
`boolean`	`containsAttack(Attack att)`	Checks whether this theory contains the given attack.
`<S extends Node> boolean`	`containsCycle()`	Checks whether there is at least one cycle in this DungTheory.
`boolean`	`equals(java.lang.Object obj)`
`boolean`	`existsDirectedPath(Argument node1, Argument node2)`	Checks whether there is a (directed) path from node1 to node2.
`Extension`	`faf(Extension extension)`	The characteristic function of an abstract argumentation framework: F_AF(S) = {A\|A is acceptable wrt.
`Matrix`	`getAdjacencyMatrix()`	Returns the adjacency matrix of this graph (the order of the nodes is the same as returned by "iterator()").
`java.util.Set<Argument>`	`getAttacked(Argument argument)`	Computes the set {A \| (argument,A) in attacks}.
`java.util.Set<Argument>`	`getAttackers(Argument argument)`	Computes the set {A \| (A,argument) in attacks}.
`java.util.Set<Attack>`	`getAttacks()`	Returns all attacks of this theory.
`java.util.Collection<Argument>`	`getChildren(Node node)`	Returns the set of children (node connected via an undirected edge or a directed edge where the given node is the parent) of the given node.
`DungTheory`	`getComplementGraph(int selfloops)`	Returns the complement graph of this graph, i.e.
`java.util.Collection<Graph<Argument>>`	`getComponents()`
`Edge<Argument>`	`getEdge(Argument a, Argument b)`	Returns the corresponding edge (a,b) if a and b are adjacent.
`java.util.Collection<? extends Edge<? extends Argument>>`	`getEdges()`	Returns the edges of this graph.
`java.util.Collection<Graph<Argument>>`	`getInducedSubgraphs()`
`Signature`	`getMinimalSignature()`	Returns the signature of the language of this knowledge base.
`java.util.Collection<Argument>`	`getNeighbors(Argument node)`	Returns the set of neighbors of the given node.
`java.util.Collection<Argument>`	`getNodes()`	Returns the nodes of this graph.
`int`	`getNumberOfNodes()`	Returns the number of nodes in this graph.
`java.util.Collection<Argument>`	`getParents(Node node)`	Returns the set of parents (node connected via an undirected edge or a directed edge where the given node is the child) of the given node.
`Graph<Argument>`	`getRestriction(java.util.Collection<Argument> arguments)`	Returns copy of this graph consisting only of the given nodes and all corresponding edges.
`java.util.Collection<java.util.Collection<Argument>>`	`getStronglyConnectedComponents()`	Returns the strongly connected components of this graph.
`java.util.Collection<Graph<Argument>>`	`getSubgraphs()`	Returns the set of sub graphs of this graph.
`boolean`	`hasAttackBranch(Argument a)`	If this graph is acyclic, this method checks if the given argument has an attack branch, i.e.
`boolean`	`hasDefenseBranch(Argument a)`	If this graph is acyclic, this method checks if the given argument has a defense branch, i.e.
`int`	`hashCode()`
`boolean`	`hasSelfLoops()`	Returns "true" iff the graph has a self loop (an edge from a node to itself).
`boolean`	`isAttackBranch(Argument a, Argument b)`	Checks whether the path from b to a is an attack branch, i.e.
`boolean`	`isAttacked(Extension ext1, Extension ext2)`	returns true if some argument of `ext2` attacks some argument in `ext1`
`boolean`	`isAttacked(Argument argument, Extension ext)`	returns true if some argument of `ext` attacks argument.
`boolean`	`isAttackedBy(Argument argument, java.util.Collection<Argument> ext)`	returns true if some argument of `ext` is attacked by argument.
`boolean`	`isAttackedBy(Argument arg1, Argument arg2)`	Checks whether arg1 is attacked by arg2.
`boolean`	`isAttackingAllOtherArguments(Extension ext)`	returns true if `arguments` attack all other arguments in the theory
`boolean`	`isCoherent()`	Determines if the theory is coherent, i.e., if each preferred extension is stable
`boolean`	`isDefenseBranch(Argument a, Argument b)`	Checks whether the path from b to a is a defense branch, i.e.
`boolean`	`isIndirectAttack(Argument arg1, Argument arg2)`	Checks whether "arg1" indirectly attacks "arg2", i.e.
`boolean`	`isRelativelyCoherent()`	Determines if the theory is relatively coherent, i.e., if the grounded extension coincides with the intersection of all preferred extensions
`boolean`	`isStable(Extension e)`	Checks whether the given extension is stable wrt.
`boolean`	`isSupport(Argument arg1, Argument arg2)`	Checks whether "arg1" supports "arg2", i.e.
`boolean`	`isWeightedGraph()`	Checks whether this graph only contains weighted edges.
`boolean`	`isWellFounded()`	returns true iff the theory is well-founded, i.e., there is no infinite sequence A1,A2,...
`java.lang.String`	`prettyPrint()`	Pretty print of the theory.
`boolean`	`remove(Argument a)`	Removes the argument and all its attacks
`boolean`	`remove(Attack attack)`	Removes the given attack from this Dung theory.
`boolean`	`removeAll(java.util.Collection<?> c)`
`java.lang.String`	`toString()`

Methods inherited from class net.sf.tweety.commons.BeliefSet
add, addAll, clear, getSignature, isEmpty, iterator, remove, retainAll, setSignature, size, toArray, toArray

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.Collection
parallelStream, removeIf, spliterator, stream, toArray

Methods inherited from interface net.sf.tweety.graphs.Graph
iterator

Methods inherited from interface java.lang.Iterable
forEach

- Constructor Detail
  - DungTheory
```
public DungTheory()
```
    Default constructor; initializes empty sets of arguments and attacks
  - DungTheory
```
public DungTheory(Graph<Argument> graph)
```
    Creates a new theory from the given graph.
    
    Parameters:
    
    graph - some graph
- Method Detail
  - getMinimalSignature
```
public Signature getMinimalSignature()
```
    Description copied from interface: BeliefBase
    
    Returns the signature of the language of this knowledge base.
    
    Specified by:
    
    getMinimalSignature in interface BeliefBase
    
    Returns:
    
    the signature of the language of this knowledge base.
  - isAttackingAllOtherArguments
```
public boolean isAttackingAllOtherArguments(Extension ext)
```
    returns true if arguments attack all other arguments in the theory
    
    Parameters:
    
    ext - An extension contains a set of arguments.
    
    Returns:
    
    true if arguments attack all other arguments in the theory
  - isWellFounded
```
public boolean isWellFounded()
```
    returns true iff the theory is well-founded, i.e., there is no infinite sequence A1,A2,... of arguments with Ai attacking Ai+1
    
    Returns:
    
    true iff the theory is well-founded
  - isCoherent
```
public boolean isCoherent()
```
    Determines if the theory is coherent, i.e., if each preferred extension is stable
    
    Returns:
    
    true if the theory is coherent
  - isRelativelyCoherent
```
public boolean isRelativelyCoherent()
```
    Determines if the theory is relatively coherent, i.e., if the grounded extension coincides with the intersection of all preferred extensions
    
    Returns:
    
    true if the theory is relatively coherent
  - getAttackers
```
public java.util.Set<Argument> getAttackers(Argument argument)
```
    Computes the set {A | (A,argument) in attacks}.
    
    Parameters:
    
    argument - an argument
    
    Returns:
    
    the set of all arguments that attack argument.
  - getAttacked
```
public java.util.Set<Argument> getAttacked(Argument argument)
```
    Computes the set {A | (argument,A) in attacks}.
    
    Parameters:
    
    argument - an argument
    
    Returns:
    
    the set of all arguments that are attacked by argument.
  - isAttacked
```
public boolean isAttacked(Argument argument,
                          Extension ext)
```
    returns true if some argument of ext attacks argument.
    
    Parameters:
    
    argument - an argument
    
    ext - an extension, ie. a set of arguments
    
    Returns:
    
    true if some argument of ext attacks argument.
  - isAttackedBy
```
public boolean isAttackedBy(Argument argument,
                            java.util.Collection<Argument> ext)
```
    returns true if some argument of ext is attacked by argument.
    
    Parameters:
    
    argument - an argument
    
    ext - an extension, ie. a set of arguments
    
    Returns:
    
    true if some argument of ext is attacked by argument.
  - isAttacked
```
public boolean isAttacked(Extension ext1,
                          Extension ext2)
```
    returns true if some argument of ext2 attacks some argument in ext1
    
    Parameters:
    
    ext1 - an extension, ie. a set of arguments
    
    ext2 - an extension, ie. a set of arguments
    
    Returns:
    
    true if some argument of ext2 attacks some argument in ext1
  - isStable
```
public boolean isStable(Extension e)
```
    Checks whether the given extension is stable wrt. this theory.
    
    Parameters:
    
    e - some extension
    
    Returns:
    
    "true" iff the extension is stable.
  - faf
```
public Extension faf(Extension extension)
```
    The characteristic function of an abstract argumentation framework: F_AF(S) = {A|A is acceptable wrt. S}.
    
    Parameters:
    
    extension - an extension (a set of arguments).
    
    Returns:
    
    an extension (a set of arguments).
  - isAttackedBy
```
public boolean isAttackedBy(Argument arg1,
                            Argument arg2)
```
    Checks whether arg1 is attacked by arg2.
    
    Parameters:
    
    arg1 - an argument.
    
    arg2 - an argument.
    
    Returns:
    
    "true" if arg1 is attacked by arg2
  - isIndirectAttack
```
public boolean isIndirectAttack(Argument arg1,
                                Argument arg2)
```
    Checks whether "arg1" indirectly attacks "arg2", i.e. whether there is an odd-length path from "arg1" to "arg2".
    
    Parameters:
    
    arg1 - an AbstractArgument.
    
    arg2 - an AbstractArgument.
    
    Returns:
    
    "true" iff "arg1" indirectly attacks "arg2".
  - isSupport
```
public boolean isSupport(Argument arg1,
                         Argument arg2)
```
    Checks whether "arg1" supports "arg2", i.e. whether there is an even-length path from "arg1" to "arg2".
    
    Parameters:
    
    arg1 - an AbstractArgument.
    
    arg2 - an AbstractArgument.
    
    Returns:
    
    "true" iff "arg1" supports "arg2".
  - isAttackBranch
```
public boolean isAttackBranch(Argument a,
                              Argument b)
```
    Checks whether the path from b to a is an attack branch, i.e. whether b is a non-attacked (indirect) attacker of a.
    
    Parameters:
    
    a - an Argument
    
    b - an Argument
    
    Returns:
    
    true iff the path from a to b is an attack branch, false otherwise
  - isDefenseBranch
```
public boolean isDefenseBranch(Argument a,
                               Argument b)
```
    Checks whether the path from b to a is a defense branch, i.e. whether b is a non-attacked (indirect) defender of a.
    
    Parameters:
    
    a - an Argument
    
    b - an Argument
    
    Returns:
    
    true iff the path from a to b is a defense branch, false otherwise
  - hasAttackBranch
```
public boolean hasAttackBranch(Argument a)
```
    If this graph is acyclic, this method checks if the given argument has an attack branch, i.e. if it is (indirectly) attacked by a non-attacked argument.
    
    Parameters:
    
    a - an Argument
    
    Returns:
    
    true iff this graph is acyclic and a has an attack branch, false otherwise
  - hasDefenseBranch
```
public boolean hasDefenseBranch(Argument a)
```
    If this graph is acyclic, this method checks if the given argument has a defense branch, i.e. if it is supported by a non-attacked argument.
    
    Parameters:
    
    a - an Argument
    
    Returns:
    
    true iff this graph is acyclic and a has a defense branch, false otherwise
  - prettyPrint
```
public java.lang.String prettyPrint()
```
    Pretty print of the theory.
    
    Returns:
    
    the pretty print of the theory.
  - toString
```
public java.lang.String toString()
```
    Specified by:
    
    toString in interface BeliefBase
    
    Specified by:
    
    toString in interface Graph<Argument>
    
    Overrides:
    
    toString in class BeliefSet<Argument,DungSignature>
  - add
```
public boolean add(Attack attack)
```
    Adds the given attack to this dung theory.
    
    Parameters:
    
    attack - an attack
    
    Returns:
    
    "true" if the set of attacks has been modified.
  - add
```
public boolean add(Attack... attacks)
```
    Adds the given attacks to this dung theory.
    
    Parameters:
    
    attacks - some attacks
    
    Returns:
    
    "true" if the set of attacks has been modified.
  - addAttack
```
public boolean addAttack(Argument attacker,
                         Argument attacked)
```
    Adds an attack from the first argument to the second to thisDdung theory.
    
    Parameters:
    
    attacker - some argument
    
    attacked - some argument
    
    Returns:
    
    "true" if the set of attacks has been modified.
  - remove
```
public boolean remove(Attack attack)
```
    Removes the given attack from this Dung theory.
    
    Parameters:
    
    attack - an attack
    
    Returns:
    
    "true" if the set of attacks has been modified.
  - remove
```
public boolean remove(Argument a)
```
    Removes the argument and all its attacks
    
    Parameters:
    
    a - some argument
    
    Returns:
    
    true if this structure has been changed
  - removeAll
```
public boolean removeAll(java.util.Collection<?> c)
```
    Specified by:
    
    removeAll in interface java.util.Collection<Argument>
    
    Overrides:
    
    removeAll in class BeliefSet<Argument,DungSignature>
  - contains
```
public boolean contains(java.lang.Object o)
```
    Description copied from interface: Graph
    
    Returns "true" when this graph contains the given node or edge.
    
    Specified by:
    
    contains in interface java.util.Collection<Argument>
    
    Specified by:
    
    contains in interface Graph<Argument>
    
    Overrides:
    
    contains in class BeliefSet<Argument,DungSignature>
    
    Parameters:
    
    o - an object
    
    Returns:
    
    "true" if this graph contains the given node or edge.
  - containsAll
```
public boolean containsAll(java.util.Collection<?> c)
```
    Specified by:
    
    containsAll in interface java.util.Collection<Argument>
    
    Overrides:
    
    containsAll in class BeliefSet<Argument,DungSignature>
  - containsAttack
```
public boolean containsAttack(Attack att)
```
    Checks whether this theory contains the given attack.
    
    Parameters:
    
    att - some attack
    
    Returns:
    
    "true" iff this theory contains the given attack.
  - addAllAttacks
```
public boolean addAllAttacks(java.util.Collection<? extends Attack> c)
```
    Adds the set of attacks to this Dung theory.
    
    Parameters:
    
    c - a collection of attacks
    
    Returns:
    
    "true" if this Dung theory has been modified.
  - add
```
public boolean add(DungTheory theory)
```
    Adds all arguments and attacks of the given theory to this theory
    
    Parameters:
    
    theory - some Dung theory
    
    Returns:
    
    "true" if this Dung Theory has been modified
  - add
```
public boolean add(Argument argument)
```
    Description copied from interface: Graph
    
    Adds the given node to this graph.
    
    Specified by:
    
    add in interface java.util.Collection<Argument>
    
    Specified by:
    
    add in interface Graph<Argument>
    
    Overrides:
    
    add in class BeliefSet<Argument,DungSignature>
    
    Parameters:
    
    argument - some node.
    
    Returns:
    
    "true" iff the edge has been added successfully.
  - getAttacks
```
public java.util.Set<Attack> getAttacks()
```
    Returns all attacks of this theory.
    
    Returns:
    
    all attacks of this theory.
  - getRestriction
```
public Graph<Argument> getRestriction(java.util.Collection<Argument> arguments)
```
    Description copied from interface: Graph
    
    Returns copy of this graph consisting only of the given nodes and all corresponding edges.
    
    Specified by:
    
    getRestriction in interface Graph<Argument>
    
    Parameters:
    
    arguments - a set of nodes
    
    Returns:
    
    a graph.
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in interface java.util.Collection<Argument>
    
    Overrides:
    
    hashCode in class BeliefSet<Argument,DungSignature>
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Specified by:
    
    equals in interface java.util.Collection<Argument>
    
    Overrides:
    
    equals in class BeliefSet<Argument,DungSignature>
  - add
```
public boolean add(Edge<Argument> edge)
```
    Description copied from interface: Graph
    
    Adds the given edge to this graph. If at least one of the nodes the given edge connects is not in the graph, an illegal argument exception is thrown.
    
    Specified by:
    
    add in interface Graph<Argument>
    
    Parameters:
    
    edge - some edge.
    
    Returns:
    
    "true" iff the edge has been added successfully.
  - getNodes
```
public java.util.Collection<Argument> getNodes()
```
    Description copied from interface: Graph
    
    Returns the nodes of this graph.
    
    Specified by:
    
    getNodes in interface Graph<Argument>
    
    Returns:
    
    the nodes of this graph.
  - getNumberOfNodes
```
public int getNumberOfNodes()
```
    Description copied from interface: Graph
    
    Returns the number of nodes in this graph.
    
    Specified by:
    
    getNumberOfNodes in interface Graph<Argument>
    
    Returns:
    
    the number of nodes in this graph.
  - areAdjacent
```
public boolean areAdjacent(Argument a,
                           Argument b)
```
    Description copied from interface: Graph
    
    Returns "true" iff the two nodes are connected by a directed edge from a to b or an undirected edge.
    
    Specified by:
    
    areAdjacent in interface Graph<Argument>
    
    Parameters:
    
    a - some node
    
    b - some node
    
    Returns:
    
    "true" iff the two nodes are connected by a directed edge from a to b or an undirected edge.
  - getEdges
```
public java.util.Collection<? extends Edge<? extends Argument>> getEdges()
```
    Description copied from interface: Graph
    
    Returns the edges of this graph.
    
    Specified by:
    
    getEdges in interface Graph<Argument>
    
    Returns:
    
    the edges of this graph.
  - getChildren
```
public java.util.Collection<Argument> getChildren(Node node)
```
    Description copied from interface: Graph
    
    Returns the set of children (node connected via an undirected edge or a directed edge where the given node is the parent) of the given node.
    
    Specified by:
    
    getChildren in interface Graph<Argument>
    
    Parameters:
    
    node - some node (must be in the graph).
    
    Returns:
    
    the set of children of the given node.
  - getParents
```
public java.util.Collection<Argument> getParents(Node node)
```
    Description copied from interface: Graph
    
    Returns the set of parents (node connected via an undirected edge or a directed edge where the given node is the child) of the given node.
    
    Specified by:
    
    getParents in interface Graph<Argument>
    
    Parameters:
    
    node - some node (must be in the graph).
    
    Returns:
    
    the set of parents of the given node.
  - existsDirectedPath
```
public boolean existsDirectedPath(Argument node1,
                                  Argument node2)
```
    Description copied from interface: Graph
    
    Checks whether there is a (directed) path from node1 to node2.
    
    Specified by:
    
    existsDirectedPath in interface Graph<Argument>
    
    Parameters:
    
    node1 - some node.
    
    node2 - some node.
    
    Returns:
    
    "true" if there is a directed path from node1 to node2.
  - getNeighbors
```
public java.util.Collection<Argument> getNeighbors(Argument node)
```
    Description copied from interface: Graph
    
    Returns the set of neighbors of the given node.
    
    Specified by:
    
    getNeighbors in interface Graph<Argument>
    
    Parameters:
    
    node - some node (must be in the graph).
    
    Returns:
    
    the set of neighbors of the given node.
  - getAdjacencyMatrix
```
public Matrix getAdjacencyMatrix()
```
    Description copied from interface: Graph
    
    Returns the adjacency matrix of this graph (the order of the nodes is the same as returned by "iterator()").
    
    Specified by:
    
    getAdjacencyMatrix in interface Graph<Argument>
    
    Returns:
    
    the adjacency matrix of this graph
  - getComplementGraph
```
public DungTheory getComplementGraph(int selfloops)
```
    Description copied from interface: Graph
    
    Returns the complement graph of this graph, i.e. the graph on the same set of vertices as this graph that connects two vertices v and w with an edge if and only if v and w are not connected in this graph.
    
    Specified by:
    
    getComplementGraph in interface Graph<Argument>
    
    Parameters:
    
    selfloops - Indicates how to deal with selfloops:
    IGNORE_SELFLOOPS - ignore self loops (don't add and don't remove)
    INVERT_SELFLOOPS - deal with self loops like ordinary edges (add if not present and remove if present)
    REMOVE_SELFLOOPS - simple remove self loops, but don't add new ones.
    
    Returns:
    
    the complement graph of this graph.
  - hasSelfLoops
```
public boolean hasSelfLoops()
```
    Description copied from interface: Graph
    
    Returns "true" iff the graph has a self loop (an edge from a node to itself).
    
    Specified by:
    
    hasSelfLoops in interface Graph<Argument>
    
    Returns:
    
    "true" iff the graph has a self loop (an edge from a node to itself).
  - getEdge
```
public Edge<Argument> getEdge(Argument a,
                              Argument b)
```
    Description copied from interface: Graph
    
    Returns the corresponding edge (a,b) if a and b are adjacent. Otherwise it returns null.
    
    Specified by:
    
    getEdge in interface Graph<Argument>
    
    Parameters:
    
    a - some node
    
    b - some node
    
    Returns:
    
    the edge (a,b) or null.
  - isWeightedGraph
```
public boolean isWeightedGraph()
```
    Description copied from interface: Graph
    
    Checks whether this graph only contains weighted edges.
    
    Specified by:
    
    isWeightedGraph in interface Graph<Argument>
    
    Returns:
    
    "true" if all edges are weighted in this graph.
  - getStronglyConnectedComponents
```
public java.util.Collection<java.util.Collection<Argument>> getStronglyConnectedComponents()
```
    Description copied from interface: Graph
    
    Returns the strongly connected components of this graph. A set of nodes is strongly connected, if there is a path from each node to each other. A set of nodes is called strongly connected component if it is strongly connected and maximal with respect to set inclusion.
    
    Specified by:
    
    getStronglyConnectedComponents in interface Graph<Argument>
    
    Returns:
    
    the strongly connected components of this graph.
  - getSubgraphs
```
public java.util.Collection<Graph<Argument>> getSubgraphs()
```
    Description copied from interface: Graph
    
    Returns the set of sub graphs of this graph.
    
    Specified by:
    
    getSubgraphs in interface Graph<Argument>
    
    Returns:
    
    the set of sub graphs of this graph.
  - compareTo
```
public int compareTo(DungTheory o)
```
    Specified by:
    
    compareTo in interface java.lang.Comparable<DungTheory>
  - containsCycle
```
public <S extends Node> boolean containsCycle()
```
    Checks whether there is at least one cycle in this DungTheory.
    
    Type Parameters:
    
    S - the type of nodes
    
    Returns:
    
    "true" if there is a cycle in this DungTheory, "false" otherwise
  - getComponents
```
public java.util.Collection<Graph<Argument>> getComponents()
```
  - getInducedSubgraphs
```
public java.util.Collection<Graph<Argument>> getInducedSubgraphs()
```

Class DungTheory

Field Summary

Fields inherited from class net.sf.tweety.commons.BeliefSet

Fields inherited from interface net.sf.tweety.graphs.Graph

Constructor Summary

Method Summary

Methods inherited from class net.sf.tweety.commons.BeliefSet

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Collection

Methods inherited from interface net.sf.tweety.graphs.Graph

Methods inherited from interface java.lang.Iterable

Constructor Detail

DungTheory

DungTheory

Method Detail

getMinimalSignature

isAttackingAllOtherArguments

isWellFounded

isCoherent

isRelativelyCoherent

getAttackers

getAttacked

isAttacked

isAttackedBy

isAttacked

isStable

faf

isAttackedBy

isIndirectAttack

isSupport

isAttackBranch

isDefenseBranch

hasAttackBranch

hasDefenseBranch

prettyPrint

toString

add

add

addAttack

remove

remove

removeAll

contains

containsAll

containsAttack

addAllAttacks

add

add

getAttacks

getRestriction

hashCode

equals

add

getNodes

getNumberOfNodes

areAdjacent

getEdges

getChildren

getParents

existsDirectedPath

getNeighbors

getAdjacencyMatrix

getComplementGraph

hasSelfLoops

getEdge

isWeightedGraph

getStronglyConnectedComponents

getSubgraphs

compareTo

containsCycle

getComponents

getInducedSubgraphs