Graph on Arg2p Wiki

ruleGraph

Mon, 01 Jan 0001 00:00:00 +0000

ruleGraph

Graph · Kotlin object RuleGraphModule · library prolog.argumentation.graph

The whole argumentation graph of the rules of a theory (module ruleGraph, the graphBuilder of the profiles but abstract, see it.unibo.tuprolog.argumentation.core.runtime.settings.Profiles): every argument its rules make (see the module argumentBuilder), those derived from them (conflictArguments), and the attacks between them (attackBuilder), saved in the context (see the module graphStore).

abstractGraph

Mon, 01 Jan 0001 00:00:00 +0000

abstractGraph

Graph · Kotlin object AbstractGraphModule · library prolog.argumentation.graph.abstract

The argumentation graph of an abstract theory (module abstractGraph, the graphBuilder of the profile abstract): the arguments it states, a. or arg(a), and the attacks between them, a -> b. or att(a, b), and a <-> b. for a mutual attack, facts or derived by Prolog clauses (X -> Y :- beats(X, Y).); an argument attacking or attacked is an argument as well. Each is saved as abstract::solve saves them. The module abstractLanguage checks the theory.

argumentBuilder

Mon, 01 Jan 0001 00:00:00 +0000

argumentBuilder

Graph · Kotlin object ArgumentBuilderModule · library prolog.argumentation.graph.arguments

The arguments of a theory (module argumentBuilder): every argument its premises and rules make, built round after round from the conclusions of the previous one, and saved in the context with their supports (see the module graphStore).

Calls: argument, graphStore, parser, utils
Called by: ruleGraph

Predicate	Description
`buildArguments/0`	The arguments made of a premise, those of the rules with no premise to support, and then, round after round, those of the rules using a conclusion of the previous round

buildArguments/0

buildArguments

The arguments made of a premise, those of the rules with no premise to support, and then, round after round, those of the rules using a conclusion of the previous round.

attackBuilder

Mon, 01 Jan 0001 00:00:00 +0000

attackBuilder

Graph · Kotlin object AttackBuilderModule · library prolog.argumentation.graph.attacks

The attacks between the arguments of the graph (module attackBuilder): each argument against those that may attack it (see the module attackCandidates), as the module attackRelation states them, saved in the context (see the module graphStore, which reads them extended to the arguments built on the attacked one).

attackRelation

Mon, 01 Jan 0001 00:00:00 +0000

attackRelation

Graph · Kotlin object AttackRelationModule · library prolog.argumentation.attack

When an argument attacks another one directly (module attackRelation): rebutting or undermining it through a conflict between their conclusions, rebutting or undermining it through a contrary premise, or undercutting its top rule. Whether the attack succeeds is up to the graph extensions (preferences, restrictions).

Calls: argument, conflict, conflictArguments, utils
Called by: attackBuilder, structuredPartial

Predicate	Description
`attacks/3`	Attacker attacks Attacked directly, Type being the first kind of attack that applies
`rebuts/2`	The conclusion of A conflicts with the one of B, a defeasible argument with a top rule
`contraryRebuts/2`	A concludes the contrary of a premise of the top rule of B (~(Claim)), both having a top rule
`undermines/2`	The conclusion of A conflicts with B, a defeasible premise (or its copy for a conflict, see the module conflictArguments)
`contraryUndermines/2`	A, a premise, is the contrary of a premise of the top rule of B (~(Claim))
`undercuts/2`	A concludes undercut(Rule), or a statement conflicting with [Rule], Rule being the defeasible top rule of B
`conflictsWith/2`	The conclusion of Argument conflicts with Statement: only through its own conflict for the copy of an argument made for a conflict argument (see the module conflictArguments), through any conflict otherwise

attacks/3

attacks(?Type, +Attacker, +Attacked)

Attacker attacks Attacked directly, Type being the first kind of attack that applies.

attackCandidates

Mon, 01 Jan 0001 00:00:00 +0000

attackCandidates

Graph · Kotlin object AttackCandidatesModule · library prolog.argumentation.attack.candidates

The statements whose arguments may attack an argument, or be attacked by it (module attackCandidates): the graph builders only check the attacks (see the module attackRelation) between an argument and the arguments for these statements, and query mode explores them.

Calls: argument, conflict, parser
Called by: attackBuilder, structuredPartial, queryExploration

Predicate	Description
`possibleAttackers/3`	findPossibleAttackers/2 for the argument with identifier Id, looked for once: query mode looks for them to build the graph, and again to build the attacks
`forgetPossibleAttackers/0`	The possible attackers looked for forgotten: with arguments for conflicts built since (metaConflicts), they may be more
`findPossibleAttackers/2`	The arguments for Statement may attack Argument: Statement conflicts with its conclusion or its top rule, it is the contrary of a premise of its top rule, or it undercuts its top rule
`possiblyAttacked/2`	Argument may attack the arguments for Statement (the converse of findPossibleAttackers/2): those in conflict with its conclusion, the conclusions of the rules it undercuts and of the rules with its conclusion as a contrary premise
`attackDependency/2`	With metaConflicts the conflicts are themselves conclusions: Argument depends on the arguments for Statement, which make others conflict with it
`attackDependant/2`	With metaConflicts, the arguments for Statement depend on Argument: those its conclusion makes conflict with others, and, for an argument for a conflict, those it makes conflict

possibleAttackers/3

possibleAttackers(+Id, +Argument, -Statement)

findPossibleAttackers/2 for the argument with identifier Id, looked for once: query mode looks for them to build the graph, and again to build the attacks.

graphStore

Mon, 01 Jan 0001 00:00:00 +0000

graphStore

Graph · Kotlin object GraphStoreModule · library prolog.argumentation.graph.store

The argumentation graph kept in the active context, and its labels (module graphStore): the only module reading and writing them in the context; the terms are those of the data modules (argument, support, attack, label, statement).

Besides the graph itself (argument/1, support/2, attack/4 terms), the context keeps: