Entry points on Arg2p Wiki

arg2p

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

arg2p

Entry points · Kotlin object Arg2pModule · library prolog.argumentation.interface

The entry points of arg2p (module arg2p, loaded by every solver): the labels of the statements of the theory, of the whole graph or of a query.

Calls: debug, graphStore, parser, structuredPartial, structuredWhole

Predicate	Description
`argTuProlog/0`	The solver is an arg2p one
`solve/0`	The labelling of the theory, in the context (buildLabelSets/0, without printing it)
`solve/1`	answerQuery/1
`solve/2`	answerQuery/2
`buildLabelSets/2`	The statements and the arguments of the theory labelled IN, OUT and UND, as [In, Out, Und] lists
`buildLabelSets/3`	The statements of the theory labelled IN, OUT and UND
`buildLabelSets/0`	The labelling of the theory, printed: the graph, the labels of the arguments and those of the statements
`answerQuery/4`	The statements unifying with Goal labelled IN, OUT and UND: with queryMode only the part of the graph they depend on is built
`answerQuery/2`	The labels of the statements unifying with Goal, as in(S), out(S) and und(S) terms
`answerQuery/1`	Goal is a statement labelled IN
`buildLabelSetsSilent/0`	The labelling of the theory, in the context

argTuProlog/0

argTuProlog

The solver is an arg2p one.

utils

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

utils

Entry points · Kotlin object UtilsModule · library prolog.argumentation.utils

Utilities on lists and on the labels of the context (module utils), most of them native primitives.

Called by: debug, parser, transposition, abstractGraph, argumentBuilder, attackRelation, graphStore, superiority, bp, defeasibleAllPref, abaPref, abstract, structuredPartial, queryExploration, semistable, ideal, eager, stage, cf2, scc, bp_grounded, bp_grounded_partial, bp_grounded_complete

Predicate	Description
`writeList/1`	The items of List written one after the other, then a new line
`writeListNl/1`	The items of List written each on a line
`appendFast/3`	List is List1 followed by List2, in one step
`appendLists/2`	Result is the concatenation of the lists in Lists
`assertAll/1`	Each of Clauses asserted in the context
`forEach/3`	Goal (all its solutions) for each element of List, as findall(_, (member(Element, List), Goal), _), but without List in the goals of the iterations: with variable tracking, every resolution step visits the terms of the goal it belongs to, so the list would make every step as costly as it is long
`contains/2`	An element of List matches Element (without binding it)
`containsAny/2`	An element of List matches one of Elements (without binding them)
`sort/2`	Reverse standard order of terms, duplicates kept (as the former quicksort)
`deduplicate/2`	Standard order of terms, duplicates removed (as setof/3)
`sortDistinct/2`	Reverse standard order of terms, duplicates removed (deduplicate/2, then sort/2)
`minimalBySet/2`	The values of the Set-Value pairs whose Set has no strict subset among the others (elements compared as ground terms), in order: minimal_set/2 over a whole collection in one step
`uniqueByFirst/2`	Lists keeping, among the lists with the same first element, only the last one (in their order)
`intersection/2`	The elements of the first list in Sets that are in all of them, in its order (elements compared as ground terms); fails if Sets is empty
`subtract/3`	The elements of List not in Removed, in order (elements compared as ground terms), without the recursion of a Prolog subtract (whose frames would all keep the rest of the list)
`sccs/1`	Strongly connected components of the attack graph, as lists of argument identifiers, in topological order (a component is only attacked by itself and by the components before it)
`sccs/2`	Strongly connected components of the subgraph of the arguments in Ids, as lists of argument identifiers, in topological order

writeList/1

writeList(+List)

The items of List written one after the other, then a new line.

debug

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

debug

Entry points · Kotlin object DebugModule · library prolog.argumentation.debug

The output of the labellings (module debug): printed by buildLabelSets/0, and written when the debug switch is on.

Calls: argument, utils
Called by: arg2p, bp_grounded_partial
Flags: debug (see Flags)

Predicate	Description
`printArgumentationGraph/3`	The graph printed, its arguments part by part
`printArgumentLabelling/1`	The arguments of [In, Out, Und] printed by label
`printStatementLabelling/1`	The statements of [In, Out, Und] printed by label
`writeDebug/1`	The debug output is written with the debug switch on (setting(debug))

printArgumentationGraph/3

printArgumentationGraph(+Arguments, +Attacks, +Supports)

The graph printed, its arguments part by part.

interpreter

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

interpreter

Entry points · Kotlin object InterpreterModule · library prolog.argumentation.meta.crossjustice

A meta-interpreter tracing the facts a proof relies on (module interpreter), written for the CrossJustice project: the facts of the user, user_fact(Fact), a goal is proved with.

Predicate	Description
`with_facts_and_length/3`	Goal is proved, Facts being the facts of the user its proof relies on (user_fact(Fact)), and Length their number
`recover_facts/2`	Facts are the facts of the user in Proof, as solve/2 gives it
`solve/2`	Goal is proved, Proof being the goals its proof goes through, nested as the clauses used
`is_list/1`	Term is a list
`fetch_argument_facts/2`	Facts are the facts of the user supporting the argument for Conclusion, from argument/1 and support/2 facts on arguments written as [Rules, TopRule, Conclusion]

with_facts_and_length/3

with_facts_and_length(+Goal, -Facts, -Length)

Goal is proved, Facts being the facts of the user its proof relies on (user_fact(Fact)), and Length their number.

module

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

module

Entry points · Kotlin object ModuleCallsModule · library prolog.argumentation.modularity

Goals solved on the theories of external modules (module module): Prolog files, found in the modules path (flag modulesPath) by their name, or at a location.

Flags: modulesPath (see Flags)

Predicate	Description
`call_module/2`	Goal solved on the theories of Modules alone, loaded in their order

call_module/2

call_module(+Modules, +Goal)

Native primitive.