Modifier and Type | Field and Description |
---|---|
private DialogueTrace<Argument,Extension> |
ArgumentationEnvironment.trace
The current dialogue trace.
|
Modifier and Type | Method and Description |
---|---|
DialogueTrace<Argument,Extension> |
ArgumentationEnvironment.getDialogueTrace()
Returns the current dialogue trace.
|
Constructor and Description |
---|
ExecutableExtension(java.util.Collection<? extends Argument> arguments)
Creates a new extension for the given arguments.
|
Modifier and Type | Field and Description |
---|---|
private Argument |
GroundedGameUtilityFunction.argument
The argument which is played for or against.
|
Modifier and Type | Field and Description |
---|---|
private UtilityFunction<Argument,Extension> |
BeliefState.utilityFunction
The utility function of the agent.
|
private java.util.Set<Argument> |
T3BeliefState.virtualArguments
The set of virtual arguments assumed to exist.
|
Modifier and Type | Method and Description |
---|---|
Argument |
RecognitionFunction.getPreimage(Argument a)
Returns the argument which maps to the set containing
the given argument.
|
Modifier and Type | Method and Description |
---|---|
protected UtilityFunction<Argument,Extension> |
BeliefState.getUtilityFunction()
Returns the utility function of this belief state.
|
Modifier and Type | Method and Description |
---|---|
Argument |
RecognitionFunction.getPreimage(Argument a)
Returns the argument which maps to the set containing
the given argument.
|
Modifier and Type | Method and Description |
---|---|
protected Pair<java.lang.Double,java.util.Set<ExecutableExtension>> |
T2BeliefState.doMove(ArgumentationEnvironment env,
DialogueTrace<Argument,Extension> trace) |
protected Pair<java.lang.Double,java.util.Set<ExecutableExtension>> |
T3BeliefState.doMove(ArgumentationEnvironment env,
DialogueTrace<Argument,Extension> trace) |
protected abstract Pair<java.lang.Double,java.util.Set<ExecutableExtension>> |
BeliefState.doMove(ArgumentationEnvironment env,
DialogueTrace<Argument,Extension> trace)
Gives the set of all best next moves with their expected utility
according to the belief state and the given trace.
|
Pair<java.lang.Double,java.util.Set<ExecutableExtension>> |
T1BeliefState.doMove(ArgumentationEnvironment env,
DialogueTrace<Argument,Extension> trace) |
protected java.util.Set<ExecutableExtension> |
BeliefState.getLegalMoves(ArgumentationEnvironment env,
DialogueTrace<Argument,Extension> trace)
Returns the set of possible moves in the given situation and the given trace.
|
protected double |
ArguingAgent.getUtility(DialogueTrace<Argument,Extension> trace)
Assess the given dialogue trace with the belief states utility function.
|
double |
GroundedGameUtilityFunction.getUtility(DialogueTrace<Argument,Extension> trace) |
double |
GroundedGameUtilityFunction.getUtility(DialogueTrace<Argument,Extension> trace,
java.util.Set<Argument> additionalArguments,
java.util.Set<Attack> additionalAttacks) |
double |
GroundedGameUtilityFunction.getUtility(DialogueTrace<Argument,Extension> trace,
java.util.Set<Argument> additionalArguments,
java.util.Set<Attack> additionalAttacks) |
private double |
GroundedGameUtilityFunction.getUtility(Extension groundedExtension,
DialogueTrace<Argument,Extension> trace)
Determines the utility of the given trace with
the given grounded extension.
|
private boolean |
BeliefState.isLegal(ArgumentationEnvironment env,
DialogueTrace<Argument,Extension> trace,
java.util.Set<Argument> move)
Given the theory from the environment and the dialogue trace, returns true if
move is a valid move.
|
private boolean |
BeliefState.isLegal(ArgumentationEnvironment env,
DialogueTrace<Argument,Extension> trace,
java.util.Set<Argument> move)
Given the theory from the environment and the dialogue trace, returns true if
move is a valid move.
|
void |
T2BeliefState.update(DialogueTrace<Argument,Extension> trace) |
void |
T3BeliefState.update(DialogueTrace<Argument,Extension> trace) |
abstract void |
BeliefState.update(DialogueTrace<Argument,Extension> trace)
Updates the current belief state accordingly to
the given dialogue trace.
|
void |
T1BeliefState.update(DialogueTrace<Argument,Extension> trace) |
Constructor and Description |
---|
GroundedGameUtilityFunction(DungTheory theory,
Argument argument,
GroundedGameSystem.AgentFaction faction)
Construct utility function.
|
Constructor and Description |
---|
BeliefState(Extension knownArguments,
UtilityFunction<Argument,Extension> utilityFunction)
Creates a new belief-state with the given parameters.
|
T1BeliefState(Extension knownArguments,
UtilityFunction<Argument,Extension> utilityFunction)
Creates a new T1-belief-state with the given parameters and without nesting.
|
T1BeliefState(Extension knownArguments,
UtilityFunction<Argument,Extension> utilityFunction,
T1BeliefState oppModel)
Creates a new T1-belief-state with the given parameters.
|
T2BeliefState(Extension knownArguments,
UtilityFunction<Argument,Extension> utilityFunction)
Creates a new T2-belief-state with the given parameters and without nesting.
|
T2BeliefState(Extension knownArguments,
UtilityFunction<Argument,Extension> utilityFunction,
ProbabilityFunction<T2BeliefState> prob)
Creates a new T2-belief-state with the given parameters.
|
T3BeliefState(Extension knownArguments,
UtilityFunction<Argument,Extension> utilityFunction,
java.util.Set<Argument> virtualArguments,
java.util.Set<Attack> virtualAttacks,
RecognitionFunction rec,
ProbabilityFunction<T3BeliefState> prob)
Creates a new T3-belief-state with the given parameters.
|
T3BeliefState(Extension knownArguments,
UtilityFunction<Argument,Extension> utilityFunction,
java.util.Set<Argument> virtualArguments,
java.util.Set<Attack> virtualAttacks,
RecognitionFunction rec,
ProbabilityFunction<T3BeliefState> prob)
Creates a new T3-belief-state with the given parameters.
|
Modifier and Type | Method and Description |
---|---|
protected java.util.Set<Argument> |
OvercautiousArgumentationAgent.attackSet()
Computes the attack set of this agent's focal element wrt.
|
protected java.util.Set<Argument> |
SasAgent.getPossibleArguments()
Returns the set of arguments this agent may bring forward.
|
protected java.util.Set<Argument> |
CautiousArgumentationAgent.necessaryArguments()
Computes the set of necessary arguments for this agent's focal
element, i.e.
|
Constructor and Description |
---|
ABAAttack(Argument attacker,
Argument attacked)
Creates a new ABA attack
|
Modifier and Type | Class and Description |
---|---|
class |
Deduction<T extends Formula> |
Modifier and Type | Class and Description |
---|---|
class |
AspicArgument<T extends Invertable> |
Modifier and Type | Class and Description |
---|---|
class |
SimplePlLogicArgument |
Modifier and Type | Method and Description |
---|---|
Argument |
LdoArgument.getArgument()
Returns an argument representation (in Dung-style)
of this LdoArgument.
|
Modifier and Type | Method and Description |
---|---|
static java.util.Collection<java.util.Collection<Argument>> |
AbstractDungParser.parseExtensionList(java.lang.String s)
Returns a collection view of the given set of extensions (=sets of
arguments)
|
Modifier and Type | Method and Description |
---|---|
private java.util.Collection<Argument> |
SimpleCF2Reasoner.getOutparents(DungTheory af,
java.util.Collection<Argument> s)
Returns the set { a in A | a nicht in S und a -> S }
|
java.util.Collection<Argument> |
GrossiModgilRankingReasoner.gradedDefense(DungTheory theory,
java.util.Collection<Argument> args,
int m,
int n)
Implements the graded defense function from Def.
|
java.util.Collection<Argument> |
GrossiModgilRankingReasoner.gradedNeutrality(DungTheory theory,
java.util.Collection<Argument> args,
int m)
Implements the graded neutrality function from Def.
|
Modifier and Type | Method and Description |
---|---|
private boolean |
GrossiModgilRankingReasoner.isContainedInAll(Argument y,
java.util.Collection<Extension> exts)
Checks whether the given argument "y" is contained in all sets of arguments
in "args".
|
private int |
GrossiModgilRankingReasoner.numOfAttackers(DungTheory theory,
Argument y,
java.util.Collection<Argument> x)
Determines the number of attackers from x to y.
|
java.lang.Boolean |
GrossiModgilRankingReasoner.query(DungTheory beliefbase,
Argument formula) |
abstract java.lang.Boolean |
AbstractDungReasoner.query(DungTheory beliefbase,
Argument formula) |
java.lang.Boolean |
StratifiedLabelingReasoner.query(DungTheory beliefbase,
Argument formula) |
java.lang.Boolean |
AbstractExtensionReasoner.query(DungTheory beliefbase,
Argument formula) |
java.lang.Boolean |
StratifiedLabelingReasoner.query(DungTheory beliefbase,
Argument formula,
int inferenceType)
Queries the given AAF for the given argument using the given
inference type.
|
java.lang.Boolean |
AbstractExtensionReasoner.query(DungTheory beliefbase,
Argument formula,
int inferenceType)
Queries the given AAF for the given argument using the given
inference type.
|
java.lang.Boolean |
ProboReasoner.query(DungTheory beliefbase,
Argument formula,
int inferenceType) |
Modifier and Type | Method and Description |
---|---|
private java.util.Set<Extension> |
SimpleSccCompleteReasoner.computeExtensionsViaSccs(DungTheory theory,
java.util.List<java.util.Collection<Argument>> sccs,
int idx,
java.util.Collection<Argument> in,
java.util.Collection<Argument> out,
java.util.Collection<Argument> undec)
Computes extensions recursively following the SCC structure.
|
private java.util.Set<Extension> |
SimpleSccCompleteReasoner.computeExtensionsViaSccs(DungTheory theory,
java.util.List<java.util.Collection<Argument>> sccs,
int idx,
java.util.Collection<Argument> in,
java.util.Collection<Argument> out,
java.util.Collection<Argument> undec)
Computes extensions recursively following the SCC structure.
|
private java.util.Set<Extension> |
SimpleSccCompleteReasoner.computeExtensionsViaSccs(DungTheory theory,
java.util.List<java.util.Collection<Argument>> sccs,
int idx,
java.util.Collection<Argument> in,
java.util.Collection<Argument> out,
java.util.Collection<Argument> undec)
Computes extensions recursively following the SCC structure.
|
private java.util.Set<Extension> |
SimpleSccCompleteReasoner.computeExtensionsViaSccs(DungTheory theory,
java.util.List<java.util.Collection<Argument>> sccs,
int idx,
java.util.Collection<Argument> in,
java.util.Collection<Argument> out,
java.util.Collection<Argument> undec)
Computes extensions recursively following the SCC structure.
|
private java.util.Set<Extension> |
SimpleCompleteReasoner.getCompleteExtensions(DungTheory dungTheory,
Extension ext,
java.util.Collection<Argument> remaining)
Auxiliary method to compute all complete extensions
|
private java.util.Collection<Argument> |
SimpleCF2Reasoner.getOutparents(DungTheory af,
java.util.Collection<Argument> s)
Returns the set { a in A | a nicht in S und a -> S }
|
protected PlBeliefSet |
SatCompleteReasoner.getPropositionalCharacterisationBySemantics(DungTheory aaf,
java.util.Map<Argument,Proposition> in,
java.util.Map<Argument,Proposition> out,
java.util.Map<Argument,Proposition> undec) |
protected PlBeliefSet |
SatCompleteReasoner.getPropositionalCharacterisationBySemantics(DungTheory aaf,
java.util.Map<Argument,Proposition> in,
java.util.Map<Argument,Proposition> out,
java.util.Map<Argument,Proposition> undec) |
protected PlBeliefSet |
SatCompleteReasoner.getPropositionalCharacterisationBySemantics(DungTheory aaf,
java.util.Map<Argument,Proposition> in,
java.util.Map<Argument,Proposition> out,
java.util.Map<Argument,Proposition> undec) |
protected PlBeliefSet |
SatStableReasoner.getPropositionalCharacterisationBySemantics(DungTheory aaf,
java.util.Map<Argument,Proposition> in,
java.util.Map<Argument,Proposition> out,
java.util.Map<Argument,Proposition> undec) |
protected PlBeliefSet |
SatStableReasoner.getPropositionalCharacterisationBySemantics(DungTheory aaf,
java.util.Map<Argument,Proposition> in,
java.util.Map<Argument,Proposition> out,
java.util.Map<Argument,Proposition> undec) |
protected PlBeliefSet |
SatStableReasoner.getPropositionalCharacterisationBySemantics(DungTheory aaf,
java.util.Map<Argument,Proposition> in,
java.util.Map<Argument,Proposition> out,
java.util.Map<Argument,Proposition> undec) |
protected abstract PlBeliefSet |
AbstractSatExtensionReasoner.getPropositionalCharacterisationBySemantics(DungTheory aaf,
java.util.Map<Argument,Proposition> in,
java.util.Map<Argument,Proposition> out,
java.util.Map<Argument,Proposition> undec)
Returns the semantic-specific propositional characterization of the underlying Dung
theory, see
getPropositionalCharacterisation . |
protected abstract PlBeliefSet |
AbstractSatExtensionReasoner.getPropositionalCharacterisationBySemantics(DungTheory aaf,
java.util.Map<Argument,Proposition> in,
java.util.Map<Argument,Proposition> out,
java.util.Map<Argument,Proposition> undec)
Returns the semantic-specific propositional characterization of the underlying Dung
theory, see
getPropositionalCharacterisation . |
protected abstract PlBeliefSet |
AbstractSatExtensionReasoner.getPropositionalCharacterisationBySemantics(DungTheory aaf,
java.util.Map<Argument,Proposition> in,
java.util.Map<Argument,Proposition> out,
java.util.Map<Argument,Proposition> undec)
Returns the semantic-specific propositional characterization of the underlying Dung
theory, see
getPropositionalCharacterisation . |
java.util.Collection<Argument> |
GrossiModgilRankingReasoner.gradedDefense(DungTheory theory,
java.util.Collection<Argument> args,
int m,
int n)
Implements the graded defense function from Def.
|
java.util.Collection<Argument> |
GrossiModgilRankingReasoner.gradedNeutrality(DungTheory theory,
java.util.Collection<Argument> args,
int m)
Implements the graded neutrality function from Def.
|
boolean |
GrossiModgilRankingReasoner.isMConflictFree(DungTheory theory,
java.util.Collection<Argument> args,
int m)
Checks whether the given set of arguments is m-conflict-free, cf.
|
boolean |
GrossiModgilRankingReasoner.isMNAdmissible(DungTheory theory,
java.util.Collection<Argument> args,
int m,
int n)
Checks whether the given set of arguments is mn-admissible, cf.
|
boolean |
GrossiModgilRankingReasoner.isMNComplete(DungTheory theory,
java.util.Collection<Argument> args,
int m,
int n)
Checks whether the given set of arguments is mn-complete, cf.
|
boolean |
GrossiModgilRankingReasoner.isMNGrounded(DungTheory theory,
java.util.Collection<Argument> args,
int m,
int n)
Checks whether the given set of arguments is mn-grounded, cf.
|
boolean |
GrossiModgilRankingReasoner.isMNPreferred(DungTheory theory,
java.util.Collection<Argument> args,
int m,
int n)
Checks whether the given set of arguments is mn-preferred, cf.
|
boolean |
GrossiModgilRankingReasoner.isMStable(DungTheory theory,
java.util.Collection<Argument> args,
int m)
Checks whether the given set of arguments is m-stable, cf.
|
private int |
GrossiModgilRankingReasoner.numOfAttackers(DungTheory theory,
Argument y,
java.util.Collection<Argument> x)
Determines the number of attackers from x to y.
|
Modifier and Type | Field and Description |
---|---|
private java.util.Set<Argument> |
Extension.arguments
The arguments in the extension
|
private java.util.Map<Argument,ArgumentStatus> |
Labeling.labeling
The actual labeling.
|
private java.util.HashMap<Argument,java.lang.Integer> |
StratifiedLabeling.map
The actual mapping of arguments to integers.
|
private Order<Argument> |
LatticeArgumentRanking.order
The actual order
|
private java.util.Map<Argument,java.lang.Double> |
NumericalArgumentRanking.theMap
The actual map used for storing acceptability values
|
Modifier and Type | Method and Description |
---|---|
java.util.Set<java.util.Map.Entry<Argument,ArgumentStatus>> |
Labeling.entrySet() |
java.util.Set<java.util.Map.Entry<Argument,java.lang.Double>> |
NumericalArgumentRanking.entrySet() |
java.util.Set<java.util.Map.Entry<Argument,java.lang.Integer>> |
StratifiedLabeling.entrySet() |
java.util.Collection<Argument> |
ArgumentRanking.getMaximallyAcceptedArguments(java.util.Collection<Argument> args)
Returns the set of all arguments a from the given
set that are maximally accepted, i.e.
|
java.util.Collection<Argument> |
ArgumentRanking.getMinimallyAcceptedArguments(java.util.Collection<Argument> args)
Returns the set of all arguments a from the given
set that are minimally accepted, i.e.
|
java.util.Iterator<Argument> |
Extension.iterator() |
java.util.Set<Argument> |
Labeling.keySet() |
java.util.Set<Argument> |
NumericalArgumentRanking.keySet() |
java.util.Set<Argument> |
StratifiedLabeling.keySet() |
Modifier and Type | Method and Description |
---|---|
boolean |
Extension.add(Argument arg0) |
int |
ArgumentRanking.compare(Argument arg0,
Argument arg1) |
boolean |
AbstractArgumentationInterpretation.isAcceptable(Argument argument,
DungTheory dungTheory)
returns true if every attacker on is attacked by some
accepted argument wrt.
|
boolean |
ArgumentRanking.isEquallyAcceptableThan(Argument a,
Argument b)
Returns "true" iff a is equally acceptable as b or a and b are not comparable,
i.e.
|
boolean |
ArgumentRanking.isStrictlyLessAcceptableThan(Argument a,
Argument b)
Returns "true" iff a is strictly less acceptable than b, i.e.
|
boolean |
NumericalArgumentRanking.isStrictlyLessOrEquallyAcceptableThan(Argument a,
Argument b) |
abstract boolean |
ArgumentRanking.isStrictlyLessOrEquallyAcceptableThan(Argument a,
Argument b)
Returns "true" iff a is strictly less acceptable than b or a is equally
acceptable as b or a and b are not comparable, i.e.
|
boolean |
LatticeArgumentRanking.isStrictlyLessOrEquallyAcceptableThan(Argument a,
Argument b) |
boolean |
ArgumentRanking.isStrictlyMoreAcceptableThan(Argument a,
Argument b)
Returns "true" iff a is strictly more acceptable than b, i.e.
|
boolean |
ArgumentRanking.isStrictlyMoreOrEquallyAcceptableThan(Argument a,
Argument b)
Returns "true" iff a is strictly more acceptable than b or a is equally
acceptable as b or a and b are not comparable, i.e.
|
ArgumentStatus |
Labeling.put(Argument arg0,
ArgumentStatus arg1) |
java.lang.Double |
NumericalArgumentRanking.put(Argument arg0,
java.lang.Double arg1) |
java.lang.Integer |
StratifiedLabeling.put(Argument arg0,
java.lang.Integer arg1) |
boolean |
StratifiedLabeling.satisfies(Argument formula) |
boolean |
AbstractArgumentationInterpretation.satisfies(Argument formula) |
void |
LatticeArgumentRanking.setStrictlyLessOrEquallyAcceptableThan(Argument a,
Argument b)
Defines "a" to be strictly less or equally acceptable than "b".
|
Modifier and Type | Method and Description |
---|---|
boolean |
Extension.addAll(java.util.Collection<? extends Argument> arg0) |
java.util.Collection<Argument> |
ArgumentRanking.getMaximallyAcceptedArguments(java.util.Collection<Argument> args)
Returns the set of all arguments a from the given
set that are maximally accepted, i.e.
|
java.util.Collection<Argument> |
ArgumentRanking.getMinimallyAcceptedArguments(java.util.Collection<Argument> args)
Returns the set of all arguments a from the given
set that are minimally accepted, i.e.
|
boolean |
ArgumentRanking.isEquivalent(ArgumentRanking other,
java.util.Collection<Argument> args)
Checks whether this ranking is equivalent to the other one wrt.
|
void |
Labeling.putAll(java.util.Map<? extends Argument,? extends ArgumentStatus> arg0) |
void |
NumericalArgumentRanking.putAll(java.util.Map<? extends Argument,? extends java.lang.Double> arg0) |
void |
StratifiedLabeling.putAll(java.util.Map<? extends Argument,? extends java.lang.Integer> arg0) |
Constructor and Description |
---|
Extension(java.util.Collection<? extends Argument> arguments)
Creates a new extension with the given set of arguments.
|
LatticeArgumentRanking(java.util.Collection<Argument> args)
Creates a new argument ranking with the given arguments which
are initially all incomparable.
|
NumericalArgumentRanking(java.util.Collection<Argument> args,
double initialvalue)
Creates a new argument ranking.
|
Modifier and Type | Field and Description |
---|---|
private static java.util.Map<DungTheory,java.util.Collection<Graph<Argument>>> |
DungTheory.archivedSubgraphs
For archiving sub graphs
|
private java.util.Map<Argument,java.util.Set<Argument>> |
DungTheory.children |
private java.util.Map<Argument,java.util.Set<Argument>> |
DungTheory.children |
private java.util.Map<Argument,java.util.Set<Argument>> |
DungTheory.parents
explicit listing of direct attackers and attackees (for efficiency reasons)
|
private java.util.Map<Argument,java.util.Set<Argument>> |
DungTheory.parents
explicit listing of direct attackers and attackees (for efficiency reasons)
|
Modifier and Type | Method and Description |
---|---|
Argument |
Attack.getAttacked()
returns the attacked argument of this attack relation.
|
Argument |
Attack.getAttacker()
returns the attacking argument of this attack relation.
|
Modifier and Type | Method and Description |
---|---|
java.util.Set<Argument> |
DungTheory.getAttacked(Argument argument)
Computes the set {A | (argument,A) in attacks}.
|
java.util.Set<Argument> |
DungTheory.getAttackers(Argument argument)
Computes the set {A | (A,argument) in attacks}.
|
java.util.Collection<Argument> |
DungTheory.getChildren(Node node) |
Edge<Argument> |
DungTheory.getEdge(Argument a,
Argument b) |
java.util.Collection<? extends Edge<? extends Argument>> |
DungTheory.getEdges() |
java.util.Collection<Argument> |
DungTheory.getNeighbors(Argument node) |
java.util.Collection<Argument> |
DungTheory.getNodes() |
java.util.Collection<Argument> |
DungTheory.getParents(Node node) |
Graph<Argument> |
DungTheory.getRestriction(java.util.Collection<Argument> arguments) |
java.util.Collection<java.util.Collection<Argument>> |
DungTheory.getStronglyConnectedComponents() |
java.util.Collection<Graph<Argument>> |
DungTheory.getSubgraphs() |
Modifier and Type | Method and Description |
---|---|
boolean |
DungTheory.addAttack(Argument attacker,
Argument attacked)
Adds an attack from the first argument to the second to thisDdung theory.
|
boolean |
DungTheory.areAdjacent(Argument a,
Argument b) |
boolean |
Attack.contains(Argument argument)
Return true if the given argument is in this attack relation.
|
boolean |
DungTheory.existsDirectedPath(Argument node1,
Argument node2) |
java.util.Set<Argument> |
DungTheory.getAttacked(Argument argument)
Computes the set {A | (argument,A) in attacks}.
|
java.util.Set<Argument> |
DungTheory.getAttackers(Argument argument)
Computes the set {A | (A,argument) in attacks}.
|
Edge<Argument> |
DungTheory.getEdge(Argument a,
Argument b) |
java.util.Collection<Argument> |
DungTheory.getNeighbors(Argument node) |
boolean |
DungTheory.isAttacked(Argument argument,
Extension ext)
returns true if some argument of attacks argument.
|
boolean |
DungTheory.isAttackedBy(Argument arg1,
Argument arg2)
Checks whether arg1 is attacked by arg2.
|
boolean |
DungTheory.isAttackedBy(Argument argument,
java.util.Collection<Argument> ext)
returns true if some argument of is attacked by argument.
|
boolean |
DungTheory.isIndirectAttack(Argument arg1,
Argument arg2)
Checks whether "arg1" indirectly attacks "arg2", i.e.
|
private boolean |
DungTheory.isIndirectAttack(Argument arg1,
Argument arg2,
java.util.Set<Argument> visited)
Checks whether "arg1" indirectly attacks "arg2", i.e.
|
boolean |
DungTheory.isSupport(Argument arg1,
Argument arg2)
Checks whether "arg1" supports "arg2", i.e.
|
private boolean |
DungTheory.isSupport(Argument arg1,
Argument arg2,
java.util.Set<Argument> visited)
Checks whether "arg1" supports "arg2", i.e.
|
boolean |
DungTheory.remove(Argument a)
Removes the argument and all its attacks
|
Modifier and Type | Method and Description |
---|---|
boolean |
DungTheory.add(Edge<Argument> edge) |
private boolean |
DungTheory.dfs(int i,
java.util.List<Argument> arguments,
boolean[] dfn,
boolean[] inProgress)
Depth-First-Search to find a cycle in the theory.
|
Graph<Argument> |
DungTheory.getRestriction(java.util.Collection<Argument> arguments) |
boolean |
DungTheory.isAttackedBy(Argument argument,
java.util.Collection<Argument> ext)
returns true if some argument of is attacked by argument.
|
boolean |
Attack.isConflictFree(java.util.Collection<? extends Argument> arguments)
returns true if one arguments in attacks another within this attack relation.
|
private boolean |
DungTheory.isIndirectAttack(Argument arg1,
Argument arg2,
java.util.Set<Argument> visited)
Checks whether "arg1" indirectly attacks "arg2", i.e.
|
private boolean |
DungTheory.isSupport(Argument arg1,
Argument arg2,
java.util.Set<Argument> visited)
Checks whether "arg1" supports "arg2", i.e.
|
Constructor and 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 and Description |
---|
DungSignature(java.util.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.
|
Modifier and Type | Field and Description |
---|---|
private java.util.Set<Argument> |
EnumeratingDungTheoryGenerator.arguments
The current set of arguments.
|
Modifier and Type | Method and Description |
---|---|
private DungTheory |
DefaultDungTheoryGenerator.generateTreeShape(Argument arg)
Generates a Dung theory with a tree shape where the given argument
is the root.
|
DungTheory |
DungTheoryGenerator.next(Argument arg)
Generates a new Dung theory where the given argument
is enforced to be in the grounded extension
|
DungTheory |
PodlaszewskiCaminadaDungTheoryGenerator.next(Argument arg) |
DungTheory |
FileDungTheoryGenerator.next(Argument arg) |
DungTheory |
EnumeratingDungTheoryGenerator.next(Argument arg) |
DungTheory |
IsoSafeEnumeratingDungTheoryGenerator.next(Argument arg) |
DungTheory |
DefaultDungTheoryGenerator.next(Argument arg) |
Modifier and Type | Method and Description |
---|---|
private java.util.List<Attack> |
EnumeratingDungTheoryGenerator.generatePossibleAttacks(java.util.Set<Argument> arguments)
Computes all possible attacks.
|
Modifier and Type | Method and Description |
---|---|
static java.lang.String |
AbstractDungWriter.writeArguments(java.util.Collection<Argument> args)
Writes the given collection of arguments into a string of the form
[arg1,...,argn].
|
Modifier and Type | Method and Description |
---|---|
protected void |
AbstractPAChangeOperator.prepareOptimizationProblem(PartialProbabilityAssignment ppa,
DungTheory theory,
OptimizationProblem problem,
java.util.Map<java.util.Collection<Argument>,FloatVariable> varsComp,
java.util.Map<java.util.Collection<Argument>,FloatVariable> varsSem,
java.util.Vector<Term> varsCompVector,
java.util.Vector<Term> varsSemVector) |
protected void |
AbstractPAChangeOperator.prepareOptimizationProblem(PartialProbabilityAssignment ppa,
DungTheory theory,
OptimizationProblem problem,
java.util.Map<java.util.Collection<Argument>,FloatVariable> varsComp,
java.util.Map<java.util.Collection<Argument>,FloatVariable> varsSem,
java.util.Vector<Term> varsCompVector,
java.util.Vector<Term> varsSemVector) |
Modifier and Type | Method and 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.
|
Modifier and Type | Method and Description |
---|---|
java.lang.Double |
AbstractPafReasoner.query(ProbabilisticArgumentationFramework beliefbase,
Argument formula) |
java.lang.Double |
MonteCarloPafReasoner.query(ProbabilisticArgumentationFramework beliefbase,
Argument formula,
int inferencetype) |
java.lang.Double |
NaivePafReasoner.query(ProbabilisticArgumentationFramework beliefbase,
Argument formula,
int inferencetype) |
abstract java.lang.Double |
AbstractPafReasoner.query(ProbabilisticArgumentationFramework beliefbase,
Argument formula,
int inferencetype)
Queries the given PAF for the given argument using the given
inference type.
|
Modifier and Type | Method and Description |
---|---|
Probability |
ProbabilisticExtension.probability(Argument a)
Computes the probability of the given argument.
|
protected Term |
AbstractPASemantics.probabilityTerm(Argument arg,
java.util.Map<java.util.Collection<Argument>,FloatVariable> worlds2vars)
Constructs the term expressing the probability of the given argument
wrt.
|
Modifier and Type | Method and Description |
---|---|
java.util.Collection<Statement> |
NeutralPASemantics.getSatisfactionStatements(DungTheory theory,
java.util.Map<java.util.Collection<Argument>,FloatVariable> worlds2vars) |
java.util.Collection<Statement> |
FoundedPASemantics.getSatisfactionStatements(DungTheory theory,
java.util.Map<java.util.Collection<Argument>,FloatVariable> worlds2vars) |
java.util.Collection<Statement> |
CoherentPASemantics.getSatisfactionStatements(DungTheory theory,
java.util.Map<java.util.Collection<Argument>,FloatVariable> worlds2vars) |
java.util.Collection<Statement> |
JustifiablePASemantics.getSatisfactionStatements(DungTheory theory,
java.util.Map<java.util.Collection<Argument>,FloatVariable> worlds2vars) |
java.util.Collection<Statement> |
RationalPASemantics.getSatisfactionStatements(DungTheory theory,
java.util.Map<java.util.Collection<Argument>,FloatVariable> worlds2vars) |
java.util.Collection<Statement> |
InvolutaryPASemantics.getSatisfactionStatements(DungTheory theory,
java.util.Map<java.util.Collection<Argument>,FloatVariable> worlds2vars) |
java.util.Collection<Statement> |
SemiFoundedPASemantics.getSatisfactionStatements(DungTheory theory,
java.util.Map<java.util.Collection<Argument>,FloatVariable> worlds2vars) |
java.util.Collection<Statement> |
OptimisticPASemantics.getSatisfactionStatements(DungTheory theory,
java.util.Map<java.util.Collection<Argument>,FloatVariable> worlds2vars) |
java.util.Collection<Statement> |
SemiOptimisticPASemantics.getSatisfactionStatements(DungTheory theory,
java.util.Map<java.util.Collection<Argument>,FloatVariable> worlds2vars) |
abstract java.util.Collection<Statement> |
AbstractPASemantics.getSatisfactionStatements(DungTheory theory,
java.util.Map<java.util.Collection<Argument>,FloatVariable> worlds2vars) |
java.util.Collection<Statement> |
PASemantics.getSatisfactionStatements(DungTheory theory,
java.util.Map<java.util.Collection<Argument>,FloatVariable> worlds2vars)
Returns the mathematical statement corresponding to the satisfaction
of the given theory wrt.
|
protected Term |
AbstractPASemantics.probabilityTerm(Argument arg,
java.util.Map<java.util.Collection<Argument>,FloatVariable> worlds2vars)
Constructs the term expressing the probability of the given argument
wrt.
|
Modifier and Type | Field and Description |
---|---|
private java.util.Map<Argument,Probability> |
ProbabilisticArgumentationFramework.argumentProbabilityAssignment
Probability assignments to arguments (with independence assumption).
|
Modifier and Type | Method and 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 and Description |
---|
ProbabilisticArgumentationFramework(Graph<Argument> graph)
Creates a new PAF from the given graph, all arguments
and attacks have probability 1.
|
Modifier and Type | Class and 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.
|
Modifier and Type | Method and Description |
---|---|
boolean |
StructuredArgumentationFramework.isAttackedBy(Argument arg1,
Argument arg2) |
Modifier and Type | Method and Description |
---|---|
java.lang.Double |
IssReasoner.query(SocialAbstractArgumentationFramework beliefbase,
Argument formula) |
Modifier and Type | Method and Description |
---|---|
private double |
IssReasoner.dist(SocialMapping<java.lang.Double> sm1,
SocialMapping<java.lang.Double> sm2,
java.util.Collection<Argument> args)
Returns the maximum-norm distance between the two social
mappings
|
Modifier and Type | Field and Description |
---|---|
private java.util.Map<Argument,L> |
SocialMapping.map
Maps arguments to their values
|
Modifier and Type | Method and 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) |
Modifier and Type | Field and Description |
---|---|
private java.util.Map<Argument,java.lang.Integer> |
SocialAbstractArgumentationFramework.neg_votes
The number of negative votes of arguments
|
private java.util.Map<Argument,java.lang.Integer> |
SocialAbstractArgumentationFramework.pos_votes
The number of positive votes of arguments
|
Modifier and Type | Method and 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 and Description |
---|
SocialAbstractArgumentationFramework(Graph<Argument> graph)
Creates a new social abstract argumentation framework from the given graph.
|