Language on Arg2p Wiki

parser

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

parser

Language · Kotlin object ParserModule · library prolog.argumentation.parser

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.

Calls: rule, transposition, utils
Called by: arg2p, transposition, aspicLanguage, abaLanguage, defeasibleLanguage, argumentBuilder, attackCandidates, defeasiblePref, structuredWhole, queryExploration, argumentSearch
Flags: autoTransposition, prologStrictCompatibility, metaConflicts, metaRules, graphLanguage (see Flags)

Predicate	Description
`convertAllRules/1`	The rules, premises, preferences and burdens of the theory, in the formats the graph builders read (rl/1 clauses, strict/1, sup/2, abstractBp/1), asserted; Rules are what was asserted
`supClosure/2`	The preferences stated, closed transitively: the ordering of rules and premises is a strict partial order (no sup(X, X) is added, should the stated ones make a cycle)
`languagePremises/1`	The ordinary premises the languages of the theory state (graphLanguage), as [Id, Statement]
`languageConflicts/1`	The conflicts the languages of the theory state (graphLanguage), as conflict(Statement, Other)
`checkLanguages/0`	The theory is written in each of its languages (graphLanguage): each checks it, raising an error if not
`rule/3`	The rule Id as converted (see convertAllRules/1), concluding Conclusion from Premises
`candidates/3`	The number of rules and premises concluding Statement, counted up to Limit (an integer, or anything else for no limit)
`checkStrict/1`	The rule or premise Id is strict
`prolog/2`	Premise, as [prolog(Goal)], is a Prolog check
`argued/1`	Premise, of a rule, is supported by an argument: neither a Prolog check nor a contrary
`contrary/2`	Premise, as [~(Statement)], is a contrary premise
`tupleToList/2`	The items of a conjunction, as a list (built with an accumulator rather than appending the lists of the two sides, which took a module call at every step)
`classicRule/3`	The rule Id concludes Conclusion ([Statement]) from Premises (a list); with metaRules, applicable(Id) is its first premise
`classicRule/2`	The premise Id concludes Conclusion ([Statement])
`ruleUsing/2`	A rule concludes Conclusion (a statement) from Premise, among others: classicRule/3 and member/2 over its premises, through an index of the premises of the rules built once in the active context
`prologStrictRules/1`	The Prolog clauses of the theory (Head :- Body) with no identifier (see `RuleAnnotations`) as strict rules, `[Id, Body, Head]`, with prologStrictCompatibility on (none otherwise)
`prologAxioms/1`	The Prolog facts of the theory with no identifier (see `RuleAnnotations`) as axioms, `[Id, Fact]`, with prologStrictCompatibility on (none otherwise)
`bpsNew/1`	The burdens of persuasion of the theory, its `bp(...)` facts, as `abstractBp([...])` terms
`prologPremises/1`	The Prolog facts of the theory with an identifier (see `RuleAnnotations`) as defeasible premises, `[Id, Fact]`, with prologStrictCompatibility on (none otherwise)
`prologDefeasibleRules/1`	The Prolog clauses of the theory (Head :- Body) with an identifier (see `RuleAnnotations`) as defeasible rules, `[Id, Body, Head]`, with prologStrictCompatibility on (none otherwise)
`extractId/2`	`strict(Id)` for the identifier of each of Rules (lists starting with it)
`ruleToClause/2`	The rules and premises of the parser (`[Id, Body, Head]`, `[Id, Head]`) as the clauses of the module rule
`ruleToClauseNatural/2`	As ruleToClause/2, with naturalTerms: the statements written as text are turned into terms, the words in upper case and in brackets becoming their arguments

convertAllRules/1

convertAllRules(-Rules)

The rules, premises, preferences and burdens of the theory, in the formats the graph builders read (rl/1 clauses, strict/1, sup/2, abstractBp/1), asserted; Rules are what was asserted.

transposition

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

transposition

Language · Kotlin object TranspositionModule · library prolog.argumentation.language.transposition

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). The contradictories of a statement are its negation, and the statements the theory declares in conflict with it both ways, with no guard (conflict([c], [d]) and conflict([d], [c])): the transpositions through those are named transposed(Id, [ConclusionContradictory, PremiseContradictory]), Id the name of the one through negations.

conflict

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

conflict

Language · Kotlin object ConflictModule · library prolog.argumentation.language.conflict

The conflicts between statements (module conflict). Without metaConflicts they are the built-in ones (a literal and its negation, and those between obligations and permissions) and those the theory declares (conflict/2,3); with metaConflicts they are only those concluded by an argument for conflict(A, B) or conflict(A, B, Guard).

aspicLanguage

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

aspicLanguage

Language · Kotlin object AspicLanguageModule · library prolog.argumentation.language.aspic

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). A contrary, a conflict declared one way only (conflict(X, Y) with no conflict(Y, X)), targets defeasible statements alone: neither an axiom nor the conclusion of a strict rule, which no attack could reach. The contradictories (negations, conflicts declared both ways) are those transposition closes the strict rules over.

abaLanguage

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

abaLanguage

Language · Kotlin object AbaLanguageModule · library prolog.argumentation.language.aba

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). Rules are the strict rules of arg2p.

defeasibleLanguage

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

defeasibleLanguage

Language · Kotlin object DefeasibleLanguageModule · library prolog.argumentation.language.defeasible

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.). It adds no premise nor conflict; it checks the theory has no strict rule, axiom nor premise.

abstractLanguage

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

abstractLanguage

Language · Kotlin object AbstractLanguageModule · library prolog.argumentation.language.abstract

The language of Dung frameworks (module abstractLanguage, the graphLanguage of the profile abstract): arguments and attacks alone, which the module abstractGraph reads. It adds no premise nor conflict; it checks the theory has none of the notations of the structured profiles, which an abstract framework would drop.