Uses of Class
org.tweetyproject.arg.dung.syntax.Argument

Packages that use Argument

Package	Description
org.tweetyproject.agents.dialogues
org.tweetyproject.agents.dialogues.oppmodels
org.tweetyproject.arg.aba.semantics
org.tweetyproject.arg.aba.syntax
org.tweetyproject.arg.aspic.syntax
org.tweetyproject.arg.bipolar.syntax
org.tweetyproject.arg.deductive.syntax
org.tweetyproject.arg.dung.independence
org.tweetyproject.arg.dung.ldo.syntax
org.tweetyproject.arg.dung.learning
org.tweetyproject.arg.dung.parser
org.tweetyproject.arg.dung.principles
org.tweetyproject.arg.dung.reasoner
org.tweetyproject.arg.dung.semantics
org.tweetyproject.arg.dung.syntax
org.tweetyproject.arg.dung.util
org.tweetyproject.arg.dung.writer
org.tweetyproject.arg.prob.lotteries
org.tweetyproject.arg.prob.reasoner
org.tweetyproject.arg.prob.semantics
org.tweetyproject.arg.prob.syntax
org.tweetyproject.arg.rankings.postulates
org.tweetyproject.arg.rankings.reasoner
org.tweetyproject.arg.rankings.semantics
org.tweetyproject.arg.rankings.util
org.tweetyproject.arg.saf.syntax
org.tweetyproject.arg.setaf.reasoners
org.tweetyproject.arg.setaf.syntax
org.tweetyproject.arg.social.reasoner
org.tweetyproject.arg.social.semantics
org.tweetyproject.arg.social.syntax

Uses of Argument in org.tweetyproject.agents.dialogues

Methods in org.tweetyproject.agents.dialogues that return types with arguments of type Argument

Modifier and Type	Method	Description
DialogueTrace<Argument,Extension>	ArgumentationEnvironment.getDialogueTrace()	Returns the current dialogue trace.

Constructor parameters in org.tweetyproject.agents.dialogues with type arguments of type Argument

Modifier	Constructor	Description
	ExecutableExtension(Collection<? extends Argument> arguments)	Creates a new extension for the given arguments.

Uses of Argument in org.tweetyproject.agents.dialogues.oppmodels

Methods in org.tweetyproject.agents.dialogues.oppmodels that return Argument

Modifier and Type	Method	Description
Argument	RecognitionFunction.getPreimage(Argument a)	Returns the argument which maps to the set containing the given argument.

Methods in org.tweetyproject.agents.dialogues.oppmodels with parameters of type Argument

Modifier and Type	Method	Description
Argument	RecognitionFunction.getPreimage(Argument a)	Returns the argument which maps to the set containing the given argument.

Method parameters in org.tweetyproject.agents.dialogues.oppmodels with type arguments of type Argument

Modifier and Type	Method	Description
Pair<Double,Set<ExecutableExtension>>	T1BeliefState.doMove(ArgumentationEnvironment env, DialogueTrace<Argument,Extension> trace)
double	GroundedGameUtilityFunction.getUtility(DialogueTrace<Argument,Extension> trace)
double	GroundedGameUtilityFunction.getUtility(DialogueTrace<Argument,Extension> trace, Set<Argument> additionalArguments, Set<Attack> additionalAttacks)
double	GroundedGameUtilityFunction.getUtility(DialogueTrace<Argument,Extension> trace, Set<Argument> additionalArguments, Set<Attack> additionalAttacks)
abstract void	BeliefState.update(DialogueTrace<Argument,Extension> trace)	Updates the current belief state accordingly to the given dialogue trace.
void	T1BeliefState.update(DialogueTrace<Argument,Extension> trace)
void	T2BeliefState.update(DialogueTrace<Argument,Extension> trace)
void	T3BeliefState.update(DialogueTrace<Argument,Extension> trace)

Constructors in org.tweetyproject.agents.dialogues.oppmodels with parameters of type Argument

Modifier	Constructor	Description
	GroundedGameUtilityFunction(DungTheory theory, Argument argument, GroundedGameSystem.AgentFaction faction)	Construct utility function.

Constructor parameters in org.tweetyproject.agents.dialogues.oppmodels with type arguments of type Argument

Modifier	Constructor	Description
	BeliefState(Extension knownArguments, UtilityFunction<Argument,Extension> utilityFunction)	Creates a new belief-state with the given parameters.
	T1BeliefState(Extension knownArguments, UtilityFunction<Argument,Extension> utilityFunction)	Creates a new T1-belief-state with the given parameters and without nesting.
	T1BeliefState(Extension knownArguments, UtilityFunction<Argument,Extension> utilityFunction, T1BeliefState oppModel)	Creates a new T1-belief-state with the given parameters.
	T2BeliefState(Extension knownArguments, UtilityFunction<Argument,Extension> utilityFunction)	Creates a new T2-belief-state with the given parameters and without nesting.
	T2BeliefState(Extension knownArguments, UtilityFunction<Argument,Extension> utilityFunction, ProbabilityFunction<T2BeliefState> prob)	Creates a new T2-belief-state with the given parameters.
	T3BeliefState(Extension knownArguments, UtilityFunction<Argument,Extension> utilityFunction, Set<Argument> virtualArguments, Set<Attack> virtualAttacks, RecognitionFunction rec, ProbabilityFunction<T3BeliefState> prob)	Creates a new T3-belief-state with the given parameters.
	T3BeliefState(Extension knownArguments, UtilityFunction<Argument,Extension> utilityFunction, Set<Argument> virtualArguments, Set<Attack> virtualAttacks, RecognitionFunction rec, ProbabilityFunction<T3BeliefState> prob)	Creates a new T3-belief-state with the given parameters.

Uses of Argument in org.tweetyproject.arg.aba.semantics

Constructors in org.tweetyproject.arg.aba.semantics with parameters of type Argument

Modifier	Constructor	Description
	AbaAttack(Argument attacker, Argument attacked)	Creates a new ABA attack

Uses of Argument in org.tweetyproject.arg.aba.syntax

Subclasses of Argument in org.tweetyproject.arg.aba.syntax

Modifier and Type	Class	Description
class	Deduction<T extends Formula>	An argument derived from an ABA theory.

Uses of Argument in org.tweetyproject.arg.aspic.syntax

Subclasses of Argument in org.tweetyproject.arg.aspic.syntax

Modifier and Type	Class	Description
class	AspicArgument<T extends Invertable>

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

Subclasses of Argument in org.tweetyproject.arg.bipolar.syntax

Modifier and Type	Class	Description
class	BArgument	This class models an argument used by bipolar abstract argumentation theories.

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

Modifier and Type	Method	Description
boolean	AbstractBipolarFramework.add(Argument argument)	Adds argument to this argumentation framework for better compatibility between dung theories and bipolar argumentation frameworks

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

Modifier	Constructor	Description
	BArgument(Argument arg)

Uses of Argument in org.tweetyproject.arg.deductive.syntax

Subclasses of Argument in org.tweetyproject.arg.deductive.syntax

Modifier and Type	Class	Description
class	SimplePlLogicArgument

Uses of Argument in org.tweetyproject.arg.dung.independence

Methods in org.tweetyproject.arg.dung.independence that return types with arguments of type Argument

Modifier and Type	Method	Description
static SimpleGraph<Argument>	Independence.computeDGraph(DungTheory theory)	transform the given AF into a DAG (D-graph) by adding new meta argument for each strongly connected component
static Collection<Collection<Argument>>	Independence.isIndependentGiven(DungTheory theory, Collection<Argument> argsA, Collection<Argument> argsB)	compute the smallest set of arguments which needs to be observed so that argsA and argsB are independent in the given AF argsA and argsB are disjoint
static Collection<Collection<Argument>>	Independence.isIndependentGiven(DungTheory theory, Collection<Argument> argsA, Collection<Argument> argsB, boolean pruneOutAttacks)	compute the smallest set of arguments which needs to be observed so that argsA and argsB are independent in the given AF argsA and argsB are disjoint
static SimpleGraph<Argument>	Independence.pruneDGraph(SimpleGraph<Argument> dGraph, Collection<Argument> argsA, Collection<Argument> argsB, Collection<Argument> argsC)	prune the given DAG by removing all leaf nodes, which are not in any of the given sets and removing all outgoing edges from nodes in argsC

Method parameters in org.tweetyproject.arg.dung.independence with type arguments of type Argument

Modifier and Type	Method	Description
static boolean	Independence.isIndependent(DungTheory theory, Collection<Argument> argsA, Collection<Argument> argsB, Collection<Argument> argsC)	compute whether args and argsB are independent given argsC in the given AF argsA, argsB and argsC are disjoint
static boolean	Independence.isIndependent(DungTheory theory, Collection<Argument> argsA, Collection<Argument> argsB, Collection<Argument> argsC, boolean pruneOutAttacks)	compute whether args and argsB are independent given argsC in the given AF argsA, argsB and argsC are disjoint
static Collection<Collection<Argument>>	Independence.isIndependentGiven(DungTheory theory, Collection<Argument> argsA, Collection<Argument> argsB)	compute the smallest set of arguments which needs to be observed so that argsA and argsB are independent in the given AF argsA and argsB are disjoint
static Collection<Collection<Argument>>	Independence.isIndependentGiven(DungTheory theory, Collection<Argument> argsA, Collection<Argument> argsB, boolean pruneOutAttacks)	compute the smallest set of arguments which needs to be observed so that argsA and argsB are independent in the given AF argsA and argsB are disjoint
static SimpleGraph<Argument>	Independence.pruneDGraph(SimpleGraph<Argument> dGraph, Collection<Argument> argsA, Collection<Argument> argsB, Collection<Argument> argsC)	prune the given DAG by removing all leaf nodes, which are not in any of the given sets and removing all outgoing edges from nodes in argsC
static SimpleGraph<Argument>	Independence.pruneDGraph(SimpleGraph<Argument> dGraph, Collection<Argument> argsA, Collection<Argument> argsB, Collection<Argument> argsC)	prune the given DAG by removing all leaf nodes, which are not in any of the given sets and removing all outgoing edges from nodes in argsC

Uses of Argument in org.tweetyproject.arg.dung.ldo.syntax

Methods in org.tweetyproject.arg.dung.ldo.syntax that return Argument

Modifier and Type	Method	Description
Argument	LdoArgument.getArgument()	Returns an argument representation (in Dung-style) of this LdoArgument.

Uses of Argument in org.tweetyproject.arg.dung.learning

Constructor parameters in org.tweetyproject.arg.dung.learning with type arguments of type Argument

Modifier	Constructor	Description
	ImprovedRiveretTheoryLearner(Collection<Argument> arguments, int max_cycles)	initialize learner for the given set of arguments
	NiskanenTheorySynthesizer(Collection<Argument> args, Semantics semantics, String solverLocation)
	RiveretTheoryLearner(Collection<Argument> arguments, int max_cycles)	initialize learner for the given set of arguments
	TheoryLearner(Collection<Argument> args, Semantics semantics, String solverLocation)

Uses of Argument in org.tweetyproject.arg.dung.parser

Methods in org.tweetyproject.arg.dung.parser that return types with arguments of type Argument

Modifier and Type	Method	Description
static Collection<Collection<Argument>>	AbstractDungParser.parseExtensionList(String s)	Returns a collection view of the given set of extensions (=sets of arguments)

Uses of Argument in org.tweetyproject.arg.dung.principles

Method parameters in org.tweetyproject.arg.dung.principles with type arguments of type Argument

Modifier and Type	Method	Description
boolean	AdmissibilityPrinciple.isApplicable(Collection<Argument> kb)
boolean	CFReinstatementPrinciple.isApplicable(Collection<Argument> kb)
boolean	ConflictFreePrinciple.isApplicable(Collection<Argument> kb)
boolean	DirectionalityPrinciple.isApplicable(Collection<Argument> kb)
boolean	IMaximalityPrinciple.isApplicable(Collection<Argument> kb)
boolean	INRAPrinciple.isApplicable(Collection<Argument> kb)
boolean	ModularizationPrinciple.isApplicable(Collection<Argument> kb)
boolean	NaivetyPrinciple.isApplicable(Collection<Argument> kb)
abstract boolean	Principle.isApplicable(Collection<Argument> kb)
boolean	ReductAdmissibilityPrinciple.isApplicable(Collection<Argument> kb)
boolean	ReinstatementPrinciple.isApplicable(Collection<Argument> kb)
boolean	SccDecomposabilityPrinciple.isApplicable(Collection<Argument> kb)
boolean	SCOOCPrinciple.isApplicable(Collection<Argument> kb)
boolean	SemiQualifiedAdmissibilityPrinciple.isApplicable(Collection<Argument> kb)
boolean	StrongAdmissibilityPrinciple.isApplicable(Collection<Argument> kb)
boolean	WeakReinstatementPrinciple.isApplicable(Collection<Argument> kb)
boolean	AdmissibilityPrinciple.isSatisfied(Collection<Argument> kb, AbstractExtensionReasoner ev)
boolean	CFReinstatementPrinciple.isSatisfied(Collection<Argument> kb, AbstractExtensionReasoner ev)
boolean	ConflictFreePrinciple.isSatisfied(Collection<Argument> kb, AbstractExtensionReasoner ev)
boolean	DirectionalityPrinciple.isSatisfied(Collection<Argument> kb, AbstractExtensionReasoner ev)
boolean	IMaximalityPrinciple.isSatisfied(Collection<Argument> kb, AbstractExtensionReasoner ev)
boolean	INRAPrinciple.isSatisfied(Collection<Argument> kb, AbstractExtensionReasoner ev)
boolean	ModularizationPrinciple.isSatisfied(Collection<Argument> kb, AbstractExtensionReasoner ev)
boolean	NaivetyPrinciple.isSatisfied(Collection<Argument> kb, AbstractExtensionReasoner ev)
abstract boolean	Principle.isSatisfied(Collection<Argument> kb, AbstractExtensionReasoner ev)
boolean	Principle.isSatisfied(Collection<Argument> kb, PostulateEvaluatable<Argument> ev)
boolean	Principle.isSatisfied(Collection<Argument> kb, PostulateEvaluatable<Argument> ev)
boolean	ReductAdmissibilityPrinciple.isSatisfied(Collection<Argument> kb, AbstractExtensionReasoner ev)
boolean	ReinstatementPrinciple.isSatisfied(Collection<Argument> kb, AbstractExtensionReasoner ev)
boolean	SccDecomposabilityPrinciple.isSatisfied(Collection<Argument> kb, AbstractExtensionReasoner ev)
boolean	SCOOCPrinciple.isSatisfied(Collection<Argument> kb, AbstractExtensionReasoner ev)
boolean	SemiQualifiedAdmissibilityPrinciple.isSatisfied(Collection<Argument> kb, AbstractExtensionReasoner ev)
boolean	StrongAdmissibilityPrinciple.isSatisfied(Collection<Argument> kb, AbstractExtensionReasoner ev)
boolean	WeakReinstatementPrinciple.isSatisfied(Collection<Argument> kb, AbstractExtensionReasoner ev)

Uses of Argument in org.tweetyproject.arg.dung.reasoner

Methods in org.tweetyproject.arg.dung.reasoner that return types with arguments of type Argument

Modifier and Type	Method	Description
abstract Collection<Argument>	AbstractAcceptabilityReasoner.getAcceptableArguments(DungTheory aaf)	Returns the set of acceptable arguments of this reasoner.
Collection<Argument>	EeeAcceptabilityReasoner.getAcceptableArguments(DungTheory aaf)
Collection<Argument>	IaqAcceptabilityReasoner.getAcceptableArguments(DungTheory aaf)
Collection<Argument>	SeeAcceptabilityReasoner.getAcceptableArguments(DungTheory aaf)
Collection<Argument>	SeemAcceptabilityReasoner.getAcceptableArguments(DungTheory aaf)
Set<Set<Argument>>	WeaklyAdmissibleReasoner.getAttackingCandidates(DungTheory bbase, Collection<Argument> ext)	computes all conflict-free sets, which attack any argument in ext
Set<Argument>	WeaklyAdmissibleReasoner.getComponent(DungTheory bbase, Argument argument)	finds the set of arguments S = {a | there exists an edge between a and argument}
Set<Set<Argument>>	WeaklyAdmissibleReasoner.getConflictFreeCandidateSets(DungTheory bbase, Collection<Argument> candidates)	computes all conflict-free sets of bbase, that contain only arguments in candidates and all arguments are relevant an argument is considered relevant iff it attacks any argument in the same component as the given argument A
Set<Set<Argument>>	WeaklyAdmissibleReasoner.getConflictFreeSets(DungTheory bbase, Collection<Argument> candidates)	computes all conflict-free sets of bbase, that contain only arguments in candidates
Collection<Argument>	OrderingSemanticsReasoner.getConflicts(Extension ext, DungTheory theory)	computes the set of conflicts occurring inside ext
Collection<Argument>	OrderingSemanticsReasoner.getDefendedNotIn(Extension ext, DungTheory theory)	computes the set of arguments outside of ext, which are defended by ext
Collection<Argument>	OrderingSemanticsReasoner.getEmpty(Extension ext, DungTheory theory)	dummy method used if only one ordering semantics is specified
List<Collection<Collection<Argument>>>	OrderingSemanticsReasoner.getModels(DungTheory theory)	compute the ordering over all subsets of theory wrt.
Collection<Argument>	SolidAdmissibleReasoner.getSolidlyDefended(Extension ext, DungTheory theory)
Collection<Argument>	OrderingSemanticsReasoner.getUnattacked(Extension ext, DungTheory theory)	computes the set of arguments outside of ext, which are not attacked by ext
Collection<Argument>	OrderingSemanticsReasoner.getUndefended(Extension ext, DungTheory theory)	computes the set of arguments in ext, which are not defended by ext against outside attackers

Methods in org.tweetyproject.arg.dung.reasoner with parameters of type Argument

Modifier and Type	Method	Description
Set<Argument>	WeaklyAdmissibleReasoner.getComponent(DungTheory bbase, Argument argument)	finds the set of arguments S = {a | there exists an edge between a and argument}
boolean	SolidAdmissibleReasoner.isSolidlyDefendedBy(Argument arg, Extension ext, DungTheory theory)
Boolean	AbstractAcceptabilityReasoner.query(DungTheory beliefbase, Argument formula)
abstract Boolean	AbstractDungReasoner.query(DungTheory beliefbase, Argument formula)
Boolean	AbstractExtensionReasoner.query(DungTheory beliefbase, Argument formula)
Boolean	AbstractExtensionReasoner.query(DungTheory beliefbase, Argument formula, InferenceMode inferenceMode)	Queries the given AAF for the given argument using the given inference type.
Boolean	ProboReasoner.query(DungTheory beliefbase, Argument formula, InferenceMode inferenceMode)
Boolean	SatCompleteReasoner.query(DungTheory beliefbase, Argument formula, InferenceMode inferenceMode)
Boolean	StratifiedLabelingReasoner.query(DungTheory beliefbase, Argument formula)
Boolean	StratifiedLabelingReasoner.query(DungTheory beliefbase, Argument formula, InferenceMode inferenceMode)	Queries the given AAF for the given argument using the given inference type.

Method parameters in org.tweetyproject.arg.dung.reasoner with type arguments of type Argument

Modifier and Type	Method	Description
Set<Set<Argument>>	WeaklyAdmissibleReasoner.getAttackingCandidates(DungTheory bbase, Collection<Argument> ext)	computes all conflict-free sets, which attack any argument in ext
Set<Set<Argument>>	WeaklyAdmissibleReasoner.getConflictFreeCandidateSets(DungTheory bbase, Collection<Argument> candidates)	computes all conflict-free sets of bbase, that contain only arguments in candidates and all arguments are relevant an argument is considered relevant iff it attacks any argument in the same component as the given argument A
Set<Set<Argument>>	WeaklyAdmissibleReasoner.getConflictFreeSets(DungTheory bbase, Collection<Argument> candidates)	computes all conflict-free sets of bbase, that contain only arguments in candidates
Collection<Extension>	SimpleNaiveReasoner.getMaximalConflictFreeSets(DungTheory bbase, Collection<Argument> candidates)	computes all maximal conflict-free sets of bbase
boolean	WeaklyCompleteReasoner.isWeaklyDefendedBy(Collection<Argument> X, Collection<Argument> E, DungTheory theory)	Computes whether E w-defends X i.e.

Uses of Argument in org.tweetyproject.arg.dung.semantics

Methods in org.tweetyproject.arg.dung.semantics that return types with arguments of type Argument

Modifier and Type	Method	Description
Set<Map.Entry<Argument,ArgumentStatus>>	Labeling.entrySet()
Set<Map.Entry<Argument,Integer>>	StratifiedLabeling.entrySet()
Iterator<Argument>	Extension.iterator()
Set<Argument>	Labeling.keySet()
Set<Argument>	StratifiedLabeling.keySet()

Methods in org.tweetyproject.arg.dung.semantics with parameters of type Argument

Modifier and Type	Method	Description
boolean	Extension.add(Argument arg0)
ArgumentStatus	Labeling.put(Argument arg0, ArgumentStatus arg1)
Integer	StratifiedLabeling.put(Argument arg0, Integer arg1)
boolean	AbstractArgumentationInterpretation.satisfies(Argument formula)
boolean	StratifiedLabeling.satisfies(Argument formula)

Method parameters in org.tweetyproject.arg.dung.semantics with type arguments of type Argument

Modifier and Type	Method	Description
boolean	Extension.addAll(Collection<? extends Argument> arg0)
void	Labeling.putAll(Map<? extends Argument,? extends ArgumentStatus> arg0)
void	StratifiedLabeling.putAll(Map<? extends Argument,? extends Integer> arg0)

Constructor parameters in org.tweetyproject.arg.dung.semantics with type arguments of type Argument

Modifier	Constructor	Description
	Extension(Collection<? extends Argument> arguments)	Creates a new extension with the given set of arguments.

Uses of Argument in org.tweetyproject.arg.dung.syntax

Methods in org.tweetyproject.arg.dung.syntax that return Argument

Modifier and Type	Method	Description
Argument	Attack.getAttacked()	returns the attacked argument of this attack relation.
Argument	Attack.getAttacker()	returns the attacking argument of this attack relation.

Methods in org.tweetyproject.arg.dung.syntax that return types with arguments of type Argument

Modifier and Type	Method	Description
Set<Argument>	DungTheory.getAttacked(Argument argument)	Computes the set {A | (argument,A) in attacks}.
Set<Argument>	DungTheory.getAttackers(Argument argument)	Computes the set {A | (A,argument) in attacks}.
Collection<Argument>	DungTheory.getChildren(Node node)
Collection<Graph<Argument>>	DungTheory.getComponents()
Edge<Argument>	DungTheory.getEdge(Argument a, Argument b)
Collection<? extends Edge<? extends Argument>>	DungTheory.getEdges()
Collection<Graph<Argument>>	DungTheory.getInducedSubgraphs()
Collection<Argument>	DungTheory.getNeighbors(Argument node)
Collection<Argument>	ArgumentationFramework.getNodes()
Collection<Argument>	DungTheory.getNodes()
Collection<Argument>	DungTheory.getParents(Node node)
Graph<Argument>	DungTheory.getRestriction(Collection<Argument> arguments)
Collection<Collection<Argument>>	DungTheory.getStronglyConnectedComponents()
Collection<Graph<Argument>>	DungTheory.getSubgraphs()

Methods in org.tweetyproject.arg.dung.syntax with parameters of type Argument

Modifier and Type	Method	Description
boolean	DungTheory.add(Argument argument)
boolean	DungTheory.addAttack(Argument attacker, Argument attacked)	Adds an attack from the first argument to the second to thisDdung theory.
boolean	WeightedDungTheory.addAttack(Argument attacker, Argument attacked)	add attack between both arguments to the theory and set weight to 1
boolean	WeightedDungTheory.addAttack(Argument attacker, Argument attacked, double weight)	add attack between both arguments to the theory and set weight to given value
boolean	DungTheory.areAdjacent(Argument a, Argument b)
boolean	Attack.contains(Argument argument)	Return true if the given argument is in this attack relation.
boolean	DungTheory.existsDirectedPath(Argument node1, Argument node2)
Set<Argument>	DungTheory.getAttacked(Argument argument)	Computes the set {A | (argument,A) in attacks}.
Set<Argument>	DungTheory.getAttackers(Argument argument)	Computes the set {A | (A,argument) in attacks}.
Edge<Argument>	DungTheory.getEdge(Argument a, Argument b)
Collection<Argument>	DungTheory.getNeighbors(Argument node)
Double	WeightedDungTheory.getWeight(Argument attacker, Argument attacked)	return weight of the attack between the given arguments
boolean	DungTheory.hasAttackBranch(Argument a)	If this graph is acyclic, this method checks if the given argument has an attack branch, i.e.
boolean	DungTheory.hasDefenseBranch(Argument a)	If this graph is acyclic, this method checks if the given argument has a defense branch, i.e.
boolean	DungTheory.isAcceptable(Argument argument, Extension ext)	returns true if every attacker on argument is attacked by some accepted argument wrt.
boolean	DungTheory.isAttackBranch(Argument a, Argument b)	Checks whether the path from b to a is an attack branch, i.e.
boolean	ArgumentationFramework.isAttacked(Argument a, Extension ext)
boolean	DungTheory.isAttacked(Argument argument, Extension ext)	returns true if some argument of ext attacks argument.
boolean	DungTheory.isAttackedBy(Argument argument, Collection<Argument> ext)	returns true if some argument of ext is attacked by argument.
boolean	DungTheory.isAttackedBy(Argument arg1, Argument arg2)	Checks whether arg1 is attacked by arg2.
boolean	DungTheory.isDefenseBranch(Argument a, Argument b)	Checks whether the path from b to a is a defense branch, i.e.
boolean	DungTheory.isIndirectAttack(Argument arg1, Argument arg2)	Checks whether "arg1" indirectly attacks "arg2", i.e.
boolean	DungTheory.isSupport(Argument arg1, Argument arg2)	Checks whether "arg1" supports "arg2", i.e.
boolean	DungTheory.remove(Argument a)	Removes the argument and all its attacks

Method parameters in org.tweetyproject.arg.dung.syntax with type arguments of type Argument

Modifier and Type	Method	Description
boolean	DungTheory.add(GeneralEdge<Argument> edge)
Graph<Argument>	DungTheory.getRestriction(Collection<Argument> arguments)
boolean	DungTheory.isAttackedBy(Argument argument, Collection<Argument> ext)	returns true if some argument of ext is attacked by argument.
boolean	Attack.isConflictFree(Collection<? extends Argument> arguments)	returns true if one arguments in arguments attacks another within this attack relation.

Constructors in org.tweetyproject.arg.dung.syntax with parameters of type Argument

Modifier	Constructor	Description
	Attack(Argument attacker, Argument attacked)	Default constructor; initializes the two arguments used in this attack relation
	DungSignature(Argument argument)	Creates a new signature with the single given argument.

Constructor parameters in org.tweetyproject.arg.dung.syntax with type arguments of type Argument

Modifier	Constructor	Description
	DungSignature(Collection<? extends Argument> arguments)	Creates a new signature with the given set of arguments.
	DungTheory(Graph<Argument> graph)	Creates a new theory from the given graph.

Uses of Argument in org.tweetyproject.arg.dung.util

Methods in org.tweetyproject.arg.dung.util with parameters of type Argument

Modifier and Type	Method	Description
DungTheory	DefaultDungTheoryGenerator.next(Argument arg)
DungTheory	DungTheoryGenerator.next(Argument arg)	Generates a new Dung theory where the given argument is enforced to be in the grounded extension
DungTheory	EnumeratingDungTheoryGenerator.next(Argument arg)
DungTheory	FileDungTheoryGenerator.next(Argument arg)
DungTheory	IsoSafeEnumeratingDungTheoryGenerator.next(Argument arg)
DungTheory	PodlaszewskiCaminadaDungTheoryGenerator.next(Argument arg)

Uses of Argument in org.tweetyproject.arg.dung.writer

Method parameters in org.tweetyproject.arg.dung.writer with type arguments of type Argument

Modifier and Type	Method	Description
static String	AbstractDungWriter.writeArguments(Collection<Argument> args)	Writes the given collection of arguments into a string of the form [arg1,...,argn].

Uses of Argument in org.tweetyproject.arg.prob.lotteries

Methods in org.tweetyproject.arg.prob.lotteries with parameters of type Argument

Modifier and Type	Method	Description
Probability	SubgraphProbabilityFunction.getAcceptanceProbability(Argument arg, Semantics semantics)	Returns the probability of the given argument being acceptable wrt.
Probability	SubgraphProbabilityFunction.getEpistemicProbability(Argument arg)	Returns the epistemic probability of the given argument, i.e.

Uses of Argument in org.tweetyproject.arg.prob.reasoner

Methods in org.tweetyproject.arg.prob.reasoner with parameters of type Argument

Modifier and Type	Method	Description
Double	AbstractPafReasoner.query(ProbabilisticArgumentationFramework beliefbase, Argument formula)
abstract Double	AbstractPafReasoner.query(ProbabilisticArgumentationFramework beliefbase, Argument formula, InferenceMode inferenceMode)	Queries the given PAF for the given argument using the given inference type.
Double	MonteCarloPafReasoner.query(ProbabilisticArgumentationFramework beliefbase, Argument formula, InferenceMode inferenceMode)
Double	SimplePafReasoner.query(ProbabilisticArgumentationFramework beliefbase, Argument formula, InferenceMode inferenceMode)

Uses of Argument in org.tweetyproject.arg.prob.semantics

Methods in org.tweetyproject.arg.prob.semantics with parameters of type Argument

Modifier and Type	Method	Description
Probability	ProbabilisticExtension.probability(Argument a)	Computes the probability of the given argument.

Method parameters in org.tweetyproject.arg.prob.semantics with type arguments of type Argument

Modifier and Type	Method	Description
abstract Collection<Statement>	AbstractPASemantics.getSatisfactionStatements(DungTheory theory, Map<Collection<Argument>,FloatVariable> worlds2vars)
Collection<Statement>	CoherentPASemantics.getSatisfactionStatements(DungTheory theory, Map<Collection<Argument>,FloatVariable> worlds2vars)
Collection<Statement>	FoundedPASemantics.getSatisfactionStatements(DungTheory theory, Map<Collection<Argument>,FloatVariable> worlds2vars)
Collection<Statement>	InvolutaryPASemantics.getSatisfactionStatements(DungTheory theory, Map<Collection<Argument>,FloatVariable> worlds2vars)
Collection<Statement>	JustifiablePASemantics.getSatisfactionStatements(DungTheory theory, Map<Collection<Argument>,FloatVariable> worlds2vars)
Collection<Statement>	NeutralPASemantics.getSatisfactionStatements(DungTheory theory, Map<Collection<Argument>,FloatVariable> worlds2vars)
Collection<Statement>	OptimisticPASemantics.getSatisfactionStatements(DungTheory theory, Map<Collection<Argument>,FloatVariable> worlds2vars)
Collection<Statement>	PASemantics.getSatisfactionStatements(DungTheory theory, Map<Collection<Argument>,FloatVariable> worlds2vars)	Returns the mathematical statement corresponding to the satisfaction of the given theory wrt.
Collection<Statement>	RationalPASemantics.getSatisfactionStatements(DungTheory theory, Map<Collection<Argument>,FloatVariable> worlds2vars)
Collection<Statement>	SemiFoundedPASemantics.getSatisfactionStatements(DungTheory theory, Map<Collection<Argument>,FloatVariable> worlds2vars)
Collection<Statement>	SemiOptimisticPASemantics.getSatisfactionStatements(DungTheory theory, Map<Collection<Argument>,FloatVariable> worlds2vars)

Uses of Argument in org.tweetyproject.arg.prob.syntax

Methods in org.tweetyproject.arg.prob.syntax with parameters of type Argument

Modifier and Type	Method	Description
boolean	ProbabilisticArgumentationFramework.add(Argument a)
boolean	ProbabilisticArgumentationFramework.add(Argument a, Probability p)	Adds the given argument with the given probability
Probability	ProbabilisticArgumentationFramework.getProbability(Argument a)	Returns the probability of the given argument.
boolean	ProbabilisticArgumentationFramework.remove(Argument a)

Constructor parameters in org.tweetyproject.arg.prob.syntax with type arguments of type Argument

Modifier	Constructor	Description
	ProbabilisticArgumentationFramework(Graph<Argument> graph)	Creates a new PAF from the given graph, all arguments and attacks have probability 1.

Uses of Argument in org.tweetyproject.arg.rankings.postulates

Method parameters in org.tweetyproject.arg.rankings.postulates with type arguments of type Argument

Modifier and Type	Method	Description
boolean	RaAbstraction.isApplicable(Collection<Argument> kb)
boolean	RaAdditionOfAttackBranch.isApplicable(Collection<Argument> kb)
boolean	RaAdditionOfDefenseBranch.isApplicable(Collection<Argument> kb)
boolean	RaAttackVsFullDefense.isApplicable(Collection<Argument> kb)
boolean	RaCardinalityPrecedence.isApplicable(Collection<Argument> kb)
boolean	RaCounterTransitivity.isApplicable(Collection<Argument> kb)
boolean	RaDefensePrecedence.isApplicable(Collection<Argument> kb)
boolean	RaDistDefensePrecedence.isApplicable(Collection<Argument> kb)
boolean	RaIncreaseOfAttackBranch.isApplicable(Collection<Argument> kb)
boolean	RaIncreaseOfDefenseBranch.isApplicable(Collection<Argument> kb)
boolean	RaIndependence.isApplicable(Collection<Argument> kb)
abstract boolean	RankingPostulate.isApplicable(Collection<Argument> kb)
boolean	RaNonAttackedEquivalence.isApplicable(Collection<Argument> kb)
boolean	RaQualityPrecedence.isApplicable(Collection<Argument> kb)
boolean	RaSelfContradiction.isApplicable(Collection<Argument> kb)
boolean	RaStrictAdditionOfDefenseBranch.isApplicable(Collection<Argument> kb)
boolean	RaStrictCounterTransitivity.isApplicable(Collection<Argument> kb)
boolean	RaTotal.isApplicable(Collection<Argument> kb)
boolean	RaVoidPrecedence.isApplicable(Collection<Argument> kb)
boolean	RaAbstraction.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<ArgumentRanking> ev)
boolean	RaAdditionOfAttackBranch.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<ArgumentRanking> ev)
boolean	RaAdditionOfDefenseBranch.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<ArgumentRanking> ev)
boolean	RaAttackVsFullDefense.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<ArgumentRanking> ev)
boolean	RaCardinalityPrecedence.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<ArgumentRanking> ev)
boolean	RaCounterTransitivity.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<ArgumentRanking> ev)
boolean	RaDefensePrecedence.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<ArgumentRanking> ev)
boolean	RaDistDefensePrecedence.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<ArgumentRanking> ev)
boolean	RaIncreaseOfAttackBranch.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<ArgumentRanking> ev)
boolean	RaIncreaseOfDefenseBranch.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<ArgumentRanking> ev)
boolean	RaIndependence.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<ArgumentRanking> ev)
abstract boolean	RankingPostulate.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<ArgumentRanking> ev)
boolean	RankingPostulate.isSatisfied(Collection<Argument> kb, PostulateEvaluatable<Argument> ev)
boolean	RankingPostulate.isSatisfied(Collection<Argument> kb, PostulateEvaluatable<Argument> ev)
boolean	RaNonAttackedEquivalence.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<ArgumentRanking> ev)
boolean	RaQualityPrecedence.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<ArgumentRanking> ev)
boolean	RaSelfContradiction.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<ArgumentRanking> ev)
boolean	RaStrictAdditionOfDefenseBranch.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<ArgumentRanking> ev)
boolean	RaStrictCounterTransitivity.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<ArgumentRanking> ev)
boolean	RaTotal.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<ArgumentRanking> ev)
boolean	RaVoidPrecedence.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<ArgumentRanking> ev)

Uses of Argument in org.tweetyproject.arg.rankings.reasoner

Methods in org.tweetyproject.arg.rankings.reasoner that return types with arguments of type Argument

Modifier and Type	Method	Description
Map<Argument,Pair<int[],int[]>>	TuplesRankingReasoner.getTupledValues()
Collection<Argument>	IteratedGradedDefenseReasoner.gradedDefense(DungTheory theory, Collection<Argument> args, int m, int n)	Implements the graded defense function from Def.
Collection<Argument>	IteratedGradedDefenseReasoner.gradedNeutrality(DungTheory theory, Collection<Argument> args, int m)	Implements the graded neutrality function from Def.

Methods in org.tweetyproject.arg.rankings.reasoner with parameters of type Argument

Modifier and Type	Method	Description
double	StrategyBasedRankingReasoner.computeStrengthOfArgument(Argument a, DungTheory kb, Set<Set<Argument>> subsets)	Computes the value of the zero-sum game for the given argument.
Pair<int[],int[]>	TuplesRankingReasoner.computeTupledValue(Argument a, DungTheory kb)	Computes the tupled value for the given argument.
int	DiscussionBasedRankingReasoner.getNumberOfPathsOfLength(DungTheory base, Argument a, int i)	Returns the number of linear discussions of the given length in the given DungTheory for the given argument.

Method parameters in org.tweetyproject.arg.rankings.reasoner with type arguments of type Argument

Modifier and Type	Method	Description
double	StrategyBasedRankingReasoner.computeDegreeOfAcceptability(Collection<Argument> A, Collection<Argument> B, DungTheory kb)	Computes the degree of acceptability of the strategy A wrt.
double	StrategyBasedRankingReasoner.computeRewards(Collection<Argument> A, Collection<Argument> B, DungTheory kb)	Computes the rewards of the given strategy (set of arguments).
double	StrategyBasedRankingReasoner.computeStrengthOfArgument(Argument a, DungTheory kb, Set<Set<Argument>> subsets)	Computes the value of the zero-sum game for the given argument.
Collection<Argument>	IteratedGradedDefenseReasoner.gradedDefense(DungTheory theory, Collection<Argument> args, int m, int n)	Implements the graded defense function from Def.
Collection<Argument>	IteratedGradedDefenseReasoner.gradedNeutrality(DungTheory theory, Collection<Argument> args, int m)	Implements the graded neutrality function from Def.
boolean	IteratedGradedDefenseReasoner.isMConflictFree(DungTheory theory, Collection<Argument> args, int m)	Checks whether the given set of arguments is m-conflict-free, cf.
boolean	IteratedGradedDefenseReasoner.isMNAdmissible(DungTheory theory, Collection<Argument> args, int m, int n)	Checks whether the given set of arguments is mn-admissible, cf.
boolean	IteratedGradedDefenseReasoner.isMNComplete(DungTheory theory, Collection<Argument> args, int m, int n)	Checks whether the given set of arguments is mn-complete, cf.
boolean	IteratedGradedDefenseReasoner.isMNGrounded(DungTheory theory, Collection<Argument> args, int m, int n)	Checks whether the given set of arguments is mn-grounded, cf.
boolean	IteratedGradedDefenseReasoner.isMNPreferred(DungTheory theory, Collection<Argument> args, int m, int n)	Checks whether the given set of arguments is mn-preferred, cf.
boolean	IteratedGradedDefenseReasoner.isMStable(DungTheory theory, Collection<Argument> args, int m)	Checks whether the given set of arguments is m-stable, cf.

Uses of Argument in org.tweetyproject.arg.rankings.semantics

Methods in org.tweetyproject.arg.rankings.semantics that return types with arguments of type Argument

Modifier and Type	Method	Description
Set<Map.Entry<Argument,Double>>	NumericalArgumentRanking.entrySet()
Collection<Argument>	LatticeArgumentRanking.getArgs()
Collection<Argument>	ArgumentRanking.getMaximallyAcceptedArguments(Collection<Argument> args)	Returns the set of all arguments a from the given set that are maximally accepted, i.e.
Collection<Argument>	ArgumentRanking.getMinimallyAcceptedArguments(Collection<Argument> args)	Returns the set of all arguments a from the given set that are minimally accepted, i.e.
Order<Argument>	LatticeArgumentRanking.getOrder()
Set<Argument>	NumericalArgumentRanking.keySet()

Methods in org.tweetyproject.arg.rankings.semantics with parameters of type Argument

Modifier and Type	Method	Description
int	ArgumentRanking.compare(Argument arg0, Argument arg1)
boolean	ArgumentRanking.isEquallyAcceptableThan(Argument a, Argument b)	Returns "true" iff a is equally acceptable as b, i.e.
abstract boolean	ArgumentRanking.isIncomparable(Argument a, Argument b)	Returns "true" iff a and b are incomparable (i.e.
boolean	LatticeArgumentRanking.isIncomparable(Argument a, Argument b)
boolean	NumericalArgumentRanking.isIncomparable(Argument a, Argument b)
boolean	ArgumentRanking.isStrictlyLessAcceptableThan(Argument a, Argument b)	Returns "true" iff a is strictly less acceptable than b, i.e.
abstract boolean	ArgumentRanking.isStrictlyLessOrEquallyAcceptableThan(Argument a, Argument b)	Returns "true" iff a is strictly less acceptable than b or a is equally acceptable as b or a and b are not comparable, i.e.
boolean	LatticeArgumentRanking.isStrictlyLessOrEquallyAcceptableThan(Argument a, Argument b)
boolean	NumericalArgumentRanking.isStrictlyLessOrEquallyAcceptableThan(Argument a, Argument b)
boolean	ArgumentRanking.isStrictlyMoreAcceptableThan(Argument a, Argument b)	Returns "true" iff a is strictly more acceptable than b, i.e.
boolean	ArgumentRanking.isStrictlyMoreOrEquallyAcceptableThan(Argument a, Argument b)	Returns "true" iff a is strictly more acceptable than b or a is equally acceptable as b, i.e.
Double	NumericalArgumentRanking.put(Argument arg0, Double arg1)
void	LatticeArgumentRanking.setStrictlyLessOrEquallyAcceptableThan(Argument a, Argument b)	Defines argument "a" to be strictly less or equally acceptable than argument "b".

Method parameters in org.tweetyproject.arg.rankings.semantics with type arguments of type Argument

Modifier and Type	Method	Description
Collection<Argument>	ArgumentRanking.getMaximallyAcceptedArguments(Collection<Argument> args)	Returns the set of all arguments a from the given set that are maximally accepted, i.e.
Collection<Argument>	ArgumentRanking.getMinimallyAcceptedArguments(Collection<Argument> args)	Returns the set of all arguments a from the given set that are minimally accepted, i.e.
boolean	ArgumentRanking.isEquivalent(ArgumentRanking other, Collection<Argument> args)	Checks whether this ranking is equivalent to the other one wrt.
void	NumericalArgumentRanking.putAll(Map<? extends Argument,? extends Double> arg0)

Constructor parameters in org.tweetyproject.arg.rankings.semantics with type arguments of type Argument

Modifier	Constructor	Description
	LatticeArgumentRanking(Collection<Argument> args)	Creates a new argument ranking with the given arguments which are initially all incomparable.
	NumericalArgumentRanking(Collection<Argument> args, double initialvalue)	Creates a new argument ranking with the given set of arguments and the given initial ranking value.

Uses of Argument in org.tweetyproject.arg.rankings.util

Methods in org.tweetyproject.arg.rankings.util that return types with arguments of type Argument

Modifier and Type	Method	Description
static HashSet<ArrayList<Argument>>	RankingTools.getPathsOfHigherSize(HashSet<ArrayList<Argument>> oldPaths, DungTheory base)	Given a set of argument paths of length i-1, this method returns a set of argument paths of length i for the given DungTheory.

Method parameters in org.tweetyproject.arg.rankings.util with type arguments of type Argument

Modifier and Type	Method	Description
static HashSet<ArrayList<Argument>>	RankingTools.getPathsOfHigherSize(HashSet<ArrayList<Argument>> oldPaths, DungTheory base)	Given a set of argument paths of length i-1, this method returns a set of argument paths of length i for the given DungTheory.

Uses of Argument in org.tweetyproject.arg.saf.syntax

Subclasses of Argument in org.tweetyproject.arg.saf.syntax

Modifier and Type	Class	Description
class	ArgumentStructure	This class models an argument structure, i.e.
class	BasicArgument	This class models a basic argument in structured argumentation frameworks, i.e.

Methods in org.tweetyproject.arg.saf.syntax with parameters of type Argument

Modifier and Type	Method	Description
boolean	StructuredArgumentationFramework.isAttackedBy(Argument arg1, Argument arg2)

Uses of Argument in org.tweetyproject.arg.setaf.reasoners

Methods in org.tweetyproject.arg.setaf.reasoners with parameters of type Argument

Modifier and Type	Method	Description
Boolean	AbstractExtensionSetAfReasoner.query(SetAf beliefbase, Argument formula)
Boolean	AbstractExtensionSetAfReasoner.query(SetAf beliefbase, Argument formula, InferenceMode inferenceMode)	Queries the given AAF for the given argument using the given inference type.
abstract Boolean	AbstractSetAfReasoner.query(SetAf beliefbase, Argument formula)

Method parameters in org.tweetyproject.arg.setaf.reasoners with type arguments of type Argument

Modifier and Type	Method	Description
Collection<Extension>	SimpleNaiveSetAfReasoner.getMaximalConflictFreeSets(SetAf bbase, Collection<Argument> candidates)	computes all maximal conflict-free sets of bbase

Uses of Argument in org.tweetyproject.arg.setaf.syntax

Methods in org.tweetyproject.arg.setaf.syntax that return Argument

Modifier and Type	Method	Description
Argument	SetAttack.getAttacked()	returns the attacked argument of this attack relation.

Methods in org.tweetyproject.arg.setaf.syntax that return types with arguments of type Argument

Modifier and Type	Method	Description
Set<Argument>	SetAf.getAttacked(Argument node)	Computes the set {A | (argument,A) in attacks}.
Set<Set<Argument>>	SetAf.getAttackers(Argument node)	Computes the set {A | (A,argument) in attacks}.
Set<Argument>	SetAttack.getAttackers()	returns the attacking argument of this attack relation.
Collection<Argument>	SetAf.getChildren(Set<Argument> node)
Collection<Argument>	SetAf.getChildren(Node node)
Collection<Argument>	SetAf.getNeighbors(Argument node)
Collection<Argument>	SetAf.getNodes()
Collection<Set<Argument>>	SetAf.getParents(Argument node)
Collection<Argument>	SetAf.getParents(Node node)
Collection<DirHyperGraph<Argument>>	SetAf.getSubGraphs()
static Collection<DirHyperGraph<Argument>>	SetAf.getSubgraphsHelper(SetAf g)
Iterator<Argument>	SetAf.iterator()
Set<Set<Argument>>	SetAf.powerSet(Set<Argument> originalSet)

Methods in org.tweetyproject.arg.setaf.syntax with parameters of type Argument

Modifier and Type	Method	Description
boolean	SetAf.add(Argument arg)
boolean	SetAf.addAttack(HashSet<Argument> hashSet, Argument attacked)	Adds an attack from the first argument to the second to this SetAf theory.
boolean	SetAf.addAttack(Argument attacker, Argument attacked)	Adds an attack from the first argument to the second to this SetAf theory.
boolean	SetAf.areAdjacent(Argument a, Argument b)
boolean	SetAttack.contains(Argument argument)	Return true if the given argument is in this attack relation.
boolean	SetAf.existsDirectedPath(Argument node1, Argument node2)
static <S extends Node> boolean	SetAf.existsDirectedPath(SetAf hyperGraph, Argument node1, Argument node2)
Set<Argument>	SetAf.getAttacked(Argument node)	Computes the set {A | (argument,A) in attacks}.
Set<Set<Argument>>	SetAf.getAttackers(Argument node)	Computes the set {A | (A,argument) in attacks}.
SetAttack	SetAf.getEdge(Argument a, Argument b)
Collection<Argument>	SetAf.getNeighbors(Argument node)
Collection<Set<Argument>>	SetAf.getParents(Argument node)
boolean	SetAf.isAcceptable(Argument argument, Extension ext)	returns true if every attacker on argument is attacked by some accepted argument wrt.
boolean	SetAf.isAttacked(Argument a, Extension setAfExtension)	returns true if some argument of ext attacks argument.
boolean	SetAf.isAttackedBy(Argument arg2, Collection<Argument> ext)	returns true if some argument of ext is attacked by argument.
boolean	SetAf.isAttackedBy(Argument arg1, Argument arg2)	Checks whether arg1 is attacked by arg2.
boolean	SetAf.remove(Argument a)	Removes the argument and all its attacks

Method parameters in org.tweetyproject.arg.setaf.syntax with type arguments of type Argument

Modifier and Type	Method	Description
boolean	SetAf.addAttack(HashSet<Argument> hashSet, Argument attacked)	Adds an attack from the first argument to the second to this SetAf theory.
Collection<Argument>	SetAf.getChildren(Set<Argument> node)
SetAttack	SetAf.getDirEdge(Set<Argument> node1, Node b)
SetAf	SetAf.getRestriction(Collection<Argument> nodes)
boolean	SetAf.isAttackedBy(Argument arg2, Collection<Argument> ext)	returns true if some argument of ext is attacked by argument.
boolean	SetAf.isConflictFree(Collection<? extends Argument> arguments)	returns true if one arguments in arguments attacks another within this attack relation.
boolean	SetAttack.isConflictFree(Collection<? extends Argument> arguments)	returns true if one arguments in arguments attacks another within this attack relation.
Set<Set<Argument>>	SetAf.powerSet(Set<Argument> originalSet)

Constructors in org.tweetyproject.arg.setaf.syntax with parameters of type Argument

Modifier	Constructor	Description
	SetAfSignature(Argument argument)	Creates a new signature with the single given argument.
	SetAttack(Set<Argument> attackers, Argument attacked)	Default constructor; initializes the two arguments used in this attack relation
	SetAttack(Argument attacker, Argument attacked)	Default constructor; initializes the two arguments used in this attack relation

Constructor parameters in org.tweetyproject.arg.setaf.syntax with type arguments of type Argument

Modifier	Constructor	Description
	SetAfSignature(Collection<? extends Argument> arguments)	Creates a new signature with the given set of arguments.
	SetAttack(Set<Argument> attackers, Argument attacked)	Default constructor; initializes the two arguments used in this attack relation

Uses of Argument in org.tweetyproject.arg.social.reasoner

Methods in org.tweetyproject.arg.social.reasoner with parameters of type Argument

Modifier and Type	Method	Description
Double	IssReasoner.query(SocialAbstractArgumentationFramework beliefbase, Argument formula)

Uses of Argument in org.tweetyproject.arg.social.semantics

Methods in org.tweetyproject.arg.social.semantics with parameters of type Argument

Modifier and Type	Method	Description
boolean	SocialMapping.containsKey(Argument a)	Returns "true" iff the given argument has a value.
L	SocialMapping.get(Argument a)	Returns the social value of the given argument
L	SocialMapping.put(Argument a, L val)	Sets the social value of the given argument
boolean	SocialMapping.satisfies(Argument formula)

Uses of Argument in org.tweetyproject.arg.social.syntax

Methods in org.tweetyproject.arg.social.syntax with parameters of type Argument

Modifier and Type	Method	Description
boolean	SocialAbstractArgumentationFramework.add(Argument a)
int	SocialAbstractArgumentationFramework.getNegative(Argument arg)	Returns the number of negative votes of the given argument
int	SocialAbstractArgumentationFramework.getPositive(Argument arg)	Returns the number of positive votes of the given argument
boolean	SocialAbstractArgumentationFramework.remove(Argument a)
void	SocialAbstractArgumentationFramework.voteDown(Argument arg)	Adds a negative vote to the given argument.
void	SocialAbstractArgumentationFramework.voteDown(Argument arg, int number)	Adds the given number of negative votes to the given argument
void	SocialAbstractArgumentationFramework.voteUp(Argument arg)	Adds a positive vote to the given argument.
void	SocialAbstractArgumentationFramework.voteUp(Argument arg, int number)	Adds the given number of positive votes to the given argument

Constructor parameters in org.tweetyproject.arg.social.syntax with type arguments of type Argument

Modifier	Constructor	Description
	SocialAbstractArgumentationFramework(Graph<Argument> graph)	Creates a new social abstract argumentation framework from the given graph.