Prolog modules
Every predicate of the modules of arg2p, from their sources. A module is called as module::Goal, or
module:::Goal to run the goal in a new context branch (see Modules).
In the signatures, +Arg is an input, bound when called, -Arg an output, ?Arg either of the two.
Entry points
The predicates a theory is queried with, and what they rely on.
| Module | Predicates | Description |
|---|---|---|
| arg2p | 11 | 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 |
| utils | 17 | Utilities on lists and on the labels of the context (module utils), most of them native primitives |
| debug | 4 | The output of the labellings (module debug): printed by buildLabelSets/0, and written when the debug switch is on |
| interpreter | 5 | 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 |
| module | 1 | 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 |
Data
The terms arg2p works on: the entities of argumentation graphs and of the rules.
| Module | Predicates | Description |
|---|---|---|
| argument | 15 | The term of an argument (module argument), read and built through it rather than by the positions of its parts |
| attack | 5 | The term of an attack (module attack): attack(Type, Attacker, Attacked, On), Attacker attacking Attacked on its sub-argument On (Attacked itself for a direct attack), with an attack of Type (rebut, undermine, undercut, …) |
| support | 3 | The term of a support (module support): support(Supporter, Supported), Supporter being a sub-argument of Supported |
| label | 4 | The terms of the labels (module label): an argument labelled IN, OUT or UND is in(Argument), out(Argument) or und(Argument), by its identifier inId(Id), outId(Id) or undId(Id) (the native labellings), and a statement statIn(Statement), statOut(Statement) or statUnd(Statement) |
| statementTerm | 1 | The term of a statement (module statementTerm, as statement is the statement labelling of that name): [Claim], the list of the term claimed, as the conclusions of the arguments and the statements labelled are written |
| rule | 3 | The terms of the rules and premises of a theory as the parser converts them (module rule): a clause rl(Conclusion) :- [Id, Premises, Conclusion] for a rule, Premises a conjunction, and rl(Conclusion) :- [Id, Conclusion] for a premise, kept in the context by their conclusion |
Language
The rules of a theory, as the graph builders read them.
| Module | Predicates | Description |
|---|---|---|
| parser | 23 | The rules of a theory, read by the graph builders (module parser): convertAllRules/1 converts the rules, premises, preferences and burdens of the theory, which classicRule/2,3 and the other predicates read |
| transposition | 1 | The transpositions of the strict rules (module transposition), with autoTransposition: for a strict rule r : a, b -> c, the rules concluding a contradictory of each premise from a contradictory of the conclusion and the other premises (r_i : -c, b -> -a, r_ii : -c, a -> -b) |
| conflict | 5 | The conflicts between statements (module conflict) |
| aspicLanguage | 3 | The language of ASPIC+ (module aspicLanguage, a graphLanguage of the profiles aspic_plus and aspic): the one of arg2p, well formed (Modgil and Prakken 2013) |
| abaLanguage | 3 | The language of assumption-based argumentation (module abaLanguage, a graphLanguage of the profile aba), mapped to the one of arg2p as flat ABA is an instance of ASPIC+ (Prakken 2010): each assumption (assumption(A)) an ordinary premise asm(A), each contrary (contrary(A, C)) the conflict of C with A, one way (an argument for C attacks those resting on A) |
| defeasibleLanguage | 3 | The defeasible part of the language of ASPIC+ (module defeasibleLanguage, a graphLanguage of the profile aspic_defeasible): defeasible rules alone, facts as rules with no premise (r : [] => a.) |
| abstractLanguage | 4 | The language of Dung frameworks (module abstractLanguage, the graphLanguage of the profile abstract): arguments and attacks alone, which the module abstractGraph reads |
Graph
Building the argumentation graph: its arguments and attacks, and where they are kept.
| Module | Predicates | Description |
|---|---|---|
| ruleGraph | 4 | 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 | 5 | 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 |
| argumentBuilder | 1 | 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) |
| attackBuilder | 1 | 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 | 7 | 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 |
| attackCandidates | 6 | 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 |
| graphStore | 49 | 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) |
Graph extensions
Changing the argumentation graph: preferences, restrictions, burdens.
| Module | Predicates | Description |
|---|---|---|
| conflictArguments | 3 | The arguments attacking through a conflict argument (module conflictArguments), with metaConflicts: conflicts are then conclusions of the theory, and an argument attacks through the conflicts its conclusion has with others only while their arguments stand |
| superiority | 4 | When an argument is superior to another one (module superiority), by the preferences between their rules (sup(Rule, Other) in the context) |
| rebutRestriction | 1 | The restricted rebut (module rebutRestriction, a graphExtension): a rebut only succeeds on an argument whose top rule is defeasible |
| bp | 3 | The burdens of proof as part of the graph (module bp, a graphExtension): for an argument for bp(Statement) and an argument for Statement, the burdened one, an argument for -burdmet(Conclusion) (top rule artificial) is attacked as the burden of proof is, and rebuts or is rebutted by the burdened argument, depending on whether the grounded labelling labels it IN |
| defeasiblePref | 9 | The preferences between rules as conclusions of the theory (module defeasiblePref, a graphExtension): an argument for sup(Rule, Other) makes the attacks that preference invalidates fail, as long as it stands |
| defeasibleAllPref | 3 | The preferences between rules as conclusions of the theory, taken together (module defeasibleAllPref, a graphExtension): as defeasiblePref, but the attack argument is attacked by an argument for all the preferences invalidating it, preference(Preferences), supported by the arguments for each of them |
| standardPref | 1 | The preferences between the rules of the theory, applied to the attacks (module standardPref, a graphExtension): an attack fails when the attacked argument is superior to the attacker (see the module superiority) |
| abaPref | 4 | The preferences between the assumptions of ABA+ (module abaPref, a graphExtension, of the profile aba_plus; Čyras and Toni 2016): sup(Stronger, Weaker), closed transitively |
Evaluation
Evaluating the graph: abstract frameworks, the whole graph of a theory, or the part a query depends on.
| Module | Predicates | Description |
|---|---|---|
| abstract | 2 | The labelling of abstract argumentation frameworks (module abstract): arguments and attacks given as they are, labelled by the semantics of argumentLabellingMode |
| structuredWhole | 8 | 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) |
| structuredPartial | 6 | 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 |
| queryExploration | 9 | 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) |
| argumentSearch | 1 | 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) |
Labelling
The semantics labelling the arguments, and the statements from them.
| Module | Predicates | Description |
|---|---|---|
| grounded | 3 | The grounded labelling (module grounded, an argumentLabellingMode, the default one): the least fixpoint of IN the arguments whose attackers are all OUT and OUT those attacked by an IN one, computed natively (groundedFixpoint) |
| complete | 2 | The complete labellings (module complete, an argumentLabellingMode): the admissible ones labelling IN every argument they defend, built one strongly connected component at a time (see the module scc) |
| preferred | 2 | The preferred labellings (module preferred, an argumentLabellingMode): the admissible ones with a maximal set of IN arguments, built one strongly connected component at a time (see the module scc) |
| semistable | 2 | The semi-stable labellings (module semistable, an argumentLabellingMode): the preferred ones with a minimal set of UND arguments |
| stable | 2 | The stable labellings (module stable, an argumentLabellingMode): those leaving no argument UND, built one strongly connected component at a time (see the module scc) |
| ideal | 2 | The ideal labelling (module ideal, an argumentLabellingMode): the maximal admissible subset of the arguments IN in every preferred labelling |
| eager | 2 | The eager labelling (module eager, an argumentLabellingMode): the maximal admissible subset of the arguments IN in every semi-stable labelling |
| naive | 3 | The naive labellings (module naive, an argumentLabellingMode): the conflict-free ones with a maximal set of IN arguments |
| stage | 2 | The stage labellings (module stage, an argumentLabellingMode): the naive ones with a minimal set of UND arguments |
| cf2 | 3 | The cf2 labellings (module cf2, an argumentLabellingMode): the naive labellings of each strongly connected component, the components taken in turn once the arguments attacked by the previous ones are suppressed |
| stage2 | 2 | The stage2 labellings (module stage2, an argumentLabellingMode): as cf2, with the stage labellings in each strongly connected component |
| conflictfree | 6 | The conflict-free labellings (module conflictfree, an argumentLabellingMode): a set of arguments IN, none attacking another one, those they attack OUT and the rest UND |
| admissible | 5 | The admissible labellings (module admissible, an argumentLabellingMode): the conflict-free ones in which every attacker of an IN argument is attacked by an IN argument |
| stronglyadmissible | 3 | The strongly admissible labellings (module stronglyadmissible, an argumentLabellingMode): the admissible ones whose IN arguments are defended, step by step, starting from the unattacked ones |
| scc | 3 | Support module of the SCC-recursive semantics (complete, preferred, stable): their labellings are built one strongly connected component at a time, the semantics only choosing which local labellings to keep |
| bp_grounded | 9 | The grounded labelling with burdens of persuasion (module bp_grounded, an argumentLabellingMode, ICAIL): as the grounded one, but an argument for a statement under a burden of persuasion that is not IN is OUT rather than UND |
| bp_grounded_partial | 3 | The partial labelling with burdens of persuasion (module bp_grounded_partial, an argumentLabellingMode, ICLP): each argument labelled IN*, OUT* or UND* by the conditions of the burdens on its conclusion and its complement |
| bp_grounded_complete | 2 | The complete labelling with burdens of persuasion (module bp_grounded_complete, an argumentLabellingMode, ICLP): the partial labelling, then the grounded labelling of its UND arguments, repeated until nothing changes |
| statement | 1 | The labels of the statements from those of their arguments (module statement, a statementLabellingMode): a statement is IN if an argument for it is IN, otherwise OUT if one is OUT, otherwise UND if one is UND |
| statement_pass_through | 1 | The labels of the statements passed through from those of their arguments (module statement_pass_through, a statementLabellingMode): a statement takes the label of each of its arguments, so it may have several |
| statement_binary | 1 | Two labels for the statements (module statement_binary, a statementLabellingMode): IN if an argument for the statement is IN, OUT otherwise |