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.adf.syntax
org.tweetyproject.arg.aspic.syntax
org.tweetyproject.arg.bipolar.reasoner
org.tweetyproject.arg.bipolar.syntax
org.tweetyproject.arg.caf.reasoner
org.tweetyproject.arg.caf.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.learning.syntax
org.tweetyproject.arg.dung.parser
org.tweetyproject.arg.dung.principles
org.tweetyproject.arg.dung.reasoner
org.tweetyproject.arg.dung.semantics
org.tweetyproject.arg.dung.serialisability.semantics
org.tweetyproject.arg.dung.syntax
org.tweetyproject.arg.dung.util
org.tweetyproject.arg.dung.writer
org.tweetyproject.arg.eaf.reasoner
org.tweetyproject.arg.eaf.syntax
org.tweetyproject.arg.explanations.principles
org.tweetyproject.arg.explanations.reasoner.acceptance
org.tweetyproject.arg.explanations.semantics
org.tweetyproject.arg.extended.reasoner
org.tweetyproject.arg.extended.syntax
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.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
org.tweetyproject.arg.weighted.syntax
org.tweetyproject.causal.syntax
org.tweetyproject.web.services.bipolar
org.tweetyproject.web.services.dung
org.tweetyproject.web.services.iaf
org.tweetyproject.web.services.paf
org.tweetyproject.web.services.rankings
org.tweetyproject.web.services.sequenceexplanation
org.tweetyproject.web.util

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<DungTheory>>	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<DungTheory>> trace)
double	GroundedGameUtilityFunction.getUtility(DialogueTrace<Argument,Extension<DungTheory>> trace)
double	GroundedGameUtilityFunction.getUtility(DialogueTrace<Argument,Extension<DungTheory>> trace, Set<Argument> additionalArguments, Set<Attack> additionalAttacks)
double	GroundedGameUtilityFunction.getUtility(DialogueTrace<Argument,Extension<DungTheory>> trace, Set<Argument> additionalArguments, Set<Attack> additionalAttacks)
abstract void	BeliefState.update(DialogueTrace<Argument,Extension<DungTheory>> trace)	Updates the current belief state accordingly to the given dialogue trace.
void	T1BeliefState.update(DialogueTrace<Argument,Extension<DungTheory>> trace)
void	T2BeliefState.update(DialogueTrace<Argument,Extension<DungTheory>> trace)
void	T3BeliefState.update(DialogueTrace<Argument,Extension<DungTheory>> 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<DungTheory> knownArguments, UtilityFunction<Argument,Extension<DungTheory>> utilityFunction)	Creates a new belief-state with the given parameters.
	T1BeliefState(Extension<DungTheory> knownArguments, UtilityFunction<Argument,Extension<DungTheory>> utilityFunction)	Creates a new T1-belief-state with the given parameters and without nesting.
	T1BeliefState(Extension<DungTheory> knownArguments, UtilityFunction<Argument,Extension<DungTheory>> utilityFunction, T1BeliefState oppModel)	Creates a new T1-belief-state with the given parameters.
	T2BeliefState(Extension<DungTheory> knownArguments, UtilityFunction<Argument,Extension<DungTheory>> utilityFunction)	Creates a new T2-belief-state with the given parameters and without nesting.
	T2BeliefState(Extension<DungTheory> knownArguments, UtilityFunction<Argument,Extension<DungTheory>> utilityFunction, ProbabilityFunction<T2BeliefState> prob)	Creates a new T2-belief-state with the given parameters.
	T3BeliefState(Extension<DungTheory> knownArguments, UtilityFunction<Argument,Extension<DungTheory>> utilityFunction, Set<Argument> virtualArguments, Set<Attack> virtualAttacks, RecognitionFunction rec, ProbabilityFunction<T3BeliefState> prob)	Creates a new T3-belief-state with the given parameters.
	T3BeliefState(Extension<DungTheory> knownArguments, UtilityFunction<Argument,Extension<DungTheory>> 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.adf.syntax

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

Modifier and Type	Class	Description
final class	Argument	An immutable representation of an ADF argument

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>	An argument according to the ASPIC+ specification

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

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

Modifier and Type	Method	Description
Collection<Argument>	AbstractBipolarExtensionReasoner.queryAll(BipolarArgumentationFramework bbase, InferenceMode inferenceMode)	Determine the set of acceptable arguments wrt.

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

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

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

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

Modifier and Type	Class	Description
class	CoalitionArgument	A representation of a set of arguments (called coalition) that represent an argument in a meta-graph.

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

Modifier and Type	Method	Description
Argument	Support.getSupported()	returns the supported argument of this support relation.
Argument	Support.getSupporter()	returns the supporting argument of this support relation.

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

Modifier and Type	Method	Description
Collection<Argument>	CoalitionArgument.getArguments()	Returns the arguments associated with this entity
Collection<Collection<Argument>>	BipolarArgumentationFramework.getCoalitions()	Computes the set of all coalition of this BAF A coalition is a maximal conflict-free set of arguments that is connected via the support relation.
Collection<Argument>	BipolarArgumentationFramework.getSupported(Collection<Argument> ext)	Compute the set of arguments supported by ext
Collection<Argument>	BipolarArgumentationFramework.getSupported(Argument arg)	Compute the set of arguments supported by arg
Collection<Argument>	BipolarArgumentationFramework.getSupporters(Collection<Argument> ext)	Compute the set of arguments supporting by ext
Collection<Argument>	BipolarArgumentationFramework.getSupporters(Argument arg)	Compute the set of arguments supporting by arg

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

Modifier and Type	Method	Description
boolean	BipolarArgumentationFramework.addSupport(Argument supporter, Argument supported)	Adds a support from the first argument to the second to this bipolar argumentation framework.
Collection<Argument>	BipolarArgumentationFramework.getSupported(Argument arg)	Compute the set of arguments supported by arg
Collection<Argument>	BipolarArgumentationFramework.getSupporters(Argument arg)	Compute the set of arguments supporting by arg
boolean	BipolarArgumentationFramework.isIndirectAttack(Argument arg1, Argument arg2)	Determine if there is an indirect attack from arg1 to arg2
boolean	BipolarArgumentationFramework.isMediatedAttack(Argument arg1, Argument arg2)	Determine if there is a mediated attack from arg1 to arg2
boolean	BipolarArgumentationFramework.isStronglyDefendedBy(Collection<Argument> ext, Argument arg)	Determines whether 'ext' strongly defends 'arg', i.e., whether 'arg' is defended under consideration of supported and indirect attacks
boolean	BipolarArgumentationFramework.isSupportedAttack(Argument arg1, Argument arg2)	Determine if there is a supported attack from arg1 to arg2
boolean	BipolarArgumentationFramework.isSupportedBy(Argument arg1, Argument arg2)	Check whether arg1 is directly supported by arg2

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

Modifier and Type	Method	Description
Collection<Argument>	BipolarArgumentationFramework.getSupported(Collection<Argument> ext)	Compute the set of arguments supported by ext
Collection<Argument>	BipolarArgumentationFramework.getSupporters(Collection<Argument> ext)	Compute the set of arguments supporting by ext
boolean	BipolarArgumentationFramework.isCoalition(Collection<Argument> args)	Determines whether 'args' is a coalition, i.e., whether 'args' is a maximal conflict-free set of arguments that is connected via the support relation.
boolean	BipolarArgumentationFramework.isCoherent(Collection<Argument> args)	Determines whether 'args' is coherent, i.e., whether there exists no argument that is both (indirectly) supported and attacked (either supported or indirectly) by 'args'
boolean	BipolarArgumentationFramework.isCoherentAdmissible(Collection<Argument> args)	Determines whether 'args' is coherent admissible, i.e., whether 'args' is coherent and strongly defends all its arguments
boolean	BipolarArgumentationFramework.isStronglyConflictFree(Collection<Argument> args)	Determines whether 'args' is strongly conflict-free, i.e., whether 'args' is conflict-free wrt.
boolean	BipolarArgumentationFramework.isStronglyDefendedBy(Collection<Argument> ext, Argument arg)	Determines whether 'ext' strongly defends 'arg', i.e., whether 'arg' is defended under consideration of supported and indirect attacks

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

Modifier	Constructor	Description
	Support(Argument supporter, Argument supported)	Default constructor; initializes the two arguments used in this support relation

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

Modifier	Constructor	Description
	CoalitionArgument(Collection<Argument> args)	Initializes a new Coalition-Argument for the given set

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

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

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

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

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

Modifier	Constructor	Description
	ConstrainedArgumentationFramework(Graph<Argument> graph)	Constructor for a CAF from a graph.
	ConstrainedArgumentationFramework(Graph<Argument> graph, String constraint)	Constructor for a CAF from a given graph and constraint.
	ConstrainedArgumentationFramework(Graph<Argument> graph, PlFormula constraint)	Constructor for a CAF from a graph and a propositional formula as the constraint.

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	Represents a simple propositional logic argument in deductive argumentation.

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 argsA 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)	Computes whether argsA and argsB are independent given argsC in the given AF.
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

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

Modifier and Type	Method	Description
Map<Argument,Collection<Collection<Attack>>>	SimpleAFLearner.computePartialAttackRelations()	TODO is this still necessary?

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)	Creates a new theory synthesizer for the given arguments and semantics.
	OptimizedParallelAFLearner(Collection<Argument> args)	initialize the Learner with a set of arguments
	RiveretTheoryLearner(Collection<Argument> arguments, int max_cycles)	initialize learner for the given set of arguments
	SimpleAFLearner(Collection<Argument> args)	initialize the Learner with a set of arguments
	TheoryLearner(Collection<Argument> args, Semantics semantics, String solverLocation)	Creates a new theory learner for the given arguments and semantics.

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

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

Modifier and Type	Method	Description
Argument	AttackConstraint.getArgument()	Retrieves the argument associated with this constraint.
Argument	ClausalAttackConstraint.getArgument()	returns the argument
Argument	SimpleAttackConstraint.getArgument()	return the argument the condition is for

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

Modifier and Type	Method	Description
Collection<Argument>	Entity.getArguments()	get the set of arguments of the hidden AF

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

Modifier and Type	Method	Description
AssociativePlFormula	SimpleAttackConstraint.getConditionForArgument(Argument arg, Input input)	compute the acceptance condition with respect to the labeling and its semantics for the given argument

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

Modifier and Type	Method	Description
AssociativePlFormula	SimpleAttackConstraint.getOptionalCondition(Collection<Argument> arguments)	compute the optional acceptance condition for this argument based on its acceptance condition

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

Modifier	Constructor	Description
	ClausalAttackConstraint(Argument arg)	simple constructor
	ClausalAttackConstraint(Argument arg, Input input)	Constructor that creates a clausal attack constraint from an argument and input
	SimpleAttackConstraint(Argument arg)	initialize empty acceptance condition for the given argument in tha case any incoming attack is optional
	SimpleAttackConstraint(Argument arg, Input input)	compute acceptance condition for the given argument with respect to the given input labeling

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	AllowingAbstentionPrinciple.isApplicable(Collection<Argument> kb)
boolean	CFReinstatementPrinciple.isApplicable(Collection<Argument> kb)
boolean	ConflictFreePrinciple.isApplicable(Collection<Argument> kb)
boolean	DefencePrinciple.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	AllowingAbstentionPrinciple.isSatisfied(Collection<Argument> kb, AbstractExtensionReasoner ev)
boolean	CFReinstatementPrinciple.isSatisfied(Collection<Argument> kb, AbstractExtensionReasoner ev)
boolean	ConflictFreePrinciple.isSatisfied(Collection<Argument> kb, AbstractExtensionReasoner ev)
boolean	DefencePrinciple.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)
boolean	NonInterferencePrinciple.isSatisfied(Collection<Argument> kb, AbstractExtensionReasoner ev)
abstract boolean	Principle.isSatisfied(Collection<Argument> kb, AbstractExtensionReasoner ev)	Computes whether the given extension reasoner (i.e.
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	SemiDirectionalityPrinciple.isSatisfied(Collection<Argument> kb, AbstractExtensionReasoner ev)
boolean	SemiQualifiedAdmissibilityPrinciple.isSatisfied(Collection<Argument> kb, AbstractExtensionReasoner ev)
boolean	StrongAdmissibilityPrinciple.isSatisfied(Collection<Argument> kb, AbstractExtensionReasoner ev)
boolean	WeakDirectionalityPrinciple.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>	FudgeAcceptabilityReasoner.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>	SolidAdmissibleReasoner.getSolidlyDefended(Extension<DungTheory> ext, DungTheory theory)	Returns all arguments solidly defended by the given extension.
Collection<Argument>	AbstractExtensionReasoner.queryAll(DungTheory bbase, InferenceMode inferenceMode)	Determine the set of acceptable arguments wrt.
Collection<Argument>	IncompleteReasoner.queryAll(IncompleteTheory bbase, IncompleteReasoner.Type type, InferenceMode inferenceMode)	Determines the set of arguments that is acceptable wrt this reasoner and the given parameters

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	IncompleteReasoner.isNecessaryCredulous(IncompleteTheory theory, Argument arg)	Decides whether the given argument is a necessary credulous conclusion of the incomplete theory
boolean	IncompleteReasoner.isNecessarySkeptical(IncompleteTheory theory, Argument arg)	Decides whether the given argument is a necessary skeptical conclusion of the incomplete theory
boolean	IncompleteReasoner.isPossibleCredulous(IncompleteTheory theory, Argument arg)	Decides whether the given argument is a possible credulous conclusion of the incomplete theory
boolean	IncompleteReasoner.isPossibleSkeptical(IncompleteTheory theory, Argument arg)	Decides whether the given argument is a possible skeptical conclusion of the incomplete theory
boolean	SolidAdmissibleReasoner.isSolidlyDefendedBy(Argument arg, Extension<DungTheory> ext, DungTheory theory)	Checks whether the given extension solidly defends the argument.
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.
Integer	GCF_GreedyKApproximationReasoner.query(DungTheory aaf, Argument arg)
Integer	GFR_GreedyKApproximationReasoner.query(DungTheory aaf, Argument arg)
Integer	GgAdmissibleApproximationReasoner.query(DungTheory aaf, Argument arg)
Integer	GgAdmissibleAstApproximationReasoner.query(DungTheory aaf, Argument arg)
Integer	GsAdmissibleApproximationReasoner.query(DungTheory aaf, Argument arg)
Integer	GsAdmissibleAstApproximationReasoner.query(DungTheory aaf, Argument arg)
Boolean	IncompleteReasoner.query(IncompleteTheory beliefbase, Argument formula)
Boolean	IncompleteReasoner.query(IncompleteTheory beliefbase, Argument formula, InferenceMode mode, IncompleteReasoner.Type type)	Determines acceptability of an argument under the given parameters
Integer	KOptimisationReasoner.query(DungTheory aaf, Argument arg)
Integer	MaxSatKAdmissibleAstReasoner.query(DungTheory aaf, Argument arg)
Integer	MaxSatKAdmissibleReasoner.query(DungTheory aaf, Argument arg)
Integer	MaxSatKStableAstReasoner.query(DungTheory aaf, Argument arg)
Integer	MaxSatKStableReasoner.query(DungTheory aaf, Argument arg)
Boolean	ProboI23Reasoner.query(DungTheory beliefbase, Argument formula, InferenceMode inferenceMode)
Boolean	ProboReasoner.query(DungTheory beliefbase, Argument formula, InferenceMode inferenceMode)
Boolean	SatCompleteReasoner.query(DungTheory beliefbase, Argument formula, InferenceMode inferenceMode)
Integer	SCF_GreedyKApproximationReasoner.query(DungTheory aaf, Argument arg)
Integer	SFR_GreedyKApproximationReasoner.query(DungTheory aaf, Argument arg)
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.
Pair<Boolean,Extension<DungTheory>>	ProboI23Reasoner.queryW(DungTheory beliefbase, Argument formula, InferenceMode inferenceMode)	Returns the queried witness together with the yes/no answer.

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

Modifier and Type	Method	Description
static boolean	MaxSatKAdmissibleAstReasoner.defendsAgainstOutsideAttackers(DungTheory aaf, Collection<Argument> set)	Returns "true" if set defends against all attacks from outside of set
static int	MaxSatKAdmissibleAstReasoner.eval(DungTheory aaf, Collection<Argument> set)	Returns the maximal k such that the given extension is a k-adm* extension of the given AAF.
static int	MaxSatKAdmissibleReasoner.eval(DungTheory aaf, Collection<Argument> set)	Returns the maximal k such that the given extension is a k-adm# extension of the given AAF.
static int	MaxSatKStableAstReasoner.eval(DungTheory aaf, Set<Argument> set)	Returns the maximal k such that the given extension is a k-stable* extension of the given AAF.
static int	MaxSatKStableReasoner.eval(DungTheory aaf, Set<Argument> set)	Returns the maximal k such that the given extension is a k-stable extension of the given AAF.
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<DungTheory>>	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

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

Modifier and Type	Class	Description
class	AbstractArgumentationInterpretation<T extends ArgumentationFramework<Argument>>	This abstract class acts as a common ancestor for interpretations to abstract argumentation frameworks.
class	Extension<T extends ArgumentationFramework<Argument>>	This class models a (possible) extension of a Dung theory, i.e.

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>>	MinMaxNumbering.entrySet()
Set<Map.Entry<Argument,Integer>>	StratifiedLabeling.entrySet()
Collection<Argument>	MinMaxNumbering.getArgumentsOfRank(Integer value)	Retrieves a collection of arguments that have the specified rank value.
Extension<? extends ArgumentationFramework<Argument>>	Labeling.getArgumentsOfStatus(ArgumentStatus status)
Iterator<Argument>	Extension.iterator()
Set<Argument>	Labeling.keySet()
Set<Argument>	MinMaxNumbering.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	MinMaxNumbering.put(Argument key, Integer value)
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	MinMaxNumbering.putAll(Map<? extends Argument,? extends Integer> m)
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.
	Labeling(ArgumentationFramework<Argument> theory, Extension<? extends ArgumentationFramework<Argument>> ext)	Creates a new labeling from the given extension wrt.
	Labeling(ArgumentationFramework<Argument> theory, Extension<? extends ArgumentationFramework<Argument>> ext)	Creates a new labeling from the given extension wrt.
	MinMaxNumbering(ArgumentationFramework<Argument> theory, Extension<? extends ArgumentationFramework<Argument>> extension)	Initializes a new Min-Max Numbering for the given theory and extension
	MinMaxNumbering(ArgumentationFramework<Argument> theory, Extension<? extends ArgumentationFramework<Argument>> extension)	Initializes a new Min-Max Numbering for the given theory and extension
	MinMaxNumbering(ArgumentationFramework<Argument> theory, Labeling labeling)	Initialize a new Min-Max Numbering from the given theory and labeling

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

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

Modifier and Type	Method	Description
Collection<? extends Argument>	SerialisationSequence.get(int index)
Iterator<Collection<? extends Argument>>	SerialisationSequence.iterator()
ListIterator<Collection<? extends Argument>>	SerialisationSequence.listIterator()
ListIterator<Collection<? extends Argument>>	SerialisationSequence.listIterator(int index)
Collection<? extends Argument>	SerialisationSequence.remove(int index)
Collection<? extends Argument>	SerialisationSequence.set(int index, Collection<? extends Argument> element)
List<Collection<? extends Argument>>	SerialisationSequence.subList(int fromIndex, int toIndex)

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

Modifier and Type	Method	Description
void	SerialisationSequence.add(int index, Collection<? extends Argument> element)
boolean	SerialisationSequence.add(Collection<? extends Argument> arguments)
boolean	SerialisationSequence.addAll(int index, Collection<? extends Collection<? extends Argument>> c)
boolean	SerialisationSequence.addAll(Collection<? extends Collection<? extends Argument>> c)
Collection<? extends Argument>	SerialisationSequence.set(int index, Collection<? extends Argument> element)

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

Modifier	Constructor	Description
	SerialisationSequence(Collection<? extends Argument> arguments)	Initializes a serialisation sequence with arguments as the first element
	SerialisationSequence(List<? extends Collection<? extends Argument>> sequence)	Initializes a serialisation sequence starting with the given List of initial sets

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

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

Modifier and Type	Class	Description
class	ClaimArgument	Represents an argument with an associated claim.

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

Modifier and Type	Field	Description
Collection<Argument>	IncompleteTheory.definiteArguments	definite arguments
Collection<Argument>	IncompleteTheory.uncertainArgument	uncertain arguments

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
Collection<Argument>	DungTheory.getAttacked(Collection<Argument> args)	Computes the set {A | (arg,A) in attacks for some arg in args}.
Set<Argument>	DungTheory.getAttacked(Argument argument)	Computes the set {A | (argument,A) in attacks}.
Collection<Argument>	DungTheory.getAttackers(Collection<Argument> args)	Computes the set {A | (A,arg) in attacks for some arg in args}.
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()	Returns the connected components of this theory.
Collection<Collection<Argument>>	DungTheory.getConnectedComponents()
Edge<Argument>	DungTheory.getEdge(Argument a, Argument b)
Collection<? extends Edge<? extends Argument>>	DungTheory.getEdges()
Collection<Graph<Argument>>	DungTheory.getInducedSubgraphs()	Returns the induced subgraphs of this theory.
Collection<Argument>	DungTheory.getNeighbors(Argument node)
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()
Collection<Argument>	DungTheory.getUnattackedAttackers(Collection<Argument> ext)	Returns the set of arguments b such that a is in ext and there is no c in ext such that (c,b) is an attack.

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
void	IncompleteTheory.addDefiniteArgument(Argument arg)	adds definite argument
void	IncompleteTheory.addDefiniteAttack(Argument arg1, Argument arg2)	adds definite attack
void	IncompleteTheory.addPossibleArgument(Argument arg)	adds possible argument
void	IncompleteTheory.addPossibleAttack(Argument arg1, Argument arg2)	adds uncertain argument
boolean	DungTheory.areAdjacent(Argument a, Argument b)
int	Argument.compareTo(Argument o)
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)
DungTheory	DungTheory.getReduct(Argument arg)	computes the reduct of this wrt.
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<DungTheory> 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	DungTheory.isAttacked(Argument argument, Extension<? extends ArgumentationFramework<?>> 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.isStronglyDefendedBy(Argument arg, Collection<Argument> ext)	Checks whether a specified argument is strongly defended by the given set of arguments.
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)
Collection<Argument>	DungTheory.getAttacked(Collection<Argument> args)	Computes the set {A | (arg,A) in attacks for some arg in args}.
Collection<Argument>	DungTheory.getAttackers(Collection<Argument> args)	Computes the set {A | (A,arg) in attacks for some arg in args}.
DungTheory	DungTheory.getReduct(Collection<Argument> arguments)	computes the reduct of bbase wrt.
Graph<Argument>	DungTheory.getRestriction(Collection<Argument> arguments)
Collection<Argument>	DungTheory.getUnattackedAttackers(Collection<Argument> ext)	Returns the set of arguments b such that a is in ext and there is no c in ext such that (c,b) is an attack.
Collection<Attack>	DungTheory.getUndefendedAttacks(Collection<Argument> ext)	Returns the set of attacks (b,a) such that a is in ext and there is no c in ext such that (c,b) is an attack.
void	IncompleteTheory.instantiate(Collection<Argument> usedPossibleArguments, Collection<Attack> usedPossibleAttacks)	instantiates some possible arguments and attacks
boolean	DungTheory.isAttackedBy(Argument argument, Collection<Argument> ext)	returns true if some argument of ext is attacked by argument.
boolean	DungTheory.isAttackingAllOtherArguments(Extension<? extends ArgumentationFramework<Argument>> ext)	returns true if arguments attack all other arguments in the theory
boolean	Attack.isConflictFree(Collection<? extends Argument> arguments)	returns true if one arguments in arguments attacks another within this attack relation.
boolean	DungTheory.isConflictFree(Collection<Argument> ext)	returns true if no accepted argument attacks another one in the set
boolean	DungTheory.isStronglyDefendedBy(Argument arg, Collection<Argument> ext)	Checks whether a specified argument is strongly defended by the given set of arguments.
void	IncompleteTheory.optimisticCompletion(Collection<Argument> s)	constructs optimistic completion (all attacks from and to set s are instantiated and no other possible attacks)
void	IncompleteTheory.pessimisticCompletion(Collection<Argument> s)	constructs pessimistic completion (all attacks but the ones from and to set s are instantiated and no other possible attacks)

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 that return types with arguments of type Argument

Modifier and Type	Method	Description
static Collection<Argument>	Realizability.args(Collection<Extension<DungTheory>> exts)	Returns the set of all arguments appearing in some extension.
static Collection<Set<Argument>>	Realizability.pairs(Collection<Extension<DungTheory>> exts)	Returns the set of sets of arguments {a,b}, s.t.

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

Modifier and Type	Method	Description
static boolean	Realizability.isPair(Collection<Extension<DungTheory>> exts, Argument a, Argument b)	Checks whether the given pair of arguments is a pair in the extension set, i.e.
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	KwtDungTheoryGenerator.next(Argument arg)
DungTheory	PodlaszewskiCaminadaDungTheoryGenerator.next(Argument arg)
DungTheory	PrSigBasedDungTheoryGenerator.next(Argument arg)

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

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

Modifier and Type	Method	Description
Argument	Iccma23Writer.getArgument(int i)	Returns the argument mapped to the given integer wrt.

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

Modifier and Type	Method	Description
int	Iccma23Writer.getArgumentId(Argument arg)	Returns the mapping of the given argument wrt.

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.eaf.reasoner

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

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

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

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

Modifier	Constructor	Description
	EpistemicArgumentationFramework(Graph<Argument> graph)	Constructor for an EAF from a graph.
	EpistemicArgumentationFramework(Graph<Argument> graph, String constraint)	Constructor for an EAF using a given graph and constraint.
	EpistemicArgumentationFramework(Graph<Argument> graph, FolFormula constraint)	Constructor for an EAF from a graph and a modal logic formula as the constraint.

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

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

Modifier and Type	Method	Description
boolean	ExplanationPrinciple.isApplicable(Collection<Argument> kb)
abstract boolean	ExplanationPrinciple.isSatisfied(Collection<Argument> kb, AbstractAcceptanceExplanationReasoner ev)	Determines whether this principle is satisfied by the given reasoner for the given instance
boolean	ExplanationPrinciple.isSatisfied(Collection<Argument> kb, PostulateEvaluatable<Argument> ev)
boolean	ExplanationPrinciple.isSatisfied(Collection<Argument> kb, PostulateEvaluatable<Argument> ev)

Uses of Argument in org.tweetyproject.arg.explanations.reasoner.acceptance

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

Modifier and Type	Method	Description
Collection<Argument>	SufficientExplanationReasoner.getRelevantArguments(DungTheory theory, Argument argument)	Computes the set of arguments relevant for argument in theory i.e.

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

Modifier and Type	Method	Description
Explanation	AbstractAcceptanceExplanationReasoner.getExplanation(DungTheory theory, Argument argument)	Computes some acceptance explanation for argument
abstract Collection<Explanation>	AbstractAcceptanceExplanationReasoner.getExplanations(DungTheory theory, Argument argument)	Computes all acceptance explanations for argument
Collection<Explanation>	DialecticalSequenceExplanationReasoner.getExplanations(DungTheory theory, Argument argument)
Collection<Explanation>	MinimalSequenceExplanationReasoner.getExplanations(DungTheory theory, Argument argument)
Collection<Explanation>	NecessaryExplanationReasoner.getExplanations(DungTheory theory, Argument argument)
Collection<Explanation>	SequenceExplanationReasoner.getExplanations(DungTheory theory, Argument argument)
Collection<Explanation>	SufficientExplanationReasoner.getExplanations(DungTheory theory, Argument argument)
Collection<Argument>	SufficientExplanationReasoner.getRelevantArguments(DungTheory theory, Argument argument)	Computes the set of arguments relevant for argument in theory i.e.
boolean	SufficientExplanationReasoner.isRelevantFor(DungTheory theory, Collection<Argument> arguments, Argument b)	Determines whether the all arguments in the set are relevant for the argument 'b' in the given theory
boolean	SufficientExplanationReasoner.isRelevantFor(DungTheory theory, Argument a, Argument b)	Determines whether the argument 'a' is relevant for the argument 'b' in the given theory

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

Modifier and Type	Method	Description
boolean	SufficientExplanationReasoner.isRelevantFor(DungTheory theory, Collection<Argument> arguments, Argument b)	Determines whether the all arguments in the set are relevant for the argument 'b' in the given theory

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

Methods in org.tweetyproject.arg.explanations.semantics that return Argument

Modifier and Type	Method	Description
Argument	Explanation.getArgument()	returns the argument that is explained by this explanation

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

Modifier and Type	Method	Description
Collection<? extends Argument>	SequenceExplanation.get(int index)
List<Collection<Argument>>	DialectialSequenceExplanation.getDefeated()	returns the sequence of defeated argument sets
List<Collection<? extends Argument>>	SequenceExplanation.getSequence()	returns the sequence representation of the explanation
Collection<Argument>	DialectialSequenceExplanation.getSetExplanation()
abstract Collection<Argument>	Explanation.getSetExplanation()	Returns the set-based explanation.
Collection<Argument>	SequenceExplanation.getSetExplanation()
Collection<Argument>	SetExplanation.getSetExplanation()
List<Collection<Argument>>	DialectialSequenceExplanation.getSupporters()	returns the sequence of supporting argument sets
Iterator<Collection<? extends Argument>>	SequenceExplanation.iterator()
Iterator<Argument>	SetExplanation.iterator()
ListIterator<Collection<? extends Argument>>	SequenceExplanation.listIterator()
ListIterator<Collection<? extends Argument>>	SequenceExplanation.listIterator(int index)
Collection<? extends Argument>	SequenceExplanation.remove(int index)
Collection<? extends Argument>	SequenceExplanation.set(int index, Collection<? extends Argument> element)
List<Collection<? extends Argument>>	SequenceExplanation.subList(int fromIndex, int toIndex)

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

Modifier and Type	Method	Description
boolean	SetExplanation.add(Argument argument)

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

Modifier and Type	Method	Description
boolean	DialectialSequenceExplanation.add(Collection<Argument> s, Collection<Argument> t)	add a new 'step' to the explanation
void	SequenceExplanation.add(int index, Collection<? extends Argument> element)
boolean	SequenceExplanation.add(Collection<? extends Argument> arguments)
boolean	SequenceExplanation.addAll(int index, Collection<? extends Collection<? extends Argument>> c)
boolean	SequenceExplanation.addAll(Collection<? extends Collection<? extends Argument>> c)
boolean	SetExplanation.addAll(Collection<? extends Argument> c)
Collection<? extends Argument>	SequenceExplanation.set(int index, Collection<? extends Argument> element)

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

Modifier	Constructor	Description
	DialectialSequenceExplanation(Argument argument)	Instantiates a new empty dialectical explanation for the given argument
	SequenceExplanation(Argument argument, SerialisationSequence sequence)	Instantiates an explanation for the given argument
	SetExplanation(Argument argument, Collection<Argument> arguments)	Instantiates a new explanation for the given argument

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

Modifier	Constructor	Description
	SetExplanation(Argument argument, Collection<Argument> arguments)	Instantiates a new explanation for the given argument

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

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

Modifier and Type	Method	Description
Boolean	AbstractExtendedExtensionReasoner.query(ExtendedTheory beliefbase, Argument formula)
Boolean	AbstractExtendedExtensionReasoner.query(ExtendedTheory beliefbase, Argument formula, InferenceMode inferenceMode)	Queries the given AAF for the given argument using the given inference type.
Boolean	AbstractRecursiveExtendedExtensionReasoner.query(RecursiveExtendedTheory beliefbase, Argument formula)	Queries the given belief base with a specified argument, using the default inference mode of skeptical reasoning.
Boolean	AbstractRecursiveExtendedExtensionReasoner.query(RecursiveExtendedTheory beliefbase, Argument formula, InferenceMode inferenceMode)	Queries the given AAF for the given argument using the given inference type.

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

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

Modifier and Type	Method	Description
Argument	ExtendedAttack.getAttacker()	returns the attacking argument of this attack relation.
Argument	ExtendedAttack.getNodeA()	get first node of the edge

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

Modifier and Type	Method	Description
Collection<Argument>	ExtendedTheory.getAttackers(Collection<DungEntity> entities)	Computes the set of attackers of 'entities'
Collection<Argument>	ExtendedTheory.getAttackers(Argument argument)	Computes the set of attackers of 'argument'
Collection<Argument>	ExtendedTheory.getAttackers(Attack attack)	Computes the set of attackers of 'attack'
Collection<Argument>	RecursiveExtendedTheory.getAttackers(Collection<DungEntity> entities)	Computes the set of arguments that attack some member of the given set of arguments/attacks.
Collection<Argument>	RecursiveExtendedTheory.getAttackers(DungEntity entity)	Computes the set of arguments that attack the given argument/attack.
Collection<Argument>	ExtendedTheory.getNodes()
Collection<Argument>	RecursiveExtendedTheory.getNodes()

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

Modifier and Type	Method	Description
boolean	ExtendedTheory.add(Argument argument)
boolean	RecursiveExtendedTheory.add(Argument argument)
boolean	ExtendedTheory.addAttack(Argument attacker, Argument attacked)	Adds an attack to the theory
boolean	ExtendedTheory.addAttack(Argument attacker, Attack attacked)	Adds an attack to the theory
boolean	RecursiveExtendedTheory.addAttack(Argument attacker, Argument attacked)	Adds an attack between arguments to the theory.
boolean	RecursiveExtendedTheory.addAttack(Argument attacker, ExtendedAttack attacked)	Adds a recursive attack to the theory.
boolean	ExtendedAttack.contains(Argument argument)	Return true if the given argument is in this attack relation.
boolean	ExtendedTheory.existsReinstatementSet(Argument a, Argument b, Collection<Argument> S)	Determines whether there exists a reinstatement set for the attack (a,b)
Collection<DungEntity>	ExtendedTheory.getAttacked(Argument argument)	Computes the set of Arguments/Attacks attacked by 'argument'
Collection<DungEntity>	RecursiveExtendedTheory.getAttacked(Argument arg)	Computes the set of arguments/attacks directly attacked by 'arg'.
Collection<Argument>	ExtendedTheory.getAttackers(Argument argument)	Computes the set of attackers of 'argument'
Collection<Attack>	ExtendedTheory.getReinstatementSet(Argument a, Argument b, Collection<Argument> S)	Computes the reinstatement set for the attack (a,b)
boolean	ExtendedTheory.isAcceptable(Argument arg, Collection<Argument> ext)	Determines whether the argument 'arg' is defended by the set 'ext'
boolean	ExtendedTheory.isAttacked(Argument a, Extension<? extends ArgumentationFramework<?>> ext)
boolean	ExtendedTheory.isAttacked(Argument a, Argument b)	Determines whether 'a' is attacked by 'b' in the theory
boolean	ExtendedTheory.isAttacked(Attack a, Argument b)	Determines whether 'a' is attacked by 'b' in the theory
boolean	RecursiveExtendedTheory.isAttacked(Argument a, Extension<? extends ArgumentationFramework<?>> ext)
boolean	RecursiveExtendedTheory.isAttacked(Argument a, Argument b)	Determines whether 'a' is attacked by 'b'.
boolean	RecursiveExtendedTheory.isAttacked(ExtendedAttack a, Argument b)	Determines whether 'a' is attacked by 'b'.
boolean	ExtendedTheory.isReinstatementSet(Collection<Attack> W, Argument a, Argument b, Collection<Argument> S)	Determines whether 'W' is a reinstatement set for the attack (a,b) A set of attacks W is a reinstatement set for an attack (a,b) iff (a,b) is an attack undisturbed by the set S and W contains all attack originating from S necessary to reinstate the attack (a,b) against all its attacks
boolean	ExtendedTheory.isUndisturbedAttack(Argument a, Argument b, Collection<Argument> ext)	Determines whether there is an undisturbed attack from 'a' to 'b' given 'ext', i.e., whether 'a' attacks 'b' and there is no extended attack from some element of 'ext' onto the attack (a,b)
Collection<Attack>	ExtendedTheory.minimizeReinstatementSet(Collection<Attack> W, Argument a, Argument b, Collection<Argument> S)	Minimizes the given Reinstatement set for (a,b)

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

Modifier and Type	Method	Description
boolean	ExtendedTheory.existsReinstatementSet(Argument a, Argument b, Collection<Argument> S)	Determines whether there exists a reinstatement set for the attack (a,b)
Collection<DungEntity>	ExtendedTheory.getAttacked(Collection<Argument> ext)	Computes the set of Arguments/Attacks attacked by 'ext'
Collection<DungEntity>	RecursiveExtendedTheory.getAttacked(Collection<Argument> ext)	Computes the set of arguments/attacks directly attacked by some argument in 'ext'.
Collection<Attack>	ExtendedTheory.getReinstatementSet(Argument a, Argument b, Collection<Argument> S)	Computes the reinstatement set for the attack (a,b)
boolean	ExtendedTheory.isAcceptable(Argument arg, Collection<Argument> ext)	Determines whether the argument 'arg' is defended by the set 'ext'
boolean	ExtendedTheory.isAdmissible(Collection<Argument> ext)	Determines whether 'ext' is admissible, i.e., conflict-free and defends all its arguments
boolean	ExtendedTheory.isComplete(Collection<Argument> ext)	Determines whether 'ext' is complete, i.e., admissible and contains all arguments defended by it
boolean	ExtendedTheory.isConflictFree(Collection<Argument> ext)	Determines whether the given set of arguments contains no conflicts, i.e., there are no attacks between any of its members
boolean	ExtendedTheory.isUndisturbedAttack(Argument a, Argument b, Collection<Argument> ext)	Determines whether there is an undisturbed attack from 'a' to 'b' given 'ext', i.e., whether 'a' attacks 'b' and there is no extended attack from some element of 'ext' onto the attack (a,b)
boolean	ExtendedTheory.isUndisturbedAttack(Attack att, Collection<Argument> ext)	Determines whether there is an undisturbed attack from 'a' to 'b' given 'ext', i.e., whether 'a' attacks 'b' and there is no extended attack from some element of 'ext' onto the attack (a,b)

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

Modifier	Constructor	Description
	ExtendedAttack(Argument attacker, Argument attacked)	Initializes an extended attack from an argument to an argument
	ExtendedAttack(Argument attacker, Attack attacked)	Initializes an extended attack from an argument to an attack
	ExtendedAttack(Argument attacker, DungEntity attacked)	Constructs an ExtendedAttack object, which represents an extended attack in a Dung argumentation framework.
	ExtendedAttack(Argument attacker, ExtendedAttack attacked)	Initializes an extended attack from an argument to an extended attack

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 that return types with arguments of type Argument

Modifier and Type	Method	Description
Map<Argument,Double>	AbstractPafReasoner.queryAll(ProbabilisticArgumentationFramework paf, InferenceMode inferenceMode)	Determine the set of acceptable arguments wrt.

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)	(non-Javadoc)
boolean	RaNonAttackedEquivalence.isApplicable(Collection<Argument> kb)
boolean	RaQualityPrecedence.isApplicable(Collection<Argument> kb)
boolean	RaSelfContradiction.isApplicable(Collection<Argument> kb)
boolean	RaSigmaCompatibility.isApplicable(Collection<Argument> kb)
boolean	RaSkeptSigmaCompatibility.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<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaAbstraction.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaAdditionOfAttackBranch.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaAdditionOfAttackBranch.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaAdditionOfDefenseBranch.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaAdditionOfDefenseBranch.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaAttackVsFullDefense.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaAttackVsFullDefense.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaCardinalityPrecedence.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaCardinalityPrecedence.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaCounterTransitivity.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaCounterTransitivity.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaDefensePrecedence.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaDefensePrecedence.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaDistDefensePrecedence.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaDistDefensePrecedence.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaIncreaseOfAttackBranch.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaIncreaseOfAttackBranch.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaIncreaseOfDefenseBranch.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaIncreaseOfDefenseBranch.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaIndependence.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaIndependence.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
abstract boolean	RankingPostulate.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)	Return status
abstract boolean	RankingPostulate.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)	Return status
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<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaNonAttackedEquivalence.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaQualityPrecedence.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaQualityPrecedence.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaSelfContradiction.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaSelfContradiction.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaSigmaCompatibility.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaSigmaCompatibility.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaSkeptSigmaCompatibility.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaSkeptSigmaCompatibility.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaStrictAdditionOfDefenseBranch.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaStrictAdditionOfDefenseBranch.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaStrictCounterTransitivity.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaStrictCounterTransitivity.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaTotal.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaTotal.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaVoidPrecedence.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)
boolean	RaVoidPrecedence.isSatisfied(Collection<Argument> kb, AbstractRankingReasoner<GeneralComparator<Argument,DungTheory>> ev)

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

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

Modifier and Type	Class	Description
class	AbstractRankingReasoner<R extends GeneralComparator<Argument,DungTheory>>	Common abstract class for ranking reasoners for abstract argumentation.

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

Modifier and Type	Method	Description
LatticePartialOrder<Argument,DungTheory>	CounterTransitivityReasoner.cardinality(DungTheory af)	orders arguments after the amount of attackers they have.
LatticePartialOrder<Argument,DungTheory>	CounterTransitivityReasoner.cardinalityFirst(DungTheory af, LatticePartialOrder<Argument,DungTheory> ra)	ranks arguments according to the cardinality function.
LatticePartialOrder<Argument,DungTheory>	BurdenBasedRankingReasoner.getModel(DungTheory base)
NumericalPartialOrder<Argument,DungTheory>	CategorizerRankingReasoner.getModel(DungTheory base)
LatticePartialOrder<Argument,DungTheory>	CounterTransitivityReasoner.getModel(DungTheory bbase)
NumericalPartialOrder<Argument,DungTheory>	CountingRankingReasoner.getModel(DungTheory kb)
LatticePartialOrder<Argument,DungTheory>	DiscussionBasedRankingReasoner.getModel(DungTheory kb)
LatticePartialOrder<Argument,DungTheory>	IteratedGradedDefenseReasoner.getModel(DungTheory bbase)
NumericalPartialOrder<Argument,DungTheory>	ProbabilisticRankingReasoner.getModel(DungTheory aaf)
LatticePartialOrder<Argument,DungTheory>	PropagationRankingReasoner.getModel(DungTheory kb)
NumericalPartialOrder<Argument,DungTheory>	SAFRankingReasoner.getModel(DungTheory kb)
LatticePartialOrder<Argument,DungTheory>	SerialisableRankingReasoner.getModel(DungTheory bbase)
NumericalPartialOrder<Argument,DungTheory>	StrategyBasedRankingReasoner.getModel(DungTheory kb)
LatticePartialOrder<Argument,DungTheory>	TuplesRankingReasoner.getModel(DungTheory kb)
Collection<LatticePartialOrder<Argument,DungTheory>>	BurdenBasedRankingReasoner.getModels(DungTheory bbase)
Collection<NumericalPartialOrder<Argument,DungTheory>>	CategorizerRankingReasoner.getModels(DungTheory bbase)
Collection<LatticePartialOrder<Argument,DungTheory>>	CounterTransitivityReasoner.getModels(DungTheory bbase)
Collection<NumericalPartialOrder<Argument,DungTheory>>	CountingRankingReasoner.getModels(DungTheory bbase)
Collection<LatticePartialOrder<Argument,DungTheory>>	DiscussionBasedRankingReasoner.getModels(DungTheory bbase)
Collection<LatticePartialOrder<Argument,DungTheory>>	IteratedGradedDefenseReasoner.getModels(DungTheory bbase)
Collection<NumericalPartialOrder<Argument,DungTheory>>	ProbabilisticRankingReasoner.getModels(DungTheory bbase)
Collection<LatticePartialOrder<Argument,DungTheory>>	PropagationRankingReasoner.getModels(DungTheory bbase)
Collection<NumericalPartialOrder<Argument,DungTheory>>	SAFRankingReasoner.getModels(DungTheory bbase)
Collection<LatticePartialOrder<Argument,DungTheory>>	SerialisableRankingReasoner.getModels(DungTheory bbase)
Collection<NumericalPartialOrder<Argument,DungTheory>>	StrategyBasedRankingReasoner.getModels(DungTheory bbase)
Collection<LatticePartialOrder<Argument,DungTheory>>	TuplesRankingReasoner.getModels(DungTheory bbase)
Map<Argument,Pair<int[],int[]>>	TuplesRankingReasoner.getTupledValues()	Return the tupled values computed by previous calls of getModel
LatticePartialOrder<Argument,DungTheory>	CounterTransitivityReasoner.gfpCardinality(DungTheory af)	calculates the greatest fix point.
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.
LatticePartialOrder<Argument,DungTheory>	CounterTransitivityReasoner.quality(DungTheory af, LatticePartialOrder<Argument,DungTheory> ra)	ranks arguments according to a given ranking.
LatticePartialOrder<Argument,DungTheory>	CounterTransitivityReasoner.qualityFirst(DungTheory af, LatticePartialOrder<Argument,DungTheory> ra)	ranks arguments according to the quality function.
LatticePartialOrder<Argument,DungTheory>	CounterTransitivityReasoner.simpleDominance(DungTheory af, LatticePartialOrder<Argument,DungTheory> ra)	only ranks two arguments if one is better according to quality and cardinality

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
LatticePartialOrder<Argument,DungTheory>	CounterTransitivityReasoner.cardinalityFirst(DungTheory af, LatticePartialOrder<Argument,DungTheory> ra)	ranks arguments according to the cardinality function.
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.
LatticePartialOrder<Argument,DungTheory>	CounterTransitivityReasoner.quality(DungTheory af, LatticePartialOrder<Argument,DungTheory> ra)	ranks arguments according to a given ranking.
LatticePartialOrder<Argument,DungTheory>	CounterTransitivityReasoner.qualityFirst(DungTheory af, LatticePartialOrder<Argument,DungTheory> ra)	ranks arguments according to the quality function.
LatticePartialOrder<Argument,DungTheory>	CounterTransitivityReasoner.simpleDominance(DungTheory af, LatticePartialOrder<Argument,DungTheory> ra)	only ranks two arguments if one is better according to quality and cardinality

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

Modifier	Constructor	Description
	CounterTransitivityReasoner(CounterTransitivityReasoner.solver sol, LatticePartialOrder<Argument,DungTheory> rank)	Constructor

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.
static GeneralComparator<Argument,DungTheory>	RankingTools.roundRanking(NumericalPartialOrder<Argument,DungTheory> ranking, int n)	Rounds values in the given numerical argument ranking to n decimals.

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.
static GeneralComparator<Argument,DungTheory>	RankingTools.roundRanking(NumericalPartialOrder<Argument,DungTheory> ranking, int n)	Rounds values in the given numerical argument ranking to n decimals.

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)

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
Collection<Argument>	SetAf.getAttacked(Collection<Argument> arguments)	Computes the set of arguments collectively attacked by arguments.
Collection<Collection<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)	Return the children of the node
Collection<Argument>	SetAf.getChildren(Node node)
Collection<Argument>	SetAf.getNeighbors(Argument node)
Collection<Argument>	SetAf.getNodes()
Collection<Set<Argument>>	SetAf.getParents(Argument node)	Return the arguments' parents
Collection<Argument>	SetAf.getParents(Node node)
Collection<DirHyperGraph<Argument>>	SetAf.getSubGraphs()
static Collection<DirHyperGraph<Argument>>	SetAf.getSubgraphsHelper(SetAf g)	Return the subgraphs of the SetAf
Iterator<Argument>	SetAf.iterator()
Set<Set<Argument>>	SetAf.powerSet(Set<Argument> originalSet)	Return the powerset of

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

Modifier and Type	Method	Description
boolean	SetAf.add(Argument arg)	Add argument to SetAf
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)	Return whether the path exists
Collection<Collection<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)	Return the arguments' parents
boolean	SetAf.isAcceptable(Argument argument, Extension<SetAf> ext)	returns true if every attacker on argument is attacked by some accepted argument wrt.
boolean	SetAf.isAttacked(Argument argument, Extension<? extends ArgumentationFramework<?>> ext)	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.getAttacked(Collection<Argument> arguments)	Computes the set of arguments collectively attacked by arguments.
Collection<Argument>	SetAf.getChildren(Set<Argument> node)	Return the children of the node
SetAttack	SetAf.getDirEdge(Set<Argument> node1, Node b)	Return the edge between the two
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	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)	Return the powerset of

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.

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

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

Modifier and Type	Method	Description
Set<Argument>	WeightedArgumentationFramework.getDefendedArguments(Argument arg)	Retrieves the set of arguments defended by the given argument.

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

Modifier and Type	Method	Description
boolean	WeightedArgumentationFramework.addAttack(Argument attacker, Argument attacked)	Adds an attack from the first argument to the second to this weighted Dung theory.
boolean	WeightedArgumentationFramework.addAttack(Argument attacker, Argument attacked, T weight)	Adds an attack from the first argument to the second to this weighted Dung theory.
boolean	WeightedArgumentationFramework.gDefence(T gamma, Argument a, Extension<DungTheory> e)	Determines if the given extension can defend itself and argument a from all attacks up to a specified threshold gamma.
Set<Argument>	WeightedArgumentationFramework.getDefendedArguments(Argument arg)	Retrieves the set of arguments defended by the given argument.
boolean	WeightedArgumentationFramework.isAcceptable(Argument argument, Extension<DungTheory> ext)	returns true if every attacker on argument is successfully attacked by some accepted argument wrt.
boolean	WeightedArgumentationFramework.isAttacked(Argument argument, Extension<? extends ArgumentationFramework<?>> ext)	returns true if some argument of ext attacks argument and argument cannot w-defend itself.
boolean	WeightedArgumentationFramework.isAttackedBy(Argument attacker, Collection<Argument> ext)	returns true if some argument of ext is attacked by argument and cannot be w-defended by ext.
boolean	WeightedArgumentationFramework.isAttackedBy(Argument arg1, Argument arg2)	Checks whether arg1 is attacked by arg2 and cannot w-defend itself.
boolean	WeightedArgumentationFramework.isStronglyDefendedBy(Argument arg, Collection<Argument> ext)
boolean	WeightedArgumentationFramework.isSupport(Argument arg1, Argument arg2)	Checks whether "arg1" supports "arg2", i.e.
boolean	WeightedArgumentationFramework.remove(Argument a)	Removes the argument and all its attacks and the corresponding weights
void	WeightedArgumentationFramework.setWeight(Argument attacker, Argument attacked, T weight)	Sets the weight of an attack between the specified attacker and attacked arguments in the framework.
boolean	WeightedArgumentationFramework.wDefence(Argument a, Extension<DungTheory> e)	Determines if the given extension can defend a specific argument from all attacks.

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

Modifier and Type	Method	Description
boolean	WeightedArgumentationFramework.gDefence(T gamma, Extension<DungTheory> e, Set<Argument> attackers)	Determines if the given extension can defend itself from a set of attackers up to a specified threshold gamma.
boolean	WeightedArgumentationFramework.gDefence(T gamma, Extension<DungTheory> e, Set<Argument> attackers, Set<Argument> attacked)	Determines if the given extension can defend itself and specific arguments from a set of attackers up to a specified threshold gamma.
Collection<Attack>	WeightedArgumentationFramework.getUndefendedAttacks(Collection<Argument> ext)
boolean	WeightedArgumentationFramework.isAttackedBy(Argument attacker, Collection<Argument> ext)	returns true if some argument of ext is attacked by argument and cannot be w-defended by ext.
boolean	WeightedArgumentationFramework.isStronglyDefendedBy(Argument arg, Collection<Argument> ext)
boolean	WeightedArgumentationFramework.wDefence(Extension<DungTheory> e, Set<Argument> attackers)	Determines if the given extension can defend itself from a set of attackers.
boolean	WeightedArgumentationFramework.wDefence(Extension<DungTheory> e, Set<Argument> attackers, Set<Argument> attacked)	Determines if the given extension can defend itself and specific arguments from a set of attackers.

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

Modifier	Constructor	Description
	WeightedArgumentationFramework(Semiring<T> semiring, Graph<Argument> graph)	Constructor for WAF from a graph with a specific Semiring.
	WeightedArgumentationFramework(Semiring<T> semiring, Graph<Argument> graph, Map<String,T> weightMap)	Constructs a Weighted Argumentation Framework using the specified semiring, graph, and weight map.

Uses of Argument in org.tweetyproject.causal.syntax

Subclasses of Argument in org.tweetyproject.causal.syntax

Modifier and Type	Class	Description
class	CausalArgument	This class represents a logical Argument induced from a CausalKnowledgeBase Such an Argument consists of a set of assumptions (premises) and a causal conclusion

Uses of Argument in org.tweetyproject.web.services.bipolar

Methods in org.tweetyproject.web.services.bipolar that return types with arguments of type Argument

Modifier and Type	Method	Description
Collection<Argument>	BipolarReasonerGetModelCallee.call()	Executes the getModel operation using the specified reasoner and base AbstractBipolarFramework.
Collection<Argument>	BipolarReasonerQueryAllCallee.call()	Executes the queryAll operation using the specified reasoner and base BipolarArgumentationFramework.

Uses of Argument in org.tweetyproject.web.services.dung

Methods in org.tweetyproject.web.services.dung that return types with arguments of type Argument

Modifier and Type	Method	Description
Collection<Argument>	DungReasonerQueryAllCallee.call()	Executes the queryAll operation using the specified reasoner and base DungTheory.

Uses of Argument in org.tweetyproject.web.services.iaf

Methods in org.tweetyproject.web.services.iaf that return types with arguments of type Argument

Modifier and Type	Method	Description
Collection<Argument>	IafReasonerQueryAllCallee.call()	Executes the queryAll operation using the specified reasoner and base IncompleteTheory.

Uses of Argument in org.tweetyproject.web.services.paf

Methods in org.tweetyproject.web.services.paf that return types with arguments of type Argument

Modifier and Type	Method	Description
Map<Argument,Double>	PafReasonerQueryAllCallee.call()

Constructors in org.tweetyproject.web.services.paf with parameters of type Argument

Modifier	Constructor	Description
	PafReasonerQueryCallee(AbstractPafReasoner reasoner, ProbabilisticArgumentationFramework paf, Argument argument, InferenceMode inferenceMode)	Default constructor

Uses of Argument in org.tweetyproject.web.services.rankings

Methods in org.tweetyproject.web.services.rankings that return types with arguments of type Argument

Modifier and Type	Method	Description
GeneralComparator<Argument,DungTheory>	RankingReasonerGetModelCallee.call()	Executes the getModel operation using the specified reasoner and base DungTheory.
static NumericalPartialOrder<Argument,DungTheory>	RankingReasonerGetModelCallee.toNumericalRanking(GeneralComparator<Argument,DungTheory> ranking)	Convert relative (lattice-based) ranking to a numerical ranking
static NumericalPartialOrder<Argument,DungTheory>	RankingReasonerGetModelCallee.toNumericalRanking(LatticePartialOrder<Argument,DungTheory> ranking)	Convert relative (lattice-based) ranking to a numerical ranking

Method parameters in org.tweetyproject.web.services.rankings with type arguments of type Argument

Modifier and Type	Method	Description
static NumericalPartialOrder<Argument,DungTheory>	RankingReasonerGetModelCallee.toNumericalRanking(GeneralComparator<Argument,DungTheory> ranking)	Convert relative (lattice-based) ranking to a numerical ranking
static NumericalPartialOrder<Argument,DungTheory>	RankingReasonerGetModelCallee.toNumericalRanking(LatticePartialOrder<Argument,DungTheory> ranking)	Convert relative (lattice-based) ranking to a numerical ranking

Uses of Argument in org.tweetyproject.web.services.sequenceexplanation

Methods in org.tweetyproject.web.services.sequenceexplanation that return types with arguments of type Argument

Modifier and Type	Method	Description
static Set<Argument>	ArgumentFilterSerialization.deserialize(List<String> argumentFilter)	Deserialize the filter for arguments.
Map<Argument,List<DialectialSequenceExplanation>>	SequenceExplanationService.SequenceExplanations.getPerArgumentSequenceExplanations()	Returns the sequence explanations grouped by argument.

Method parameters in org.tweetyproject.web.services.sequenceexplanation with type arguments of type Argument

Modifier and Type	Method	Description
SequenceExplanationService.SequenceExplanations	SequenceExplanationService.querySequenceExplanations(DungTheory theory, Set<Argument> argumentFilter)	Computes sequence explanations for the given theory.

Constructor parameters in org.tweetyproject.web.services.sequenceexplanation with type arguments of type Argument

Modifier	Constructor	Description
	SequenceExplanations(Map<Argument,List<DialectialSequenceExplanation>> perAtomSequenceExplanations)	Creates a new container for sequence explanations.

Uses of Argument in org.tweetyproject.web.util

Methods in org.tweetyproject.web.util with parameters of type Argument

Modifier and Type	Method	Description
static String	ArgumentSerialization.from(Argument argument)	Serialize argument object to string

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

Modifier and Type	Method	Description
static List<String>	ArgumentSerialization.fromCollection(Collection<Argument> arguments)	Serialize a set of arguments to strings
static List<List<String>>	ArgumentSerialization.fromCollectionOfCollections(List<Collection<Argument>> collectionsOfArguments)	Serialize a set of sets of arguments to strings