Evaluation on Arg2p Wiki

abstract

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

abstract

Evaluation · Kotlin object AbstractModule · library prolog.argumentation.abstract

The labelling of abstract argumentation frameworks (module abstract): arguments and attacks given as they are, labelled by the semantics of argumentLabellingMode.

Calls: argument, graphStore, structuredWhole, utils
Called by: abstractGraph
Flags: argumentLabellingMode (see Flags)

Predicate	Description
`solve/5`	The labelling of the abstract framework of Arguments (atoms) and Attacks ((A, B) pairs), by argumentLabellingMode: the arguments IN, OUT and UND
`solve/2`	The labelling of the abstract framework of Arguments and Attacks, in the context

solve/5

solve(+Arguments, +Attacks, -In, -Out, -Und)

The labelling of the abstract framework of Arguments (atoms) and Attacks ((A, B) pairs), by argumentLabellingMode: the arguments IN, OUT and UND.

structuredWhole

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

structuredWhole

Evaluation · Kotlin object StructuredWholeModule · library prolog.argumentation.structured.whole

The whole argumentation graph of a theory and its labellings, as the flags select them (module structuredWhole): the graph builder (graphBuildMode), the graph extensions (graphExtension), the semantics (argumentLabellingMode) and the statement labelling (statementLabellingMode). Query mode builds only a part of the graph (see the module structuredPartial), then changes and labels it through this module as well.

structuredPartial

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

structuredPartial

Evaluation · Kotlin object StructuredPartialModule · library prolog.argumentation.structured.partial

Query mode (module structuredPartial): the labels of the statements for a goal, computed on the part of the argumentation graph they depend on (see the modules queryExploration and argumentSearch), or on the whole graph.

Calls: attackCandidates, attackRelation, graphStore, queryExploration, structuredWhole, utils
Called by: arg2p
Flags: queryMode (see Flags)

Predicate	Description
`computeStatementAcceptance/2`	The labels of the statements for Goal: in(S), out(S) and und(S) terms
`computeStatementAcceptance/4`	The statements for Goal labelled IN, OUT and UND
`computeStatementAcceptance/1`	The labels of the statements for Goal, in the context: with queryMode only the part of the graph they depend on is built, otherwise the whole graph
`locality/1`	The part of the graph the labels of the arguments for the query depend on, as the semantics declares it (locality/1): the arguments they depend on (directional), those connected to them in either direction (connected), or the whole graph (whole_graph, also for a semantics that does not declare it)
`buildArgument/3`	Argument is each argument for Query, saved with those its label may depend on, and SubArguments are its sub-arguments: the solvers that do not know its rules look for their attackers as well
`findAttacker/6`	Attacker attacks Target, directly or on one of its SubArguments, and the attacks are saved; each attacker is given once, with its own sub-arguments

computeStatementAcceptance/2

computeStatementAcceptance(+Goal, -Result)

The labels of the statements for Goal: in(S), out(S) and und(S) terms.

queryExploration

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

queryExploration

Evaluation · Kotlin object QueryExplorationModule · library prolog.argumentation.structured.exploration

The part of the argumentation graph a query depends on (module queryExploration, for query mode): the arguments for the query, and, recursively, those their labels may depend on, saved as they are built (see the module argumentSearch).

Calls: argument, argumentSearch, attackCandidates, graphStore, parser, utils
Called by: structuredPartial, argumentSearch

Predicate	Description
`explore/1`	The arguments for Query and those their labels may depend on (see exploreStatement/2)
`resume/1`	The exploration carried on once arguments for Statements are saved: the statements explored whose rules use them as premises, directly or through other statements, explored again, the others left as they are
`restart/0`	The exploration forgotten, not the arguments it built: exploring again finds all that the arguments saved since support or make possible attackers (with metaConflicts, those for conflicts)
`explored/1`	Statement is explored (with the statements it generalises)
`premiseOfExplored/1`	Premise is one of the premises, to be supported by an argument, of a rule concluding a statement explored, and the statement makes it ground
`exploreAll/1`	Each of Queries explored (see explore/1)
`buildSubGraph/2`	Argument is each argument for Query, a premise, once explored
`expand/1`	For the connected locality, the arguments whose labels may depend on the ones built (see dependant/2), with those they depend on in turn, until none is new
`groundVars/2`	Term with each of its variables replaced by an atom of its own (`$var_0`, …): a term (with none of these atoms) unifies with Grounded if and only if it generalises Term

explore/1

explore(+Query)

The arguments for Query and those their labels may depend on (see exploreStatement/2). With cycles among the rules, a statement needed as a premise while its arguments are being built only gets those built so far: the exploration is then repeated, from scratch, until it builds no new argument (the arguments are finitely many, as none uses a rule twice).

argumentSearch

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

argumentSearch

Evaluation · Kotlin object ArgumentSearchModule · library prolog.argumentation.structured.search

The arguments for a statement, built on demand (module argumentSearch, for query mode): from a premise, or from a rule whose premises are supported in turn by the arguments for them (explored through the module queryExploration, which saves them).

An argument is the same term as the graph builder makes (see the module argumentBuilder): its rules and info from those of its sub-arguments (argument::rulesAndInfo/5), its body the premises of its rule as written. Its parts are collected in found(Body, TopRule, Rules, Info, Supports), built in the clause bodies, so that clause heads only match the conclusion or the premises (matching many arguments against every clause head is what makes resolution expensive).