Uses of Class
org.tweetyproject.arg.bipolar.syntax.BArgument

Packages that use BArgument

Package	Description
org.tweetyproject.arg.bipolar.analysis
org.tweetyproject.arg.bipolar.analysis.extensions
org.tweetyproject.arg.bipolar.io
org.tweetyproject.arg.bipolar.syntax

Uses of BArgument in org.tweetyproject.arg.bipolar.analysis

Method parameters in org.tweetyproject.arg.bipolar.analysis with type arguments of type BArgument

Modifier and Type	Method	Description
AnalysisResult	Analysis.query(Set<BArgument> args)	Creates an AnalysisResult to store the results of the analysis
AnalysisResult	ApproxAnalysis.query(Set<BArgument> args)	Computes approximately what is probabilistic justification of the given set of arguments in the PEAF given error level
AnalysisResult	ConcurrentApproxAnalysis.query(Set<BArgument> args)	Computes approximately what is probabilistic justification of the given set of arguments in the PEAF given error level concurrently.
AnalysisResult	ConcurrentExactAnalysis.query(Set<BArgument> args)	Computes exactly what is probabilistic justification of the given set of arguments in the PEAF.
AnalysisResult	ExactAnalysis.query(Set<BArgument> args)	Computes exactly what is probabilistic justification of the given set of arguments in the PEAF.

Uses of BArgument in org.tweetyproject.arg.bipolar.analysis.extensions

Method parameters in org.tweetyproject.arg.bipolar.analysis.extensions with type arguments of type BArgument

Modifier and Type	Method	Description
AnalysisResult	AbstractExtensionAnalysis.query(Set<BArgument> args)

Uses of BArgument in org.tweetyproject.arg.bipolar.io

Method parameters in org.tweetyproject.arg.bipolar.io with type arguments of type BArgument

Modifier and Type	Method	Description
static void	EdgeListWriter.write(String path, PEAFTheory peafTheory, Set<BArgument> query)	Writes a PEAFTheory and the query to a EdgeList format given the path

Uses of BArgument in org.tweetyproject.arg.bipolar.syntax

Fields in org.tweetyproject.arg.bipolar.syntax with type parameters of type BArgument

Modifier and Type	Field	Description
final Set<BArgument>	InducibleEAF.arguments	A subset of arguments from PEAF
final Set<BArgument>	InducibleEAF.newArguments	A subset of arguments from PEAF that can be used to create a new EAF (connected to InducibleEAF)

Methods in org.tweetyproject.arg.bipolar.syntax that return BArgument

Modifier and Type	Method	Description
BArgument	AbstractEAFTheory.addArgument(int identifier)	Create and add a new argument with identifier
BArgument	EAFTheory.addArgument(int identifier)	Add an argument with an integer identifier
BArgument	NamedPEAFTheory.addArgument(int identifier, String name, String aifNodeIdentifier)	Add argument with names
BArgument	PEAFTheory.addArgument(int identifier)	Add an argument with an integer identifier
BArgument	NamedPEAFTheory.getArgumentByIdentifier(String identifier)	Returns the EArgument object given its identifier
BArgument	BinaryAttack.getAttacked()	returns the attacked argument of this attack relation.
BArgument	SetAttack.getAttacked()	returns the attacked argument of this attack relation.
BArgument	BinaryAttack.getAttacker()	returns the attacking argument of this attack relation.
BArgument	AbstractEAFTheory.getEta()	Get the eta (the root) argument
BArgument	EvidentialArgumentationFramework.getEta()	returns the special argument eta
BArgument	BinarySupport.getSupported()	returns the supported argument of this support relation.
BArgument	BinarySupport.getSupporter()	returns the supporting argument of this support relation.

Methods in org.tweetyproject.arg.bipolar.syntax that return types with arguments of type BArgument

Modifier and Type	Method	Description
ArrayList<BArgument>	AbstractEAFTheory.getArguments()	Return a list of arguments
Set<BArgument>	ArgumentSet.getArguments()	Returns the set of arguments contained in this ArgumentSet.
ArrayList<BArgument>	EAFTheory.getArguments()	Gets arguments of the EAF
Set<BArgument>	InducibleEAF.getArguments()
Set<BArgument>	AbstractEAFTheory.getArgumentsAsSet()	Get all arguments
Set<BArgument>	AbstractBipolarFramework.getAttacked(BipolarEntity arg)	Computes the set {A | (argument,A) in attacks}.
Collection<BArgument>	AbstractBipolarFramework.getChildren(Node node)
Graph<BArgument>	AbstractBipolarFramework.getComplementGraph(int i)
Set<BArgument>	NecessityArgumentationFramework.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
Set<BArgument>	AbstractBipolarFramework.getDirectSupported(BipolarEntity arg)	Computes the set {A | (argument,A) in supports}.
Edge<BArgument>	AbstractBipolarFramework.getEdge(BArgument a, BArgument b)
Collection<? extends Edge<? extends BArgument>>	AbstractBipolarFramework.getEdges()
Set<BArgument>	EvidentialArgumentationFramework.getEvidenceSupportedArguments()	returns all arguments that have evidential support in this framework
Collection<Collection<BArgument>>	EvidentialArgumentationFramework.getMinimalEvidenceSupportedAttackers(BArgument argument)	computes all subsets which carry out a minimal evidence supported attack on argument
Set<Set<BArgument>>	EvidentialArgumentationFramework.getMinimalEvidentialSupporters(BArgument argument)	computes all subsets which minimal e-support argument
Collection<BArgument>	AbstractBipolarFramework.getNeighbors(BArgument node)
Set<BArgument>	InducibleEAF.getNewArguments()
Collection<BArgument>	AbstractBipolarFramework.getNodes()
Collection<BArgument>	AbstractBipolarFramework.getParents(Node node)
Graph<BArgument>	AbstractBipolarFramework.getRestriction(Collection<BArgument> collection)
Collection<Collection<BArgument>>	AbstractBipolarFramework.getStronglyConnectedComponents()
Collection<Graph<BArgument>>	AbstractBipolarFramework.getSubgraphs()
Set<BArgument>	DeductiveArgumentationFramework.getSupported(Collection<BArgument> ext)	Computes the set {A | there is a sequence of direct supports from an element of ext to A
Set<BArgument>	DeductiveArgumentationFramework.getSupported(BArgument argument)	Computes the set {A | there is a sequence of direct supports from argument to A
Set<BArgument>	EvidentialArgumentationFramework.getSupported(ArgumentSet argumentSet)	Computes the set {A | there is a sequence of direct supports from argumentSet to A}
Set<BArgument>	DeductiveArgumentationFramework.getSupporters(BArgument argument)	Computes the set {A | there is a sequence of direct supports from A to argument
Iterator<BArgument>	ArgumentSet.iterator()	Returns an iterator over the arguments in this set.
Iterator<BArgument>	BArgument.iterator()	Returns an iterator over the arguments in this set.
Iterator<BArgument>	BinaryAttack.iterator()
Iterator<BArgument>	BinarySupport.iterator()
Iterator<BArgument>	EAttack.iterator()
Iterator<BArgument>	SetAttack.iterator()
Iterator<BArgument>	SetSupport.iterator()

Methods in org.tweetyproject.arg.bipolar.syntax with parameters of type BArgument

Modifier and Type	Method	Description
boolean	AbstractBipolarFramework.add(BArgument argument)	Adds argument to this argumentation framework
boolean	ArgumentSet.add(BArgument arg0)	Adds an argument to this set.
void	AbstractEAFTheory.addArgument(BArgument argument)	Add an argument
boolean	DeductiveArgumentationFramework.addAttack(BArgument attacker, BArgument attacked)	Adds an attack from the first argument to the second to this deductive argumentation system.
boolean	EvidentialArgumentationFramework.addAttack(ArgumentSet attacker, BArgument attacked)	Adds an attack from the set of arguments to the argument to this evidential argumentation system.
boolean	EvidentialArgumentationFramework.addAttack(BArgument attacker, BArgument attacked)	Adds an attack from the first argument to the second to this evidential argumentation system.
boolean	NecessityArgumentationFramework.addAttack(BArgument attacker, BArgument attacked)	Adds an attack from the first argument to the second to this necessity argumentation system.
boolean	EvidentialArgumentationFramework.addPrimaFacie(BArgument argument)	Adds a argument with evidential support to this evidential argumentation system If the argument is already in this evidential argumentation system, adds evidential support
boolean	DeductiveArgumentationFramework.addSupport(BipolarEntity bipolarEntity, BArgument supported)	Adds a support from the first argument to the second to this bipolar argumentation framework.
boolean	EvidentialArgumentationFramework.addSupport(ArgumentSet supporter, BArgument supported)	Adds a support from a set of arguments to an argument to this argumentation framework.
boolean	EvidentialArgumentationFramework.addSupport(BArgument supporter, BArgument supported)	Adds a support from the first argument to the second to this argumentation framework.
boolean	NecessityArgumentationFramework.addSupport(ArgumentSet supporter, BArgument supported)	Adds a support from a set of arguments to an argument to this argumentation framework.
boolean	NecessityArgumentationFramework.addSupport(BArgument supporter, BArgument supported)	Adds a support from the first argument to the second to this argumentation framework.
boolean	AbstractBipolarFramework.areAdjacent(BArgument a, BArgument b)
boolean	SetSupport.contains(BArgument argument)	Return true if the given argument is in this support relation.
boolean	AbstractBipolarFramework.existsDirectedPath(BArgument node1, BArgument node2)
Set<BipolarEntity>	AbstractBipolarFramework.getAttackers(BArgument argument)	Computes the set {A | (A,argument) in attacks}.
Set<BipolarEntity>	EvidentialArgumentationFramework.getAttackingSets(BArgument argument)	Computes the set {S | (S, argument) in attacks}.
Set<BipolarEntity>	AbstractBipolarFramework.getDirectSupporters(BArgument argument)	Computes the set {A | (A,argument) in supports}.
Edge<BArgument>	AbstractBipolarFramework.getEdge(BArgument a, BArgument b)
String	NamedPEAFTheory.getIdentifier(BArgument e)
Set<BinaryAttack>	DeductiveArgumentationFramework.getMediatedAttacks(BArgument arg1)	Calculates the set of mediated attack from "arg1" to other arguments "y", i.e.
Collection<Collection<BArgument>>	EvidentialArgumentationFramework.getMinimalEvidenceSupportedAttackers(BArgument argument)	computes all subsets which carry out a minimal evidence supported attack on argument
Set<Set<BArgument>>	EvidentialArgumentationFramework.getMinimalEvidentialSupporters(BArgument argument)	computes all subsets which minimal e-support argument
String	NamedPEAFTheory.getNameOfArgument(BArgument argument)	Returns the name of the argument given EArgument object's reference
Collection<BArgument>	AbstractBipolarFramework.getNeighbors(BArgument node)
Set<BArgument>	DeductiveArgumentationFramework.getSupported(BArgument argument)	Computes the set {A | there is a sequence of direct supports from argument to A
Set<BinaryAttack>	DeductiveArgumentationFramework.getSupportedAttacks(BArgument arg1)	Calculates the set of supported attack from "arg1" to other arguments "y", i.e.
Set<BArgument>	DeductiveArgumentationFramework.getSupporters(BArgument argument)	Computes the set {A | there is a sequence of direct supports from A to argument
Set<Support>	AbstractEAFTheory.getSupports(BArgument arg)	Get all supports invloving argument arg
boolean	EvidentialArgumentationFramework.hasEvidentialSupport(BArgument argument, Collection<BArgument> ext)	returns true if argument has evidential support from set ext.
boolean	EvidentialArgumentationFramework.hasMinimalEvidentialSupport(BArgument argument, Collection<BArgument> ext)	returns true if argument has minimal evidential support from set ext.
abstract boolean	AbstractBipolarFramework.isAcceptable(BArgument argument, Collection<BArgument> ext)	checks whether argument is acceptable wrt.
boolean	DeductiveArgumentationFramework.isAcceptable(BArgument argument, Collection<BArgument> ext)
boolean	EAFTheory.isAcceptable(BArgument argument, Collection<BArgument> ext)
boolean	EvidentialArgumentationFramework.isAcceptable(BArgument argument, Collection<BArgument> ext)	return true if argument is acceptable with respect to ext argument is acceptable wrt.
boolean	NecessityArgumentationFramework.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
boolean	PEAFTheory.isAcceptable(BArgument argument, Collection<BArgument> ext)
boolean	DeductiveArgumentationFramework.isAttacked(BArgument argument, Set<BArgument> argumentSet)	returns true if some argument of argumentSet attacks argument.
boolean	AbstractBipolarFramework.isAttackedBy(BArgument arg1, BipolarEntity arg2)	Checks whether arg1 is attacked by arg2.
boolean	NecessityArgumentationFramework.isAttackedBy(BArgument argument, Collection<BArgument> argumentSet)	checks whether argument is attacked by any argument in argumentSet
boolean	DeductiveArgumentationFramework.isAttacking(BArgument argument, Set<BArgument> argSet)	returns true if some argument of argSet is attacked by argument.
boolean	AbstractBipolarFramework.isDirectSupportedBy(BArgument arg1, BipolarEntity arg2)	Checks whether arg1 is directly supported by arg2.
boolean	EvidentialArgumentationFramework.isEvidenceSupportedAttack(Collection<BArgument> ext, BArgument argument)	returns true if ext carries out an evidence supported attack on argument ext e-support-attacks an argument a iff a subset S of ext attacks a and all elements of S have e-support from ext.
boolean	DeductiveArgumentationFramework.isMediatedAttack(BArgument arg1, BArgument arg2)	Checks whether there exists a mediated attack from "arg1" to "arg2", i.e.
boolean	EvidentialArgumentationFramework.isMinimalEvidenceSupportedAttack(Collection<BArgument> ext, BArgument argument)	returns true if ext carries out a minimal evidence supported attack on argument i.e.
boolean	NecessityArgumentationFramework.isNCycleFreeIn(BArgument argument, Collection<BArgument> argumentSet)	checks if argument is N-Cycle-Free in the set of arguments
boolean	DeductiveArgumentationFramework.isSuperMediatedAttack(BArgument arg1, BArgument arg2)	Checks whether there exists a super-mediated attack from "arg1" to "arg2", i.e.
boolean	DeductiveArgumentationFramework.isSupportedAttack(BArgument arg1, BArgument arg2)	Checks whether there exists a supported attack from "arg1" to "arg2", i.e.
boolean	AbstractBipolarFramework.remove(BArgument a)	Removes the argument and all its attacks and supports
boolean	EvidentialArgumentationFramework.removePrimaFacie(BArgument argument)	removes evidential support from argument, does not remove argument itself

Method parameters in org.tweetyproject.arg.bipolar.syntax with type arguments of type BArgument

Modifier and Type	Method	Description
boolean	AbstractBipolarFramework.add(GeneralEdge<BArgument> edge)
boolean	ArgumentSet.addAll(Collection<? extends BArgument> arg0)	Adds a collection of arguments to this set.
void	AbstractEAFTheory.addAttack(Set<BArgument> froms, Set<BArgument> tos)	Add an attack with sets
void	EAFTheory.addSupport(HashSet<BArgument> froms, HashSet<BArgument> tos)	Add a support with index arrays (froms and tos)
void	PEAFTheory.addSupport(Set<BArgument> froms, Set<BArgument> tos, double cp)	Add a support with sets for many to many mapping
boolean	EAFTheory.checkIsSelfSupporting(Set<BArgument> A)	Checks if a set of arguments whether they are self-supporting or not This is used for conversion from EAF to DAF.
NamedPEAFTheory	NamedPEAFTheory.createCopyWithoutArguments(Set<BArgument> args)
Set<BArgument>	NecessityArgumentationFramework.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
Graph<BArgument>	AbstractBipolarFramework.getRestriction(Collection<BArgument> collection)
Set<BArgument>	DeductiveArgumentationFramework.getSupported(Collection<BArgument> ext)	Computes the set {A | there is a sequence of direct supports from an element of ext to A
static Set<String>	NamedPEAFTheory.giveNames(Map<BArgument,String> names, Set<BArgument> args)	Helper function to give the names of a set of arguments Static such that it can work with PEAFTheory nodes (EArgument, EAttack and PSupport)
static Set<String>	NamedPEAFTheory.giveNames(Map<BArgument,String> names, Set<BArgument> args)	Helper function to give the names of a set of arguments Static such that it can work with PEAFTheory nodes (EArgument, EAttack and PSupport)
boolean	EvidentialArgumentationFramework.hasEvidentialSupport(BArgument argument, Collection<BArgument> ext)	returns true if argument has evidential support from set ext.
boolean	EvidentialArgumentationFramework.hasMinimalEvidentialSupport(BArgument argument, Collection<BArgument> ext)	returns true if argument has minimal evidential support from set ext.
abstract boolean	AbstractBipolarFramework.isAcceptable(BArgument argument, Collection<BArgument> ext)	checks whether argument is acceptable wrt.
boolean	DeductiveArgumentationFramework.isAcceptable(BArgument argument, Collection<BArgument> ext)
boolean	EAFTheory.isAcceptable(BArgument argument, Collection<BArgument> ext)
boolean	EvidentialArgumentationFramework.isAcceptable(BArgument argument, Collection<BArgument> ext)	return true if argument is acceptable with respect to ext argument is acceptable wrt.
boolean	NecessityArgumentationFramework.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
boolean	PEAFTheory.isAcceptable(BArgument argument, Collection<BArgument> ext)
boolean	DeductiveArgumentationFramework.isAttacked(BArgument argument, Set<BArgument> argumentSet)	returns true if some argument of argumentSet attacks argument.
boolean	NecessityArgumentationFramework.isAttackedBy(Collection<BArgument> argumentSet1, Collection<BArgument> argumentSet2)	checks whether some argument in argumentSet1 is attacked by any argument in argumentSet2
boolean	NecessityArgumentationFramework.isAttackedBy(BArgument argument, Collection<BArgument> argumentSet)	checks whether argument is attacked by any argument in argumentSet
boolean	DeductiveArgumentationFramework.isAttacking(Set<BArgument> argumentSet1, Set<BArgument> argumentSet2)	Checks whether argumentSet1 is attacking argumentSet2 ie any element of argumentSet1 is attacking any element of argumentSet2
boolean	DeductiveArgumentationFramework.isAttacking(BArgument argument, Set<BArgument> argSet)	returns true if some argument of argSet is attacked by argument.
boolean	NecessityArgumentationFramework.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
boolean	NecessityArgumentationFramework.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
boolean	NecessityArgumentationFramework.isConflictFree(Collection<BArgument> argumentSet)	checks whether the given set is conflict-free wrt.
boolean	EvidentialArgumentationFramework.isEvidenceSupportedAttack(Collection<BArgument> ext, BArgument argument)	returns true if ext carries out an evidence supported attack on argument ext e-support-attacks an argument a iff a subset S of ext attacks a and all elements of S have e-support from ext.
boolean	EvidentialArgumentationFramework.isMinimalEvidenceSupportedAttack(Collection<BArgument> ext, BArgument argument)	returns true if ext carries out a minimal evidence supported attack on argument i.e.
boolean	NecessityArgumentationFramework.isNCycleFree(Collection<BArgument> argumentSet)	checks if a set of arguments S is N-Cycle-Free in this argumentation framework ie.
boolean	NecessityArgumentationFramework.isNCycleFreeIn(BArgument argument, Collection<BArgument> argumentSet)	checks if argument is N-Cycle-Free in the set of arguments
boolean	NecessityArgumentationFramework.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

Constructors in org.tweetyproject.arg.bipolar.syntax with parameters of type BArgument

Modifier	Constructor	Description
	ArgumentSet(BArgument argument)	Constructs an ArgumentSet with a single argument.
	BinaryAttack(BArgument attacker, BArgument attacked)	Default constructor; initializes the two arguments used in this attack relation
	BinarySupport(BArgument supporter, BArgument supported)	Default constructor; initializes the two arguments used in this support relation
	SetAttack(Collection<BArgument> supporter, BArgument supported)	initializes the arguments used in this attack relation
	SetAttack(ArgumentSet supporter, BArgument supported)	Default constructor; initializes the arguments used in this attack relation
	SetAttack(BArgument supporter, BArgument supported)	initializes the arguments used in this attack relation
	SetSupport(BArgument supporter, BArgument supported)	initializes the arguments used in this support relation

Constructor parameters in org.tweetyproject.arg.bipolar.syntax with type arguments of type BArgument

Modifier	Constructor	Description
	ArgumentSet(Collection<? extends BArgument> arguments)	Constructs an ArgumentSet initialized with a collection of arguments.
	EAFTheory(Set<BArgument> noArguments)	Optional constructor; initializes an EAFTheory with arguments
	EAttack(Set<BArgument> froms, Set<BArgument> tos)	The default constructor that creates EAttack object
	InducibleEAF(Set<BArgument> arguments, Set<Support> supports, Set<EAttack> attacks, Set<BArgument> newArguments, double pInside, double inducePro)	Constructor
	PEAFTheory(Set<BArgument> noArguments)	Optional constructor; initializes an PEAFTheory with arguments
	SetAttack(Collection<BArgument> supporter, BArgument supported)	initializes the arguments used in this attack relation
	SetSupport(Collection<BArgument> supporter, Collection<BArgument> supported)	initializes the arguments used in this support relation