@tuprolog/arg2p-core 0.6.1 → 0.6.2

package/kotlin/arg2p-core.js

@@ -3147,7 +3147,7 @@
     return 'prologStrictCompatibility';
   };
   PrologStrictCompatibility.prototype.default = function () {
-    return true;
+    return false;
   };
   PrologStrictCompatibility.prototype.values = function () {
     return Unit;
@@ -4681,7 +4681,7 @@
   }
   function ArgumentationGraph() {
     ArgumentationGraph_instance = this;
-    this.theoryCode = trimIndent('\n    buildArgumentationGraph :-\n        buildArguments,\n        buildAttacks.\n    buildArguments :-\n    \tbuildArgumentsFromPremises,\n    \tfindall([RuleID, RuleBody, RuleHead], context_check(rule([RuleID, RuleBody, RuleHead])), Rules),\n    \tbuildArgumentsFromRules(Rules, Rules, n).\n    buildArgumentsFromPremises :-\n        findall(\n            _,\n            (\n                context_check(premise([PremiseID, Premise])),\n                checkStrict(PremiseID, DefPrem),\n                ground(Premise),\n                context_assert(argument([[PremiseID], none, Premise, [], [[], [], DefPrem]]))\n            ),\n            _\n        ).\n    buildArgumentsFromRules(Rules, [], n).\n    buildArgumentsFromRules(Rules, [], y) :- buildArgumentsFromRules(Rules, Rules, n).\n    buildArgumentsFromRules(Rules, [H|T], _) :-\n        copy_term(H, HH),\n        buildArgumentsFromRule(HH),\n        buildArgumentsFromRules(Rules, T, y), !.\n    buildArgumentsFromRules(Rules, [_|T], X) :-\n        buildArgumentsFromRules(Rules, T, X).\n    buildArgumentsFromRule([RuleID, RuleBody, RuleHead]) :-\n    \truleBodyIsSupported(RuleBody, [], [], SupportRules, ArgSupports),\n    \t\\+ member(RuleID, SupportRules),\n    \tground(RuleHead),\n    \tutils::sort([RuleID|SupportRules], SortedPremises),\n    \t\\+ context_check(argument([SortedPremises, RuleID, RuleHead, RuleBody, _])),\n    \tbuildArgumentInfo(ArgSupports, RuleID, Info),\n        NewArgument = [SortedPremises, RuleID, RuleHead, RuleBody, Info],\n    \tcontext_assert(argument(NewArgument)),\n    \tsupports(NewArgument, ArgSupports).\n    supports(Argument, Supports) :-\n        findall(_, (\n            member(S, Supports),\n            context_assert(support(S, Argument))\n        ), _).\n    checkStrict(Id, [Id]) :- \\+ context_check(strict(Id)).\n    checkStrict(Id, []) :- context_check(strict(Id)).\n    buildArgumentInfo(Supports, RuleId, [LastDefRules, DefRules, DefPrem]) :-\n        defeasibleRules(RuleId, Supports, DefRules),\n        ordinaryPremises(Supports, DefPrem),\n        lastDefeasibleRules(Supports, RuleId, LastDefRules).\n    ordinaryPremises(Supports, DefPrem) :-\n        findall(Def, member([_, _, _, _, [_, _, Def]], Supports), Prem),\n        utils::appendLists(Prem, TempPrem),\n        utils::sortDistinct(TempPrem, DefPrem).\n    defeasibleRules(RuleId, Supports, DefRules) :-\n    \tfindall(Def, member([_, _, _, _, [_, Def, _]], Supports), UnsortedRules),\n    \tcheckStrict(RuleId, DefRule),\n    \tutils::appendLists([DefRule|UnsortedRules], TempRules),\n    \tutils::sortDistinct(TempRules, DefRules).\n    lastDefeasibleRules(_, TopRule, [TopRule]) :-\n        TopRule \\== none, \\+ context_check(strict(TopRule)).\n    lastDefeasibleRules(Supports, TopRule, LastRules) :-\n    \tcontext_check(strict(TopRule)),\n    \tfindall(Def, member([_, _, _, _, [Def, _, _]], Supports), Res),\n    \tutils::appendLists(Res, TempLastRules),\n    \tutils::sortDistinct(TempLastRules, LastRules).\n    ruleBodyIsSupported([], ResultPremises, ResultSupports, ResultPremises, ResultSupports).\n    ruleBodyIsSupported([ [unless, _] | Others], Premises, Supports, ResultPremises, ResultSupports) :-\n    \truleBodyIsSupported(Others, Premises, Supports, ResultPremises, ResultSupports).\n    ruleBodyIsSupported([ [prolog(Check)] | Others], Premises, Supports, ResultPremises, ResultSupports) :-\n    \t(callable(Check) -> call(Check); Check),\n    \truleBodyIsSupported(Others, Premises, Supports, ResultPremises, ResultSupports).\n    ruleBodyIsSupported([Statement|Others], Premises, Supports, ResultPremises, ResultSupports) :-\n        context_check(argument([ArgumentID, RuleID, Statement, Body, Info])),\n    \tappend(ArgumentID, Premises, NewPremises),\n    \truleBodyIsSupported(Others, NewPremises, [[ArgumentID, RuleID, Statement, Body, Info]|Supports], ResultPremises, ResultSupports).\n    buildAttacks :-\n        findall(X, context_check(argument(X)), Args),\n    \tbuildDirectAttacks(Args),\n    \tbuildTransitiveAttacks.\n    buildDirectAttacks([]).\n    buildDirectAttacks([H|T]) :-\n        findall(_, buildDirectAttack(H), _),\n        buildDirectAttacks(T).\n    buildDirectAttack(A) :-\n    \tcontext_check(argument(B)),\n    \tA \\== B,\n        attacks(T, A, B),\n    \t\\+ context_check(attack(T, A, B, B)),\n    \tcontext_assert(attack(T, A, B, B)).\n    buildTransitiveAttacks :-\n    \tcontext_check(attack(T, A, B, D)),\n    \tcontext_check(support(B, C)),\n    \t\\+ context_check(attack(T, A, C, D)), !,\n    \tcontext_assert(attack(T, A, C, D)),\n        buildTransitiveAttacks.\n    buildTransitiveAttacks.\n    attacks(rebut, A, B) :- rebuts(A, B), !.\n    attacks(contrary_rebut, A, B) :- contraryRebuts(A, B), !.\n    attacks(undermine, A, B) :- undermines(A, B), !.\n    attacks(contrary_undermine, A, B) :- contraryUndermines(A, B), !.\n    attacks(undercut, A, B) :- undercuts(A, B), !.\n    rebuts([IDPremisesA, RuleA, RuleHeadA, _, _], [IDPremisesB, RuleB, RuleHeadB, _, Info]) :-\n    \tRuleB \\== none,\n        Info \\== [[], [], []],\n    \tconflict(RuleHeadA, RuleHeadB).\n    contraryRebuts([IDPremisesA, RuleA, RuleHeadA, _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n    \tRuleA \\== none,\n    \tRuleB \\== none,\n    \tmember([unless, RuleHeadA], Body).\n    undermines([IDPremisesA, RuleA, RuleHeadA, _, _], [[IDPremiseB], none, RuleHeadB, _, Info]) :-\n    \tInfo \\== [[], [], []],\n    \tconflict(RuleHeadA, RuleHeadB).\n    contraryUndermines([IDPremisesA, none, RuleHeadA, _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n    \tRuleB \\== none,\n    \tmember([unless, RuleHeadA], Body).\n    undercuts([_, _, [undercut(RuleB)], _, _], [_, RuleB, _, _, [[RuleB], _, _]]).\n    conflict( [Atom], [neg, Atom]).\n    conflict( [neg, Atom], [Atom]).\n    conflict( [obl, [Atom]],  [obl, [neg, Atom]]).\n    conflict( [obl, [neg, Atom]],  [obl, [Atom]]).\n    conflict( [obl, Lit],  [neg, obl, Lit]).\n    conflict( [neg, obl, Lit],  [obl, Lit]).\n    conflict( [perm, [Atom]],  [obl, [neg, Atom]]).\n    conflict( [obl, [neg, Atom]],  [perm, [Atom]]).\n    conflict( [perm, [neg, Atom]],  [obl, [Atom]]).\n    conflict( [obl, [Atom]],  [perm, [neg, Atom]]).\n    conflict([bp, Atom], [neg, bp, Atom]).\n    conflict([neg, bp, Atom], [bp, Atom]).\n    conflict([sup(X, Y)],  [sup(Y, X)]).\n        ');
+    this.theoryCode = trimIndent('\n    buildArgumentationGraph :-\n        buildArguments,\n        buildAttacks.\n    buildArguments :-\n    \tbuildArgumentsFromPremises,\n    \tbuildArgumentsFromEmptyRules,\n    \tfindall([RuleID, RuleBody, RuleHead], (\n    \t    context_check(rule([RuleID, RuleBody, RuleHead])),\n    \t    \\+ emptyRule([RuleID, RuleBody, RuleHead])\n        ), Rules),\n    \tbuildArgumentsFromRules(Rules, Rules, n).\n    buildArgumentsFromPremises :-\n        findall(\n            _,\n            (\n                context_check(premise([PremiseID, Premise])),\n                checkStrict(PremiseID, DefPrem),\n                ground(Premise),\n                context_assert(argument([[PremiseID], none, Premise, [], [[], [], DefPrem]]))\n            ),\n            _\n        ).\n    buildArgumentsFromEmptyRules :-\n        findall(\n            _,\n            (\n                emptyRule([RuleID, RulePrem, RuleHead]),\n                checkStrict(RuleID, DefRule),\n                ground(RuleHead),\n                context_assert(argument([[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]]))\n            ),\n            _\n        ).\n    emptyRule([RuleID, [], RuleHead]) :-\n        context_check(rule([RuleID, [], RuleHead])).\n    emptyRule([RuleID, [[unless, X]], RuleHead]) :-\n        context_check(rule([RuleID, [[unless, X]], RuleHead])).\n    emptyRule([RuleID, [[prolog(Check)]], RuleHead]) :-\n        context_check(rule([RuleID, [[prolog(Check)]], RuleHead])),\n        (callable(Check) -> call(Check); Check).\n    buildArgumentsFromRules(Rules, [], n).\n    buildArgumentsFromRules(Rules, [], y) :- buildArgumentsFromRules(Rules, Rules, n).\n    buildArgumentsFromRules(Rules, [H|T], _) :-\n        copy_term(H, HH),\n        buildArgumentsFromRule(HH),\n        buildArgumentsFromRules(Rules, T, y), !.\n    buildArgumentsFromRules(Rules, [_|T], X) :-\n        buildArgumentsFromRules(Rules, T, X).\n    buildArgumentsFromRule([RuleID, RuleBody, RuleHead]) :-\n    \truleBodyIsSupported(RuleBody, [], [], SupportRules, ArgSupports),\n    \t\\+ member(RuleID, SupportRules),\n    \tground(RuleHead),\n    \tutils::sort([RuleID|SupportRules], SortedPremises),\n    \t\\+ context_check(argument([SortedPremises, RuleID, RuleHead, RuleBody, _])),\n    \tbuildArgumentInfo(ArgSupports, RuleID, Info),\n        NewArgument = [SortedPremises, RuleID, RuleHead, RuleBody, Info],\n    \tcontext_assert(argument(NewArgument)),\n    \tsupports(NewArgument, ArgSupports).\n    supports(Argument, Supports) :-\n        findall(_, (\n            member(S, Supports),\n            context_assert(support(S, Argument))\n        ), _).\n    checkStrict(Id, [Id]) :- \\+ context_check(strict(Id)).\n    checkStrict(Id, []) :- context_check(strict(Id)).\n    buildArgumentInfo(Supports, RuleId, [LastDefRules, DefRules, DefPrem]) :-\n        defeasibleRules(RuleId, Supports, DefRules),\n        ordinaryPremises(Supports, DefPrem),\n        lastDefeasibleRules(Supports, RuleId, LastDefRules).\n    ordinaryPremises(Supports, DefPrem) :-\n        findall(Def, member([_, _, _, _, [_, _, Def]], Supports), Prem),\n        utils::appendLists(Prem, TempPrem),\n        utils::sortDistinct(TempPrem, DefPrem).\n    defeasibleRules(RuleId, Supports, DefRules) :-\n    \tfindall(Def, member([_, _, _, _, [_, Def, _]], Supports), UnsortedRules),\n    \tcheckStrict(RuleId, DefRule),\n    \tutils::appendLists([DefRule|UnsortedRules], TempRules),\n    \tutils::sortDistinct(TempRules, DefRules).\n    lastDefeasibleRules(_, TopRule, [TopRule]) :-\n        TopRule \\== none, \\+ context_check(strict(TopRule)).\n    lastDefeasibleRules(Supports, TopRule, LastRules) :-\n    \tcontext_check(strict(TopRule)),\n    \tfindall(Def, member([_, _, _, _, [Def, _, _]], Supports), Res),\n    \tutils::appendLists(Res, TempLastRules),\n    \tutils::sortDistinct(TempLastRules, LastRules).\n    ruleBodyIsSupported([], ResultPremises, ResultSupports, ResultPremises, ResultSupports).\n    ruleBodyIsSupported([ [unless, _] | Others], Premises, Supports, ResultPremises, ResultSupports) :-\n    \truleBodyIsSupported(Others, Premises, Supports, ResultPremises, ResultSupports).\n    ruleBodyIsSupported([ [prolog(Check)] | Others], Premises, Supports, ResultPremises, ResultSupports) :-\n    \t(callable(Check) -> call(Check); Check),\n    \truleBodyIsSupported(Others, Premises, Supports, ResultPremises, ResultSupports).\n    ruleBodyIsSupported([Statement|Others], Premises, Supports, ResultPremises, ResultSupports) :-\n        context_check(argument([ArgumentID, RuleID, Statement, Body, Info])),\n    \tappend(ArgumentID, Premises, NewPremises),\n    \truleBodyIsSupported(Others, NewPremises, [[ArgumentID, RuleID, Statement, Body, Info]|Supports], ResultPremises, ResultSupports).\n    findPossibleAttackers([_, _, Head, _, _], [_, _, Conf, _, _]) :-\n        conflict(Head, Conf).\n    findPossibleAttackers([_, _, _, Prem, _], [_, _, Conf, _, _]) :-\n        member([unless, Conf], Prem).\n    findPossibleAttackers([_, RuleID, _, _, _], [_, _, [undercut(RuleID)], _, _]).\n    buildAttacks :-\n        findall(X, context_check(argument(X)), Args),\n    \tbuildDirectAttacks(Args),\n    \tbuildTransitiveAttacks.\n    buildDirectAttacks([]).\n    buildDirectAttacks([H|T]) :-\n        findall(_, buildDirectAttack(H), _),\n        buildDirectAttacks(T).\n    buildDirectAttack(A) :-\n    \tcontext_check(argument(B)),\n    \tA \\== B,\n        attacks(T, B, A),\n    \t\\+ context_check(attack(T, B, A, A)),\n    \tcontext_assert(attack(T, B, A, A)).\n    buildTransitiveAttacks :-\n    \tcontext_check(attack(T, A, B, D)),\n    \tcontext_check(support(B, C)),\n    \t\\+ context_check(attack(T, A, C, D)), !,\n    \tcontext_assert(attack(T, A, C, D)),\n        buildTransitiveAttacks.\n    buildTransitiveAttacks.\n    attacks(rebut, A, B) :- rebuts(A, B), !.\n    attacks(contrary_rebut, A, B) :- contraryRebuts(A, B), !.\n    attacks(undermine, A, B) :- undermines(A, B), !.\n    attacks(contrary_undermine, A, B) :- contraryUndermines(A, B), !.\n    attacks(undercut, A, B) :- undercuts(A, B), !.\n    rebuts([IDPremisesA, RuleA, RuleHeadA, _, _], [IDPremisesB, RuleB, RuleHeadB, _, Info]) :-\n    \tRuleB \\== none,\n        Info \\== [[], [], []],\n    \tconflict(RuleHeadA, RuleHeadB).\n    contraryRebuts([IDPremisesA, RuleA, RuleHeadA, _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n    \tRuleA \\== none,\n    \tRuleB \\== none,\n    \tmember([unless, RuleHeadA], Body).\n    undermines([IDPremisesA, RuleA, RuleHeadA, _, _], [[IDPremiseB], none, RuleHeadB, _, Info]) :-\n    \tInfo \\== [[], [], []],\n    \tconflict(RuleHeadA, RuleHeadB).\n    contraryUndermines([IDPremisesA, none, RuleHeadA, _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n    \tRuleB \\== none,\n    \tmember([unless, RuleHeadA], Body).\n    undercuts([_, _, [undercut(RuleB)], _, _], [_, RuleB, _, _, [[RuleB], _, _]]).\n    conflict( [Atom], [neg, Atom]).\n    conflict( [neg, Atom], [Atom]).\n    conflict( [obl, [Atom]],  [obl, [neg, Atom]]).\n    conflict( [obl, [neg, Atom]],  [obl, [Atom]]).\n    conflict( [obl, Lit],  [neg, obl, Lit]).\n    conflict( [neg, obl, Lit],  [obl, Lit]).\n    conflict( [perm, [Atom]],  [obl, [neg, Atom]]).\n    conflict( [obl, [neg, Atom]],  [perm, [Atom]]).\n    conflict( [perm, [neg, Atom]],  [obl, [Atom]]).\n    conflict( [obl, [Atom]],  [perm, [neg, Atom]]).\n    conflict([bp, Atom], [neg, bp, Atom]).\n    conflict([neg, bp, Atom], [bp, Atom]).\n    conflict([sup(X, Y)],  [sup(Y, X)]).\n        ');
   }
   ArgumentationGraph.$metadata$ = {
     kind: Kind_OBJECT,
@@ -4861,7 +4861,7 @@
   }
   function QueryMode_0() {
     QueryMode_instance_0 = this;
-    this.theoryCode = trimIndent('\n    computeStatementAcceptance(Goal, YesResult, NoResult, UndResult) :-\n        \\+ queryMode,\n        abstract:::computeGlobalAcceptance,\n        mineResults(Goal, YesResult, NoResult, UndResult).\n    computeStatementAcceptance(Goal, YesResult, NoResult, UndResult) :-\n        queryMode,\n        argumentLabellingMode(grounded),\n        parser::check_modifiers_in_list(effects, [Goal], [X]),\n        findall(_, query(X, _), _),\n        (ambiguityBlocking ->\n            statement_binary:::statementLabelling;\n            statementLabellingMode(Y),\n            Y:::statementLabelling\n        ),\n        mineResults(Goal, YesResult, NoResult, UndResult).\n    mineResults(Goal, YesResult, NoResult, UndResult) :-\n        parser::check_modifiers_in_list(effects, [Goal], [X]),\n        findall(Goal, context_check(statIn(X)), In),\n        findall(Goal, context_check(statOut(X)), Out),\n        findall(Goal, context_check(statUnd(X)), Und),\n        utils::sort(In, YesResult),\n        utils::sort(Out, NoResult),\n        utils::sort(Und, UndResult).\n    query(Query, Res) :-\n        buildArgument(Query, Argument),\n        once(defend(Argument, [], Res)).\n    query(Query, und) :- \\+ buildArgument(Query, _).\n    defend(Argument, _, no) :- context_check(out(Argument)).\n    defend(Argument, _, und) :- context_check(und(Argument)).\n    defend(Argument, _, yes) :- context_check(in(Argument)).\n    defend(Argument, QueryChain, no) :-\n        findAttacker(Argument, QueryChain, Attacker, yes),\n        once(defend(Attacker, [Argument|QueryChain], X)),\n        X == yes,\n        bufferResult(Argument, no), !.\n    defend(Argument, QueryChain, Res) :-\n        findAttacker(Argument, QueryChain, Attacker, yes),\n        once(defend(Attacker, [Argument|QueryChain], X)),\n        X == und,\n        ambiguityCheck(Argument, Attacker, Res),\n        bufferResult(Argument, Res), !.\n    complementary([_, _, ConclusionA, _, _], [_, _, ConclusionB, _, _]) :-\n        standard_af::conflict(ConclusionA, ConclusionB).\n    ambiguityCheck(A, B, no) :- ambiguityBlocking,\n        \\+ complementary(A, B),\n        context_check(attack(direct, B, A, _)), !.\n    ambiguityCheck(_, _, und).\n    defend(Argument, QueryChain, und) :-\n        findAttacker(Argument, QueryChain, Attacker, no),\n        bufferResult(Argument, und), !.\n    defend(Argument, QueryChain, yes) :- bufferResult(Argument, yes).\n    bufferResult(Argument, no) :- \\+ context_check(out(Argument)), context_assert(out(Argument)), !.\n    bufferResult(Argument, yes) :- \\+ context_check(in(Argument)), context_assert(in(Argument)), !.\n    bufferResult(Argument, und) :- \\+ context_check(und(Argument)), context_assert(und(Argument)), !.\n    bufferResult(_, _).\n    findAttacker(Target, QueryChain, Attacker, IsValid) :-\n        attacker(Target, Attacker, Type),\n        bufferAttacker(Attacker, Target, Type),\n        detectCycle(Attacker, QueryChain, IsValid).\n    bufferAttacker(Attacker, Target, Type) :-\n        \\+ context_check(attack(Type, Attacker, Target, none)),\n        context_assert(attack(Type, Attacker, Target, none)), !.\n    bufferAttacker(_, _, _).\n    detectCycle(Attacker, QueryChain, yes) :- \\+ member(Attacker, QueryChain).\n    detectCycle(Attacker, QueryChain, no) :- member(Attacker, QueryChain).\n    attacker([Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type) :-\n        member(X, Rules),\n        \\+ context_check(strict(X)),\n        attackerOnRule(X, [Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type).\n    attacker([Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type) :-\n        member(X, Groundings),\n        attackerOnTerm(X, [Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type).\n    attackerOnRule(Rule, _, Argument, undercut) :-\n        buildArgument([undercut(Rule)], Argument).\n    attackerOnTerm(Term, [TargetRules, TopRule, Conclusion, Groundings, ArgInfo], Attacker, direct) :-\n        Term \\= [unless, _],\n        \\+ strict([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]),\n        (graphExtension(rebutRestriction) ->\n            (\n                buildSubArgument(Term, TargetRules, SubArgument),\n                rebutRestriction(SubArgument)\n            );\n            true\n        ),\n        standard_af::conflict(Term, X),\n        buildArgument(X, Attacker),\n        (graphExtension(standardPref) ->\n            (ground(SubArgument) ->\n                true;\n                buildSubArgument(Term, TargetRules, SubArgument)\n            ),\n            \\+ superiorArgument(SubArgument, Attacker);\n            true\n        ).\n    attackerOnTerm([unless, X], _, Attacker, contrary) :-\n        buildArgument(X, Attacker).\n    strict([_, _, _, _, [_, [], []]]).\n    rebutRestriction([TargetRules, none, Conclusion, Groundings, ArgInfo]) :-\n        graphExtension(rebutRestriction).\n    rebutRestriction([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]) :-\n        graphExtension(rebutRestriction),\n        TopRule \\= none,\n        rebutRestriction::restrict([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]).\n    rebutRestriction(_) :- \\+ graphExtension(rebutRestriction).\n    superiorArgument(SubArgument, Attacker) :-\n        superiority::superiorArgument(SubArgument, Attacker).\n    buildSubArgument(Term, Rules, [SubRules, SubTopRule, SubConclusion, SubGrounds, Info]) :-\n        buildArgument(Term, [SubRules, SubTopRule, SubConclusion, SubGrounds, Info]),\n        contained(SubRules, Rules).\n    contained([], _).\n    contained([H|T], Target) :- member(H, Target), contained(T, Target).\n    buildArgument(Query, Argument) :-\n        \\+ context_check(explored(Query)),\n        findall(_, (\n            buildSingleArgument(Query, Argument),\n            context_assert(argument(Argument))\n        ), _),\n        context_assert(explored(Query)),\n        fail.\n    buildArgument(Query, [R, T, Query, B, I]) :- context_check(argument([R, T, Query, B, I])).\n    buildSingleArgument(Query, Argument) :-\n        build(Query, Groundings, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]),\n        utils::deduplicate(DefRules, CDefRules),\n        utils::deduplicate(DefPremises, CDefPremises),\n        utils::deduplicate(Groundings, CGroundings),\n        Argument = [AllRules, TopRule, Query, CGroundings, [LastDefRules, CDefRules, CDefPremises]].\n    build(Conclusion, [Conclusion], Rules) :-\n        context_check(premise([Id, Conclusion])),\n        premiseRules(Id, Rules).\n    build(Conclusion, [Conclusion|Conclusions], Rules) :-\n        context_check(rule([Id, Premises, Conclusion])),\n        buildPremises(Premises, Conclusions, ResRules),\n        ruleRules(Id, ResRules, Rules).\n    build([prolog(Check)], [], []) :- (callable(Check) -> call(Check); Check).\n    build([unless, Atom], [[unless, Atom]], []).\n    buildPremises([], [], [[], [], [], []]).\n    buildPremises([H|T], Conclusions, Rules) :-\n        build(H, HConclusions, HRules),\n        buildPremises(T, TConclusions, TRules),\n        utils::appendLists([HConclusions, TConclusions], Conclusions),\n        mergeRules(HRules, TRules, Rules).\n    premiseRules(Id, [[Id], none, [], [], [Id]]) :- \\+ context_check(strict(Id)).\n    premiseRules(Id, [[Id], none, [], [], []]) :- context_check(strict(Id)).\n    ruleRules(Id, [AllRules, _, DefRules, DefPremises], \n        [[Id|AllRules], Id, [Id], [Id|DefRules], DefPremises]) :- \\+ context_check(strict(Id)).\n    ruleRules(Id, [AllRules, LastDefRules, DefRules, DefPremises], \n        [[Id|AllRules], Id, LastDefRules, DefRules, DefPremises]) :- context_check(strict(Id)).\n    mergeRules([], [AllRules, LastDefRules, DefRules, DefPremises], [AllRules, LastDefRules, DefRules, DefPremises]).\n    mergeRules([HAR, _, HLDR, HDR, HDP], [TAR, TLDR, TDR, TDP], [AR, LDR, DR, DP]) :-\n       utils::appendLists([HAR, TAR], AR),\n       utils::appendLists([HLDR, TLDR], LDR),\n       utils::appendLists([HDR, TDR], DR),\n       utils::appendLists([HDP, TDP], DP).\n        ');
+    this.theoryCode = trimIndent('\n    computeStatementAcceptance(Goal, YesResult, NoResult, UndResult) :-\n        \\+ queryMode,\n        abstract:::computeGlobalAcceptance,\n        mineResults(Goal, YesResult, NoResult, UndResult).\n    computeStatementAcceptance(Goal, YesResult, NoResult, UndResult) :-\n        queryMode,\n        argumentLabellingMode(grounded),\n        parser::check_modifiers_in_list(effects, [Goal], [X]),\n        findall(_, query(X, _), _),\n        (ambiguityBlocking ->\n            statement_binary:::statementLabelling;\n            statementLabellingMode(Y),\n            Y:::statementLabelling\n        ),\n        mineResults(Goal, YesResult, NoResult, UndResult).\n    mineResults(Goal, YesResult, NoResult, UndResult) :-\n        parser::check_modifiers_in_list(effects, [Goal], [X]),\n        findall(Goal, context_check(statIn(X)), In),\n        findall(Goal, context_check(statOut(X)), Out),\n        findall(Goal, context_check(statUnd(X)), Und),\n        utils::sort(In, YesResult),\n        utils::sort(Out, NoResult),\n        utils::sort(Und, UndResult).\n    query(Query, Res) :-\n        buildArgument(Query, Argument),\n        once(defend(Argument, [], Res)).\n    query(Query, und) :- \\+ buildArgument(Query, _).\n    defend(Argument, _, no) :- context_check(out(Argument)).\n    defend(Argument, _, und) :- context_check(und(Argument)).\n    defend(Argument, _, yes) :- context_check(in(Argument)).\n    defend(Argument, QueryChain, no) :-\n        findAttacker(Argument, QueryChain, Attacker, yes),\n        once(defend(Attacker, [Argument|QueryChain], X)),\n        X == yes,\n        bufferResult(Argument, no), !.\n    defend(Argument, QueryChain, Res) :-\n        findAttacker(Argument, QueryChain, Attacker, yes),\n        once(defend(Attacker, [Argument|QueryChain], X)),\n        X == und,\n        ambiguityCheck(Argument, Attacker, Res),\n        bufferResult(Argument, Res), !.\n    complementary([_, _, ConclusionA, _, _], [_, _, ConclusionB, _, _]) :-\n        standard_af::conflict(ConclusionA, ConclusionB).\n    ambiguityCheck(A, B, no) :- ambiguityBlocking,\n        \\+ complementary(A, B),\n        context_check(attack(direct, B, A, _)), !.\n    ambiguityCheck(_, _, und).\n    defend(Argument, QueryChain, und) :-\n        findAttacker(Argument, QueryChain, Attacker, no),\n        bufferResult(Argument, und), !.\n    defend(Argument, QueryChain, yes) :- bufferResult(Argument, yes).\n    bufferResult(Argument, no) :- \\+ context_check(out(Argument)), context_assert(out(Argument)), !.\n    bufferResult(Argument, yes) :- \\+ context_check(in(Argument)), context_assert(in(Argument)), !.\n    bufferResult(Argument, und) :- \\+ context_check(und(Argument)), context_assert(und(Argument)), !.\n    bufferResult(_, _).\n    findAttacker(Target, QueryChain, Attacker, IsValid) :-\n        attacker(Target, Attacker, Type),\n        bufferAttacker(Attacker, Target, Type),\n        detectCycle(Attacker, QueryChain, IsValid).\n    bufferAttacker(Attacker, Target, Type) :-\n        \\+ context_check(attack(Type, Attacker, Target, none)),\n        context_assert(attack(Type, Attacker, Target, none)), !.\n    bufferAttacker(_, _, _).\n    detectCycle(Attacker, QueryChain, yes) :- \\+ member(Attacker, QueryChain).\n    detectCycle(Attacker, QueryChain, no) :- member(Attacker, QueryChain).\n    attacker([Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type) :-\n        member(X, Rules),\n        \\+ context_check(strict(X)),\n        attackerOnRule(X, [Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type).\n    attacker([Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type) :-\n        member(X, Groundings),\n        attackerOnTerm(X, [Rules, TopRule, Conclusion, Groundings, ArgInfo], Argument, Type).\n    attackerOnRule(Rule, _, Argument, undercut) :-\n        buildArgument([undercut(Rule)], Argument).\n    attackerOnTerm(Term, [TargetRules, TopRule, Conclusion, Groundings, ArgInfo], Attacker, direct) :-\n        Term \\= [unless, _],\n        \\+ strict([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]),\n        (graphExtension(rebutRestriction) ->\n            (\n                buildSubArgument(Term, TargetRules, SubArgument),\n                rebutRestriction(SubArgument)\n            );\n            true\n        ),\n        standard_af::conflict(Term, X),\n        buildArgument(X, Attacker),\n        (graphExtension(standardPref) ->\n            (ground(SubArgument) ->\n                true;\n                buildSubArgument(Term, TargetRules, SubArgument)\n            ),\n            \\+ superiorArgument(SubArgument, Attacker);\n            true\n        ).\n    attackerOnTerm([unless, X], _, Attacker, contrary) :-\n        buildArgument(X, Attacker).\n    strict([_, _, _, _, [_, [], []]]).\n    rebutRestriction([TargetRules, none, Conclusion, Groundings, ArgInfo]) :-\n        graphExtension(rebutRestriction).\n    rebutRestriction([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]) :-\n        graphExtension(rebutRestriction),\n        TopRule \\= none,\n        rebutRestriction::restrict([TargetRules, TopRule, Conclusion, Groundings, ArgInfo]).\n    rebutRestriction(_) :- \\+ graphExtension(rebutRestriction).\n    superiorArgument(SubArgument, Attacker) :-\n        superiority::superiorArgument(SubArgument, Attacker).\n    buildSubArgument(Term, Rules, [SubRules, SubTopRule, SubConclusion, SubGrounds, Info]) :-\n        buildArgument(Term, [SubRules, SubTopRule, SubConclusion, SubGrounds, Info]),\n        contained(SubRules, Rules).\n    contained([], _).\n    contained([H|T], Target) :- member(H, Target), contained(T, Target).\n    buildArgument(Query, Argument) :-\n        \\+ context_check(explored(Query)),\n        findall(_, (\n            buildSingleArgument(Query, Argument),\n            context_assert(argument(Argument))\n        ), _),\n        context_assert(explored(Query)),\n        fail.\n    buildArgument(Query, [R, T, Query, B, I]) :- context_check(argument([R, T, Query, B, I])).\n    buildSingleArgument(Query, Argument) :-\n        build(Query, [], Groundings, [AllRules, TopRule, LastDefRules, DefRules, DefPremises]),\n        utils::deduplicate(DefRules, CDefRules),\n        utils::deduplicate(DefPremises, CDefPremises),\n        utils::deduplicate(Groundings, CGroundings),\n        Argument = [AllRules, TopRule, Query, CGroundings, [LastDefRules, CDefRules, CDefPremises]].\n    build(Conclusion, _, [Conclusion], Rules) :-\n        context_check(premise([Id, Conclusion])),\n        premiseRules(Id, Rules).\n    build(Conclusion, Ids, [Conclusion|Conclusions], Rules) :-\n        context_check(rule([Id, Premises, Conclusion])),\n        \\+ member(Id, Ids),\n        buildPremises(Premises, [Id|Ids], Conclusions, ResRules),\n        ruleRules(Id, ResRules, Rules).\n    build([prolog(Check)], _, [], []) :- (callable(Check) -> call(Check); Check).\n    build([unless, Atom], _, [[unless, Atom]], []).\n    buildPremises([], _, [], [[], [], [], []]).\n    buildPremises([H|T], Ids, Conclusions, Rules) :-\n        build(H, Ids, HConclusions, HRules),\n        buildPremises(T, Ids, TConclusions, TRules),\n        utils::appendLists([HConclusions, TConclusions], Conclusions),\n        mergeRules(HRules, TRules, Rules).\n    premiseRules(Id, [[Id], none, [], [], [Id]]) :- \\+ context_check(strict(Id)).\n    premiseRules(Id, [[Id], none, [], [], []]) :- context_check(strict(Id)).\n    ruleRules(Id, [AllRules, _, DefRules, DefPremises], \n        [[Id|AllRules], Id, [Id], [Id|DefRules], DefPremises]) :- \\+ context_check(strict(Id)).\n    ruleRules(Id, [AllRules, LastDefRules, DefRules, DefPremises], \n        [[Id|AllRules], Id, LastDefRules, DefRules, DefPremises]) :- context_check(strict(Id)).\n    mergeRules([], [AllRules, LastDefRules, DefRules, DefPremises], [AllRules, LastDefRules, DefRules, DefPremises]).\n    mergeRules([HAR, _, HLDR, HDR, HDP], [TAR, TLDR, TDR, TDP], [AR, LDR, DR, DP]) :-\n       utils::appendLists([HAR, TAR], AR),\n       utils::appendLists([HLDR, TLDR], LDR),\n       utils::appendLists([HDR, TDR], DR),\n       utils::appendLists([HDP, TDP], DP).\n        ');
   }
   QueryMode_0.$metadata$ = {
     kind: Kind_OBJECT,
@@ -4876,7 +4876,7 @@
   }
   function RuleTranslator() {
     RuleTranslator_instance = this;
-    this.theoryCode = trimIndent("\n    /*\n     *  Main directive. Find all the rules in the theory in the format (Name : Preconditions => Conclusion)\n     *  or (Name : Effects) and then if:\n     *  - It is a standard rule, translate it in the standard format (rule([Name, Preconditions, Conclusions]));\n     *  - It is a bp rule, translate it to (abstractBp([Effects]))\n     *  During the process, clean them from the unallowed symbols (-, o, p).\n     */\n    convertAllRules(ArgRules) :-\n        defeasibleRules(DefeasibleRules),\n        strictRules(StrictRules, RulesIds),\n        ordinaryPremises(Premises),\n        axiomPremises(Axioms, AxiomsIds),\n        specialRules(SpecialRules),\n        utils::appendLists([DefeasibleRules, StrictRules, Premises, Axioms, SpecialRules], L),\n        convertAllRules(L, Rules), !,\n        findall(sup(X, Y), sup(X, Y), Sups),\n        utils::appendLists([Rules, AxiomsIds, RulesIds, Sups], ArgRules),\n        findall(_, (member(X, ArgRules), context_assert(X)), _).\n    defeasibleRules(DefeasibleRules) :-\n        findall([RuleName, Preconditions, Effect], (RuleName : Preconditions => Effect), DefeasibleRulesOld),\n        prologDefeasibleRules(DefeasibleRulesNew),\n        append(DefeasibleRulesOld, DefeasibleRulesNew, DefeasibleRules).\n    strictRules(CtrRules, Ids) :-\n        findall([RuleName, Preconditions, Effect], (RuleName : Preconditions -> Effect), StrictRulesOld),\n        prologStrictRules(StrictRulesNew),\n        append(StrictRulesOld, StrictRulesNew, StrictRules),\n        transpose(StrictRules, StrictRules, CtrRules),\n        findall(strict(RN), member([RN, _, _], CtrRules), Ids).\n    ordinaryPremises(Premises) :-\n        findall([RuleName, Effect], ((RuleName :=> Effect), atom(RuleName)), PremisesOld),\n        prologPremises(PremisesNew),\n        append(PremisesOld, PremisesNew, Premises).\n    axiomPremises(Axioms, Ids) :-\n        findall([RuleName, Effect], ((RuleName :-> Effect), atom(RuleName)), AxiomsOld),\n        prologAxioms(AxiomsNew),\n        append(AxiomsOld, AxiomsNew, Axioms),\n        findall(strict(RN), member([RN, _], Axioms), Ids).\n    specialRules(SpecialRules) :-\n        bpsNew(SpecialRules).\n    transpose(_, CtrRules, CtrRules) :- \\+ autoTransposition. \n    transpose([], CtrRules, CtrRules).\n    transpose([H|T], TempCtrRules, CtrRules) :-\n        transpose(T, TempCtrRules, CR),\n        findall(TrH, transposition(H, TrH), Tran),\n        mergeCtrRules(CR, Tran, CtrRules).\n    mergeCtrRules(All, ToMerge, X) :-\n        append(All, ToMerge, XT),\n        deduplicate(XT, X).\n    deduplicate([], []).\n    deduplicate([[RN,A,B]|T], X) :- deduplicate(T, TT), (member([RN,_,_], TT) -> X = TT; X = [[RN,A,B]|TT]). \n    transposition([Id, Prec, Effect], [Id, Prec, Effect]).\n    transposition([Id, Prec, Effect], [NewId, NewPrec ,XNegated]) :-\n        compound(Prec),\n        tuple_to_list(Prec, LPrec),!,\n        transposition_sequential(LPrec, LPrec, Effect, Id, [], NewPrec, XNegated, NewId).\n    transposition([Id, Prec, Effect], [NewId, EffectNegated ,XNegated]) :-\n        \\+ compound(Prec),\n        Prec \\== [],\n        prologEscape(Prec),\n        negate(Prec, XNegated),\n        negate(Effect, EffectNegated),\n        atom_concat(Id, '_i', NewId).\n    transposition_sequential(LPrec, [H|T], Effect, Id, Skipped, NewPrec, XNegated, NewId) :-\n        transposition_sequential(LPrec, T, Effect, Id, [H|Skipped], NewPrec, XNegated, NewId).\n    transposition_sequential(LPrec, [X|T], Effect, Id, Skipped, NewPrec, XNegated, NewId) :-\n        prologEscape(X),\n        append(Skipped, T, CleanedPrec),\n        negate(X, XNegated),\n        negate(Effect, EffectNegated),\n        list_to_tuple([EffectNegated|CleanedPrec], NewPrec),\n        newIdentifier(Skipped, Id, NewId).\n    newIdentifier(List, OldId, NewId) :-\n        modifier(List, Mod),\n        atom_concat(OldId, Mod, NewId).\n    modifier([], '_i').\n    modifier([_|Tail], Index):-\n        modifier(Tail, Index1),\n        atom_concat(Index1, 'i', Index).\n    negate(X, Arg) :-\n        functor(X, '-', _) -> (\n            arg(1, X, Arg));\n        functor(X, 'p', _) -> (\n            arg(1, X, PX),\n            (functor(PX, '-', _) -> (\n                arg(1, PX, PNX),\n                Arg = o(PNX)\n            );\n            Arg = o(-(PX))));\n        Arg = -(X).\n    prologEscape(X) :- \\+ functor(X, 'prolog', _), \\+ functor(X, '~', _).\n    /*\n     *   Standard rules (RuleName : Preconditions => Effects)\n     *   Special rules (RuleName : Effects)\n     */\n    convertAllRules([], []).\n    convertAllRules([[H,P,E]|T], [R|Rules]) :- convertRule(H, P, E, R), convertAllRules(T, Rules).\n    convertAllRules([[H,E]|T], [R|Rules]) :- convertRule(H, E, R), convertAllRules(T, Rules).\n    /*\n     *   Convert the given rule to the standard format\n     *   Example:\n     *   r2: followedGuidelines(X), doctor(X) => -liable(X)\n     *   rule([r2,[[followedGuidelines(X_e4149)],[doctor(X_e4149)]],[neg,liable(X_e4149)]]).\n     */\n    convertRule(RuleName, Preconditions, Effects, rule(List)) :-\n        tuple_to_list(Preconditions, Lprecond),\n        tuple_to_list(Effects, Leffects),\n        check_modifiers_in_list(preconditions, Lprecond, LprecondChecked),\n        check_modifiers_in_list(effects, Leffects, LeffectsChecked),\n        flatten_first_level(LeffectsChecked, LeffectsCheckedFlattened),\n        List = [RuleName, LprecondChecked, LeffectsCheckedFlattened].\n    /*\n     *   Convert the given special rule\n     *   Example:\n     *   bp(-liable(X)).\n     *   abastractBp([[neg, liable(X_e4149)]]).\n     */\n    convertRule(bps, Effects, abstractBp(Checked)) :-\n        functor(Effects, 'bp', _),\n        Effects =.. L,\n        removehead(L, LC),\n        check_modifiers_in_list(effects, LC, Checked).\n    convertRule(Name, Effects, premise([Name, LeffectsCheckedFlattened])) :-\n        tuple_to_list(Effects, Leffects),\n        check_modifiers_in_list(effects, Leffects, LeffectsChecked),\n        flatten_first_level(LeffectsChecked, LeffectsCheckedFlattened).\n    /*\n     *   Find negations(-), obligations(o), permissions(p) on a list of preconditions/effects and\n     *   raplace them with the assigned literal (neg, obl, perm)\n     */\n    check_modifiers_in_list(MODE, [], []).\n    check_modifiers_in_list(MODE, [H|T], L) :- H == [], L = [].\n    check_modifiers_in_list(MODE, [H|T], L) :- H \\== [],\n                                check_modifiers(H, LH),\n                                check_admissibility(MODE, H, LH),\n                                check_modifiers_in_list(MODE, T, LT),\n                                append([LH], LT, L).\n    check_admissibility(preconditions, H, LH) :-\n        \\+ defeasible_admissible(LH),\n        throw(['Premise  ', H, '  is not a well formed member of the argumentation language.']).\n    check_admissibility(effects, H, LH) :-\n        \\+ admissible(LH),\n        throw(['Conclusion  ', H, '  is not a well formed member of the argumentation language.']).\n    check_admissibility(_, _, _).\n    check_modifiers([], []).\n    check_modifiers(H, List) :-\n        functor(H, '-', _) -> (\n            arg(1, H, Arg),\n            check_modifiers(Arg, Lobl),\n            append([neg], Lobl, Lf),\n            List = Lf);\n        functor(H, 'o', _) -> (\n            arg(1, H, Arg),\n            check_modifiers(Arg, Lobl),\n            List = [obl|[Lobl]]);\n        functor(H, 'p', _) -> (\n            arg(1, H, Arg),\n            check_modifiers(Arg, Lper),\n            List = [perm|[Lper]]);\n        functor(H, '~', _) -> (\n            arg(1, H, Arg),\n            check_modifiers(Arg, Lper),\n            List = [unless|[Lper]]);\n        functor(H, 'bp', _) -> (\n            H =.. [_|Arg],\n            check_modifiers_in_list(effects, Arg, Lper),\n            List = [bp|[Lper]]);\n        List = [H].\n    /*\n     *   Convert the given tuple to list\n     */\n    tuple_to_list((A,B),L) :- tuple_to_list(A, La), tuple_to_list(B, Lb), append(La, Lb,L).\n    tuple_to_list(A,[A]) :- nonvar(A), A \\= (_ , _).\n    list_to_tuple([H], (H)).\n    list_to_tuple([H|T], (H,TT)) :- list_to_tuple(T,TT).\n    /*\n     *   Replace all the occurences of a given element with the given argument\n     */\n    replace(_, _, [],[]).\n    replace(O, R, [O|T], [R|T2]) :- replace(O, R, T, T2).\n    replace(O, R, [H|T], [H|T2]) :- H \\= O, replace(O, R, T, T2).\n    flatten_first_level([X], X).\n    flatten_first_level.\n    removehead([_|Tail], Tail).\n    in(A, A) :- nonvar(A), A \\= (_ , _).\n    in(A, (A, _)).\n    in(A, (_ , Cs)) :- in(A, Cs).\n    defeasible_admissible([unless, Term]) :- admissible(Term).\n    defeasible_admissible(Term) :- admissible(Term).\n    admissible([neg, bp, Term]) :- admissible_terms_complete(Term).\n    admissible([bp, Term]) :- admissible_terms_complete(Term).\n    admissible([neg, Term]) :- admissible_term(Term).\n    admissible([obl, [Term]]) :- admissible_term(Term).\n    admissible([obl, [neg, Term]]) :- admissible_term(Term).\n    admissible([neg, obl, [Term]]) :- admissible_term(Term).\n    admissible([neg, obl, [neg, Term]]) :- admissible_term(Term).\n    admissible([perm, [Term]]) :- admissible_term(Term).\n    admissible([perm, [neg, Term]]) :- admissible_term(Term).\n    admissible([Term]) :- admissible_term(Term).\n    admissible_term(Term) :-\n        atomic(Term),\n        Term \\== neg,\n        Term \\== obl,\n        Term \\== perm,\n        Term \\== unless,\n        Term \\== bp.\n    admissible_term(Term) :- var(Term).\n    admissible_term(Term) :-\n        compound(Term),\n        \\+ functor(Term, 'o', _),\n        \\+ functor(Term, 'p', _),\n        \\+ functor(Term, '-', _),\n        \\+ functor(Term, '~', _),\n        \\+ functor(Term, 'bp', _),\n        Term =.. [_|Args],\n        admissible_terms(Args).\n    admissible_terms([]).\n    admissible_terms([H|T]) :-\n        admissible_term(H),\n        admissible_terms(T).\n    admissible_terms_complete([]).\n    admissible_terms_complete([H|T]) :-\n        admissible(H),\n        admissible_terms_complete(T).\n        ");
+    this.theoryCode = trimIndent("\n    /*\n     *  Main directive. Find all the rules in the theory in the format (Name : Preconditions => Conclusion)\n     *  or (Name : Effects) and then if:\n     *  - It is a standard rule, translate it in the standard format (rule([Name, Preconditions, Conclusions]));\n     *  - It is a bp rule, translate it to (abstractBp([Effects]))\n     *  During the process, clean them from the unallowed symbols (-, o, p).\n     */\n    convertAllRules(ArgRules) :-\n        defeasibleRules(DefeasibleRules),\n        strictRules(StrictRules, RulesIds),\n        ordinaryPremises(Premises),\n        axiomPremises(Axioms, AxiomsIds),\n        specialRules(SpecialRules),\n        utils::appendLists([DefeasibleRules, StrictRules, Premises, Axioms, SpecialRules], L),\n        convertAllRules(L, Rules),\n        findall(sup(X, Y), sup(X, Y), Sups),\n        utils::appendLists([Rules, AxiomsIds, RulesIds, Sups], ArgRules),\n        findall(_, (member(X, ArgRules), context_assert(X)), _), !.\n    defeasibleRules(DefeasibleRules) :-\n        findall([RuleName, Preconditions, Effect], (RuleName : Preconditions => Effect), DefeasibleRulesOld),\n        prologDefeasibleRules(DefeasibleRulesNew),\n        append(DefeasibleRulesOld, DefeasibleRulesNew, DefeasibleRules).\n    strictRules(CtrRules, Ids) :-\n        findall([RuleName, Preconditions, Effect], (RuleName : Preconditions -> Effect), StrictRulesOld),\n        prologStrictRules(StrictRulesNew),\n        append(StrictRulesOld, StrictRulesNew, StrictRules),\n        transpose(StrictRules, StrictRules, CtrRules),\n        findall(strict(RN), member([RN, _, _], CtrRules), Ids).\n    ordinaryPremises(Premises) :-\n        findall([RuleName, Effect], ((RuleName :=> Effect), atom(RuleName)), PremisesOld),\n        prologPremises(PremisesNew),\n        append(PremisesOld, PremisesNew, Premises).\n    axiomPremises(Axioms, Ids) :-\n        findall([RuleName, Effect], ((RuleName :-> Effect), atom(RuleName)), AxiomsOld),\n        prologAxioms(AxiomsNew),\n        append(AxiomsOld, AxiomsNew, Axioms),\n        findall(strict(RN), member([RN, _], Axioms), Ids).\n    specialRules(SpecialRules) :-\n        bpsNew(SpecialRules).\n    transpose(_, CtrRules, CtrRules) :- \\+ autoTransposition, !.\n    transpose([], CtrRules, CtrRules).\n    transpose([H|T], TempCtrRules, CtrRules) :-\n        transpose(T, TempCtrRules, CR),\n        findall(TrH, transposition(H, TrH), Tran),\n        mergeCtrRules(CR, Tran, CtrRules).\n    mergeCtrRules(All, ToMerge, X) :-\n        append(All, ToMerge, XT),\n        deduplicate(XT, X).\n    deduplicate([], []).\n    deduplicate([[RN,A,B]|T], X) :- deduplicate(T, TT), (member([RN,_,_], TT) -> X = TT; X = [[RN,A,B]|TT]). \n    transposition([Id, Prec, Effect], [Id, Prec, Effect]).\n    transposition([Id, Prec, Effect], [NewId, NewPrec ,XNegated]) :-\n        compound(Prec),\n        tuple_to_list(Prec, LPrec),!,\n        transposition_sequential(LPrec, LPrec, Effect, Id, [], NewPrec, XNegated, NewId).\n    transposition([Id, Prec, Effect], [NewId, EffectNegated ,XNegated]) :-\n        \\+ compound(Prec),\n        Prec \\== [],\n        prologEscape(Prec),\n        negate(Prec, XNegated),\n        negate(Effect, EffectNegated),\n        atom_concat(Id, '_i', NewId).\n    transposition_sequential(LPrec, [H|T], Effect, Id, Skipped, NewPrec, XNegated, NewId) :-\n        transposition_sequential(LPrec, T, Effect, Id, [H|Skipped], NewPrec, XNegated, NewId).\n    transposition_sequential(LPrec, [X|T], Effect, Id, Skipped, NewPrec, XNegated, NewId) :-\n        prologEscape(X),\n        append(Skipped, T, CleanedPrec),\n        negate(X, XNegated),\n        negate(Effect, EffectNegated),\n        list_to_tuple([EffectNegated|CleanedPrec], NewPrec),\n        newIdentifier(Skipped, Id, NewId).\n    newIdentifier(List, OldId, NewId) :-\n        modifier(List, Mod),\n        atom_concat(OldId, Mod, NewId).\n    modifier([], '_i').\n    modifier([_|Tail], Index):-\n        modifier(Tail, Index1),\n        atom_concat(Index1, 'i', Index).\n    negate(X, Arg) :-\n        functor(X, '-', _) -> (\n            arg(1, X, Arg));\n        functor(X, 'p', _) -> (\n            arg(1, X, PX),\n            (functor(PX, '-', _) -> (\n                arg(1, PX, PNX),\n                Arg = o(PNX)\n            );\n            Arg = o(-(PX))));\n        Arg = -(X).\n    prologEscape(X) :- \\+ functor(X, 'prolog', _), \\+ functor(X, '~', _).\n    /*\n     *   Standard rules (RuleName : Preconditions => Effects)\n     *   Special rules (RuleName : Effects)\n     */\n    convertAllRules([], []).\n    convertAllRules([[H,P,E]|T], [R|Rules]) :- convertRule(H, P, E, R), convertAllRules(T, Rules).\n    convertAllRules([[H,E]|T], [R|Rules]) :- convertRule(H, E, R), convertAllRules(T, Rules).\n    /*\n     *   Convert the given rule to the standard format\n     *   Example:\n     *   r2: followedGuidelines(X), doctor(X) => -liable(X)\n     *   rule([r2,[[followedGuidelines(X_e4149)],[doctor(X_e4149)]],[neg,liable(X_e4149)]]).\n     */\n    convertRule(RuleName, Preconditions, Effects, rule(List)) :-\n        tuple_to_list(Preconditions, Lprecond),\n        tuple_to_list(Effects, Leffects),\n        check_modifiers_in_list(preconditions, Lprecond, LprecondChecked),\n        check_modifiers_in_list(effects, Leffects, LeffectsChecked),\n        flatten_first_level(LeffectsChecked, LeffectsCheckedFlattened),\n        List = [RuleName, LprecondChecked, LeffectsCheckedFlattened], !.\n    /*\n     *   Convert the given special rule\n     *   Example:\n     *   bp(-liable(X)).\n     *   abastractBp([[neg, liable(X_e4149)]]).\n     */\n    convertRule(bps, Effects, abstractBp(Checked)) :-\n        functor(Effects, 'bp', _),\n        Effects =.. L,\n        removehead(L, LC),\n        check_modifiers_in_list(effects, LC, Checked), !.\n    convertRule(Name, Effects, premise([Name, LeffectsCheckedFlattened])) :-\n        tuple_to_list(Effects, Leffects),\n        check_modifiers_in_list(effects, Leffects, LeffectsChecked),\n        flatten_first_level(LeffectsChecked, LeffectsCheckedFlattened).\n    /*\n     *   Find negations(-), obligations(o), permissions(p) on a list of preconditions/effects and\n     *   raplace them with the assigned literal (neg, obl, perm)\n     */\n    check_modifiers_in_list(MODE, [], []) :- !.\n    check_modifiers_in_list(MODE, [H|T], L) :- H == [], L = [], !.\n    check_modifiers_in_list(MODE, [H|T], L) :- H \\== [],\n                                check_modifiers_once(H, LH),\n                                check_modifiers_in_list(MODE, T, LT),\n                                append([LH], LT, L).\n    check_modifiers_once(H, List) :- once(check_modifiers(H, List)).\n    check_modifiers([], []).\n    check_modifiers(H, List) :-\n        functor(H, '-', _) -> (\n            arg(1, H, Arg),\n            check_modifiers_once(Arg, Lobl),\n            append([neg], Lobl, Lf),\n            List = Lf);\n        functor(H, 'o', _) -> (\n            arg(1, H, Arg),\n            check_modifiers_once(Arg, Lobl),\n            List = [obl|[Lobl]]);\n        functor(H, 'p', _) -> (\n            arg(1, H, Arg),\n            check_modifiers_once(Arg, Lper),\n            List = [perm|[Lper]]);\n        functor(H, '~', _) -> (\n            arg(1, H, Arg),\n            check_modifiers_once(Arg, Lper),\n            List = [unless|[Lper]]);\n        functor(H, 'bp', _) -> (\n            H =.. [_|Arg],\n            check_modifiers_in_list(effects, Arg, Lper),\n            List = [bp|[Lper]]);\n        List = [H].\n    /*\n     *   Convert the given tuple to list\n     */\n    tuple_to_list(A,[A]) :- nonvar(A), A \\= (_ , _), !.\n    tuple_to_list((A,B),L) :-\n        tuple_to_list(A, La),\n        tuple_to_list(B, Lb),\n        append(La, Lb,L).\n    list_to_tuple([H], (H)) :- !.\n    list_to_tuple([H|T], (H,TT)) :- list_to_tuple(T,TT).\n    /*\n     *   Replace all the occurences of a given element with the given argument\n     */\n    replace(_, _, [],[]) :- !.\n    replace(O, R, [O|T], [R|T2]) :- replace(O, R, T, T2), !.\n    replace(O, R, [H|T], [H|T2]) :- H \\= O, replace(O, R, T, T2).\n    flatten_first_level([X], X) :- !.\n    flatten_first_level.\n    removehead([_|Tail], Tail).\n    in(A, A) :- nonvar(A), A \\= (_ , _), !.\n    in(A, (A, _)) :- !.\n    in(A, (_ , Cs)) :- in(A, Cs).\n    check_admissibility(preconditions, H, LH) :-\n        \\+ defeasible_admissible(LH),\n        throw(['Premise  ', H, '  is not a well formed member of the argumentation language.']).\n    check_admissibility(effects, H, LH) :-\n        \\+ admissible(LH),\n        throw(['Conclusion  ', H, '  is not a well formed member of the argumentation language.']).\n    check_admissibility(_, _, _).\n    defeasible_admissible([unless, Term]) :- admissible(Term).\n    defeasible_admissible(Term) :- admissible(Term).\n    admissible([neg, bp, Term]) :- admissible_terms_complete(Term).\n    admissible([bp, Term]) :- admissible_terms_complete(Term).\n    admissible([neg, Term]) :- admissible_term(Term).\n    admissible([obl, [Term]]) :- admissible_term(Term).\n    admissible([obl, [neg, Term]]) :- admissible_term(Term).\n    admissible([neg, obl, [Term]]) :- admissible_term(Term).\n    admissible([neg, obl, [neg, Term]]) :- admissible_term(Term).\n    admissible([perm, [Term]]) :- admissible_term(Term).\n    admissible([perm, [neg, Term]]) :- admissible_term(Term).\n    admissible([Term]) :- admissible_term(Term).\n    admissible_term(Term) :-\n        atomic(Term),\n        Term \\== neg,\n        Term \\== obl,\n        Term \\== perm,\n        Term \\== unless,\n        Term \\== bp.\n    admissible_term(Term) :- var(Term).\n    admissible_term(Term) :-\n        compound(Term),\n        \\+ functor(Term, 'o', _),\n        \\+ functor(Term, 'p', _),\n        \\+ functor(Term, '-', _),\n        \\+ functor(Term, '~', _),\n        \\+ functor(Term, 'bp', _),\n        Term =.. [_|Args],\n        admissible_terms(Args).\n    admissible_terms([]).\n    admissible_terms([H|T]) :-\n        admissible_term(H),\n        admissible_terms(T).\n    admissible_terms_complete([]).\n    admissible_terms_complete([H|T]) :-\n        admissible(H),\n        admissible_terms_complete(T).\n        ");
   }
   RuleTranslator.$metadata$ = {
     kind: Kind_OBJECT,
@@ -5480,9 +5480,9 @@
   PrologWithArgumentationImpl.prototype.anyMguWith = PrologWithArgumentation.prototype.anyMguWith;
   PrologWithArgumentationImpl.prototype.anyUnifyWith = PrologWithArgumentation.prototype.anyUnifyWith;
   PrologWithArgumentationImpl.prototype.list = PrologWithArgumentation.prototype.list;
-  PrologWithArgumentationImpl.prototype.listFromSequence = PrologWithArgumentation.prototype.listFromSequence;
-  PrologWithArgumentationImpl.prototype.listFrom = PrologWithArgumentation.prototype.listFrom;
   PrologWithArgumentationImpl.prototype.listFromIterable = PrologWithArgumentation.prototype.listFromIterable;
+  PrologWithArgumentationImpl.prototype.listFrom = PrologWithArgumentation.prototype.listFrom;
+  PrologWithArgumentationImpl.prototype.listFromSequence = PrologWithArgumentation.prototype.listFromSequence;
   PrologWithArgumentationImpl.prototype.matchAny = PrologWithArgumentation.prototype.matchAny;
   PrologWithArgumentationImpl.prototype.mguWithOccurCheck = PrologWithArgumentation.prototype.mguWithOccurCheck;
   PrologWithArgumentationImpl.prototype.mguAny = PrologWithArgumentation.prototype.mguAny;