@tuprolog/arg2p-core 0.6.2 → 0.6.3

package/kotlin/arg2p-core.js

@@ -108,6 +108,7 @@
   var Random = Kotlin.kotlin.random.Random;
   var toTerm = $module$_2p_core.it.unibo.tuprolog.core.listToTerm;
   var UnaryPredicate$WithoutSideEffects = $module$_2p_solve.it.unibo.tuprolog.solve.primitive.UnaryPredicate.WithoutSideEffects;
+  var BinaryRelation$WithoutSideEffects = $module$_2p_solve.it.unibo.tuprolog.solve.primitive.BinaryRelation.WithoutSideEffects;
   var copyToArray = Kotlin.kotlin.collections.copyToArray;
   var AliasedLibrary = $module$_2p_solve.it.unibo.tuprolog.solve.library.AliasedLibrary;
   var compareBy = Kotlin.kotlin.comparisons.compareBy_bvgy4j$;
@@ -167,6 +168,8 @@
   DefeasibleRules.prototype.constructor = DefeasibleRules;
   Bps.prototype = Object.create(UnaryPredicate$WithoutSideEffects.prototype);
   Bps.prototype.constructor = Bps;
+  ExtractStrictIds.prototype = Object.create(BinaryRelation$WithoutSideEffects.prototype);
+  ExtractStrictIds.prototype.constructor = ExtractStrictIds;
   StructuredModeBase.prototype = Object.create(LazyRawPrologContent.prototype);
   StructuredModeBase.prototype.constructor = StructuredModeBase;
   DebugBase.prototype = Object.create(LazyRawPrologContent.prototype);
@@ -3077,7 +3080,9 @@
         return $receiver.descriptionPair;
       }.bind(null, Premises_getInstance())).get(), getPropertyCallableRef('descriptionPair', 0, function ($receiver) {
         return $receiver.descriptionPair;
-      }.bind(null, DefeasibleRules_getInstance())).get()]), this.prologTheory, RuleParserBase$Companion_getInstance().operators());
+      }.bind(null, DefeasibleRules_getInstance())).get(), getPropertyCallableRef('descriptionPair', 0, function ($receiver) {
+        return $receiver.descriptionPair;
+      }.bind(null, ExtractStrictIds_getInstance())).get()]), this.prologTheory, RuleParserBase$Companion_getInstance().operators());
     }
   });
   Object.defineProperty(RuleParserBase.prototype, 'baseFlags', {
@@ -3414,6 +3419,35 @@
       new Bps();
     }return Bps_instance;
   }
+  function ExtractStrictIds() {
+    ExtractStrictIds_instance = this;
+    BinaryRelation$WithoutSideEffects.call(this, 'extract_id');
+  }
+  ExtractStrictIds.prototype.computeAllSubstitutions_2j1e5m$ = function ($receiver, first, second) {
+    var tmp$ = Substitution.Companion;
+    var tmp$_0 = ensureNotNull(second.asVar());
+    var tmp$_1 = List.Companion;
+    var $receiver_0 = ensureNotNull(first.asList()).toList();
+    var destination = ArrayList_init(collectionSizeOrDefault($receiver_0, 10));
+    var tmp$_2;
+    tmp$_2 = $receiver_0.iterator();
+    while (tmp$_2.hasNext()) {
+      var item = tmp$_2.next();
+      destination.add_11rb$(Struct.Companion.of('strict', [ensureNotNull(item.asCons()).head]));
+    }
+    return sequenceOf([tmp$.of(tmp$_0, tmp$_1.ofList(destination))]);
+  };
+  ExtractStrictIds.$metadata$ = {
+    kind: Kind_OBJECT,
+    simpleName: 'ExtractStrictIds',
+    interfaces: [BinaryRelation$WithoutSideEffects]
+  };
+  var ExtractStrictIds_instance = null;
+  function ExtractStrictIds_getInstance() {
+    if (ExtractStrictIds_instance === null) {
+      new ExtractStrictIds();
+    }return ExtractStrictIds_instance;
+  }
   function StructuredModeBase() {
     LazyRawPrologContent.call(this);
     this.alias_k0m5up$_0 = 'prolog.argumentation.structured';
@@ -3631,7 +3665,11 @@
   Object.defineProperty(UtilsBase.prototype, 'baseContent', {
     configurable: true,
     get: function () {
-      return Library.Companion.aliased(this.alias, void 0, this.prologTheory);
+      var tmp$, tmp$_0, tmp$_1;
+      tmp$_1 = Library.Companion;
+      tmp$ = this.alias;
+      tmp$_0 = this.prologTheory;
+      return tmp$_1.aliased(tmp$, mapOf_0([to(AppendOptimized_getInstance().signature, AppendOptimized_getInstance()), to(AssertAll_getInstance().signature, AssertAll_getInstance())]), tmp$_0);
     }
   });
   Object.defineProperty(UtilsBase.prototype, 'baseFlags', {
@@ -3654,6 +3692,172 @@
     simpleName: 'UtilsBase',
     interfaces: [Loadable, LazyRawPrologContent, ArgLibrary]
   };
+  function AppendOptimized() {
+    AppendOptimized_instance = this;
+    this.signature = new Signature('append_fast', 3);
+  }
+  function Coroutine$AppendOptimized$solve$lambda(closure$request_0, closure$res_0, closure$list1_0, closure$list2_0, $receiver_0, controller, continuation_0) {
+    CoroutineImpl.call(this, continuation_0);
+    this.$controller = controller;
+    this.exceptionState_0 = 1;
+    this.local$closure$request = closure$request_0;
+    this.local$closure$res = closure$res_0;
+    this.local$closure$list1 = closure$list1_0;
+    this.local$closure$list2 = closure$list2_0;
+    this.local$$receiver = $receiver_0;
+  }
+  Coroutine$AppendOptimized$solve$lambda.$metadata$ = {
+    kind: Kotlin.Kind.CLASS,
+    simpleName: null,
+    interfaces: [CoroutineImpl]
+  };
+  Coroutine$AppendOptimized$solve$lambda.prototype = Object.create(CoroutineImpl.prototype);
+  Coroutine$AppendOptimized$solve$lambda.prototype.constructor = Coroutine$AppendOptimized$solve$lambda;
+  Coroutine$AppendOptimized$solve$lambda.prototype.doResume = function () {
+    do
+      try {
+        switch (this.state_0) {
+          case 0:
+            this.state_0 = 2;
+            this.result_0 = this.local$$receiver.yield_11rb$(this.local$closure$request.replyWith(Substitution.Companion.of(this.local$closure$res, List.Companion.ofList(plus(this.local$closure$list1.toList(), this.local$closure$list2.toList()))), void 0, []), this);
+            if (this.result_0 === COROUTINE_SUSPENDED)
+              return COROUTINE_SUSPENDED;
+            continue;
+          case 1:
+            throw this.exception_0;
+          case 2:
+            return this.result_0;
+          default:this.state_0 = 1;
+            throw new Error('State Machine Unreachable execution');
+        }
+      } catch (e) {
+        if (this.state_0 === 1) {
+          this.exceptionState_0 = this.state_0;
+          throw e;
+        } else {
+          this.state_0 = this.exceptionState_0;
+          this.exception_0 = e;
+        }
+      }
+     while (true);
+  };
+  function AppendOptimized$solve$lambda(closure$request_0, closure$res_0, closure$list1_0, closure$list2_0) {
+    return function ($receiver_0, continuation_0, suspended) {
+      var instance = new Coroutine$AppendOptimized$solve$lambda(closure$request_0, closure$res_0, closure$list1_0, closure$list2_0, $receiver_0, this, continuation_0);
+      if (suspended)
+        return instance;
+      else
+        return instance.doResume(null);
+    };
+  }
+  AppendOptimized.prototype.solve = function (request) {
+    var list1 = request.arguments.get_za3lpa$(0);
+    var list2 = request.arguments.get_za3lpa$(1);
+    var res = request.arguments.get_za3lpa$(2);
+    if (!Kotlin.isType(list1, List)) {
+      throw TypeError.Companion.forGoal(request.context, request.signature, TypeError$Expected.LIST, list1);
+    }if (!Kotlin.isType(list2, List)) {
+      throw TypeError.Companion.forGoal(request.context, request.signature, TypeError$Expected.LIST, list2);
+    }if (!Kotlin.isType(res, Var)) {
+      throw TypeError.Companion.forGoal(request.context, request.signature, TypeError$Expected.VARIABLE, res);
+    }return sequence(AppendOptimized$solve$lambda(request, res, list1, list2));
+  };
+  AppendOptimized.$metadata$ = {
+    kind: Kind_OBJECT,
+    simpleName: 'AppendOptimized',
+    interfaces: [Primitive]
+  };
+  var AppendOptimized_instance = null;
+  function AppendOptimized_getInstance() {
+    if (AppendOptimized_instance === null) {
+      new AppendOptimized();
+    }return AppendOptimized_instance;
+  }
+  function AssertAll() {
+    AssertAll_instance = this;
+    this.signature = new Signature('assert_all', 1);
+  }
+  function AssertAll$solve$lambda(closure$list, closure$request) {
+    return function ($receiver) {
+      var $receiver_0 = closure$list.toSequence();
+      var tmp$;
+      tmp$ = $receiver_0.iterator();
+      while (tmp$.hasNext()) {
+        var element = tmp$.next();
+        first(closure$request.solve($receiver.stringInvoke('context_assert', element, [])));
+      }
+      return Unit;
+    };
+  }
+  function Coroutine$AssertAll$solve$lambda(closure$request_0, $receiver_0, controller, continuation_0) {
+    CoroutineImpl.call(this, continuation_0);
+    this.$controller = controller;
+    this.exceptionState_0 = 1;
+    this.local$closure$request = closure$request_0;
+    this.local$$receiver = $receiver_0;
+  }
+  Coroutine$AssertAll$solve$lambda.$metadata$ = {
+    kind: Kotlin.Kind.CLASS,
+    simpleName: null,
+    interfaces: [CoroutineImpl]
+  };
+  Coroutine$AssertAll$solve$lambda.prototype = Object.create(CoroutineImpl.prototype);
+  Coroutine$AssertAll$solve$lambda.prototype.constructor = Coroutine$AssertAll$solve$lambda;
+  Coroutine$AssertAll$solve$lambda.prototype.doResume = function () {
+    do
+      try {
+        switch (this.state_0) {
+          case 0:
+            this.state_0 = 2;
+            this.result_0 = this.local$$receiver.yield_11rb$(this.local$closure$request.replyWithCondition(true, void 0, []), this);
+            if (this.result_0 === COROUTINE_SUSPENDED)
+              return COROUTINE_SUSPENDED;
+            continue;
+          case 1:
+            throw this.exception_0;
+          case 2:
+            return this.result_0;
+          default:this.state_0 = 1;
+            throw new Error('State Machine Unreachable execution');
+        }
+      } catch (e) {
+        if (this.state_0 === 1) {
+          this.exceptionState_0 = this.state_0;
+          throw e;
+        } else {
+          this.state_0 = this.exceptionState_0;
+          this.exception_0 = e;
+        }
+      }
+     while (true);
+  };
+  function AssertAll$solve$lambda_0(closure$request_0) {
+    return function ($receiver_0, continuation_0, suspended) {
+      var instance = new Coroutine$AssertAll$solve$lambda(closure$request_0, $receiver_0, this, continuation_0);
+      if (suspended)
+        return instance;
+      else
+        return instance.doResume(null);
+    };
+  }
+  AssertAll.prototype.solve = function (request) {
+    var list = request.arguments.get_za3lpa$(0);
+    if (!Kotlin.isType(list, List)) {
+      throw TypeError.Companion.forGoal(request.context, request.signature, TypeError$Expected.LIST, list);
+    }arg2pScope(AssertAll$solve$lambda(list, request));
+    return sequence(AssertAll$solve$lambda_0(request));
+  };
+  AssertAll.$metadata$ = {
+    kind: Kind_OBJECT,
+    simpleName: 'AssertAll',
+    interfaces: [Primitive]
+  };
+  var AssertAll_instance = null;
+  function AssertAll_getInstance() {
+    if (AssertAll_instance === null) {
+      new AssertAll();
+    }return AssertAll_instance;
+  }
   function MetaInterpreterLib() {
     MetaInterpreterLib_instance = this;
     this.$delegate_3wovwi$_0 = Library.Companion.aliased('prolog.argumentation.meta', void 0, parse_2(Theory.Companion, trimIndent('\n        % with_facts_and_length/3\n        with_facts_and_length(X, Y, L) :-\n            solve(X, R),\n            recover_facts(R, Y),\n            length(Y, L).\n\n        % lenght/2\n\n        length([], 0).\n        length([_|T], X) :- length(T, Y), X is Y + 1.\n\n        % recover_facts/2\n\n        recover_facts([], []) :- !.\n        recover_facts([H|T], C) :-\n            is_list(H), !,\n            recover_facts(T, TC),\n            recover_facts(H, HC),\n            append(TC, HC, C).\n        recover_facts([H|T], C) :-\n            \\+ is_list(H),\n            recover_facts(T, TC),\n            evaluate(H, HC),\n            append(TC, HC, C).\n\n        evaluate(user_fact(X), [X]) :- !.\n        evaluate(_, []) :- !.\n\n        % solve/2\n\n        solve((A,B), Result) :- !,\n            solve(A, ARes),\n            solve(B, BRes),\n            append(ARes, BRes, Result).\n\n        solve((A;B), Result) :- !,\n            solve(A, Result);\n            solve(B, Result).\n\n        solve(member(A, B), [system_predicate]) :- !,\n            call(member(A, B)).\n\n        solve(\\+(A), [not(A)]) :- !,\n            call(\\+(A)).\n\n        solve((A)\\=(B), [doNotUnify(A, B)]) :- !,\n            call((A)\\=(B)).\n\n        solve(A, [system_predicate]) :-\n            catch(clause(A, _), B, true),\n            \\+ var(B), !,\n            call(A).\n\n        solve(A, [A]) :-\n            \\+ clause(A, B), !,\n            call(A).\n\n        solve(A, [A|[Res]]) :-\n            clause(A, B),\n            solve(B, Res).\n\n        % is_list/1\n\n        is_list(X) :- var(X), !, fail.\n        is_list([]).\n        is_list([_|T]) :- is_list(T).\n        \n        % fetch_argument_facts/2\n        \n        fetch_argument_facts(Conclusion, Facts) :-\n            argument([R, TR, [Conclusion]]),\n            findall(user_fact(Fact), \n                support([_, _, [user_fact(Fact)]], [R, TR, [Conclusion]]),\n            Facts).\n        ')));
@@ -4876,7 +5080,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_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        ");
+    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), Sup),\n        utils::appendLists([Rules, AxiomsIds, RulesIds, Sup], ArgRules),\n        utils::assert_all(ArgRules), !.\n    defeasibleRules(DefeasibleRules) :-\n        findall([RuleName, Preconditions, Effect], (RuleName : Preconditions => Effect), DefeasibleRulesOld),\n        prologDefeasibleRules(DefeasibleRulesNew),\n        utils::append_fast(DefeasibleRulesOld, DefeasibleRulesNew, DefeasibleRules).\n    strictRules(CtrRules, Ids) :-\n        findall([RuleName, Preconditions, Effect], (RuleName : Preconditions -> Effect), StrictRulesOld),\n        prologStrictRules(StrictRulesNew),\n        utils::append_fast(StrictRulesOld, StrictRulesNew, StrictRules),\n        transpose(StrictRules, StrictRules, CtrRules),\n        extract_id(CtrRules, Ids).\n    ordinaryPremises(Premises) :-\n        findall([RuleName, Effect], ((RuleName :=> Effect), atom(RuleName)), PremisesOld),\n        prologPremises(PremisesNew),\n        utils::append_fast(PremisesOld, PremisesNew, Premises).\n    axiomPremises(Axioms, Ids) :-\n        findall([RuleName, Effect], ((RuleName :-> Effect), atom(RuleName)), AxiomsOld),\n        prologAxioms(AxiomsNew),\n        utils::append_fast(AxiomsOld, AxiomsNew, Axioms),\n        extract_id(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        utils::append_fast(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        utils::append_fast(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], R) :- H \\== [],\n                                check_modifiers_once(H, LH),\n                                check_modifiers_in_list(MODE, T, LT),\n                                utils::append_fast([LH], LT, L),\n                                R = 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            utils::append_fast([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        utils::append_fast(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,
@@ -4921,7 +5125,7 @@
   }
   function Utils() {
     Utils_instance = this;
-    this.theoryCode = trimIndent('\n    writeList([]) :- nl.\n    writeList([X|Others]) :-\n    \twrite(X),\n    \twriteList(Others).\n    writeListNl([]).\n    writeListNl([X|Others]) :-\n    \twrite(X),nl,\n    \twriteListNl(Others).\n    sortDistinct(List, Sorted) :-\n        deduplicate(List, Deduplicated),\n        sort(Deduplicated, Sorted).\n    deduplicate([], []).\n    deduplicate(List, Output) :-\n        List \\== [],\n        setof(X, member(X, List), Output).\n    sort(List,Sorted) :- q_sort(List, [], Sorted).\n    q_sort([], Acc, Acc).\n    q_sort([H|T], Acc, Sorted) :-\n    \tpivoting(H, T, L1, L2),\n    \tq_sort(L1, Acc, Sorted1),\n    \tq_sort(L2, [H|Sorted1], Sorted).\n    pivoting(H,[],[],[]).\n    pivoting(H, [X|T], [X|L], G) :-\n        H @>= X,\n        pivoting(H, T, L, G).\n    pivoting(H, [X|T], L, [X|G]) :-\n        X @> H,\n        pivoting(H, T, L, G).\n    subtract([], _, []).\n    subtract([Head|Tail], L2, L3) :-\n            member(Head, L2), !,\n            subtract(Tail, L2, L3).\n    subtract([Head|Tail1], L2, [Head|Tail3]) :-\n            subtract(Tail1, L2, Tail3).\n    isEmptyList([]).\n    appendLists([], []).\n    appendLists([H|T], R) :-\n        appendLists(T, AT),\n        append(H, AT, R).\n    search(F, L, S) :-\n       between(1, L, N),\n       functor(S, F, N),\n       call(S).\n    between(N, M, K) :- N < M, K = N.\n    between(N, M, K) :- N == M, !, K = N.\n    between(N, M, K) :- N < M, N1 is N+1, between(N1, M, K).\n    recoverGraph(Args, Attacks, Supports) :-\n            findall(X, context_check(argument(X)), TempArgs),\n            findall((T, A, B, C), context_check(attack(T, A, B, C)), TempAttacks),\n            findall((A, B), context_check(support(A, B)), TempSupports),\n            utils::sort(TempArgs, Args),\n            utils::sort(TempAttacks, Attacks),\n            utils::sort(TempSupports, Supports).\n    recoverArgumentLabelling(ArgsIn, ArgsOut, ArgsUnd) :-\n            findall(X, context_check(in(X)), TempArgsIn),\n            findall(X, context_check(out(X)), TempArgsOut),\n            findall(X, context_check(und(X)), TempArgsUnd),\n            utils::sort(TempArgsIn, ArgsIn),\n            utils::sort(TempArgsOut, ArgsOut),\n            utils::sort(TempArgsUnd, ArgsUnd).\n    recoverStatementLabelling(In, Out, Und) :-\n            findall(X, context_check(statIn(X)), TempIn),\n            findall(X, context_check(statOut(X)), TempOut),\n            findall(X, context_check(statUnd(X)), TempUnd),\n            utils::sort(TempIn, In),\n            utils::sort(TempOut, Out),\n            utils::sort(TempUnd, Und).\n        ');
+    this.theoryCode = trimIndent('\n    writeList([]) :- nl.\n    writeList([X|Others]) :-\n    \twrite(X),\n    \twriteList(Others).\n    writeListNl([]).\n    writeListNl([X|Others]) :-\n    \twrite(X),nl,\n    \twriteListNl(Others).\n    sortDistinct(List, Sorted) :-\n        deduplicate(List, Deduplicated),\n        sort(Deduplicated, Sorted).\n    deduplicate([], []).\n    deduplicate(List, Output) :-\n        List \\== [],\n        setof(X, member(X, List), Output).\n    sort(List,Sorted) :- q_sort(List, [], Sorted).\n    q_sort([], Acc, Acc).\n    q_sort([H|T], Acc, Sorted) :-\n    \tpivoting(H, T, L1, L2),\n    \tq_sort(L1, Acc, Sorted1),\n    \tq_sort(L2, [H|Sorted1], Sorted).\n    pivoting(H,[],[],[]).\n    pivoting(H, [X|T], [X|L], G) :-\n        H @>= X,\n        pivoting(H, T, L, G).\n    pivoting(H, [X|T], L, [X|G]) :-\n        X @> H,\n        pivoting(H, T, L, G).\n    subtract([], _, []).\n    subtract([Head|Tail], L2, L3) :-\n            member(Head, L2), !,\n            subtract(Tail, L2, L3).\n    subtract([Head|Tail1], L2, [Head|Tail3]) :-\n            subtract(Tail1, L2, Tail3).\n    isEmptyList([]).\n    appendLists([], []).\n    appendLists([H|T], R) :-\n        appendLists(T, AT),\n        append_fast(H, AT, R).\n    search(F, L, S) :-\n       between(1, L, N),\n       functor(S, F, N),\n       call(S).\n    between(N, M, K) :- N < M, K = N.\n    between(N, M, K) :- N == M, !, K = N.\n    between(N, M, K) :- N < M, N1 is N+1, between(N1, M, K).\n    recoverGraph(Args, Attacks, Supports) :-\n            findall(X, context_check(argument(X)), TempArgs),\n            findall((T, A, B, C), context_check(attack(T, A, B, C)), TempAttacks),\n            findall((A, B), context_check(support(A, B)), TempSupports),\n            utils::sort(TempArgs, Args),\n            utils::sort(TempAttacks, Attacks),\n            utils::sort(TempSupports, Supports).\n    recoverArgumentLabelling(ArgsIn, ArgsOut, ArgsUnd) :-\n            findall(X, context_check(in(X)), TempArgsIn),\n            findall(X, context_check(out(X)), TempArgsOut),\n            findall(X, context_check(und(X)), TempArgsUnd),\n            utils::sort(TempArgsIn, ArgsIn),\n            utils::sort(TempArgsOut, ArgsOut),\n            utils::sort(TempArgsUnd, ArgsUnd).\n    recoverStatementLabelling(In, Out, Und) :-\n            findall(X, context_check(statIn(X)), TempIn),\n            findall(X, context_check(statOut(X)), TempOut),\n            findall(X, context_check(statUnd(X)), TempUnd),\n            utils::sort(TempIn, In),\n            utils::sort(TempOut, Out),\n            utils::sort(TempUnd, Und).\n        ');
   }
   Utils.$metadata$ = {
     kind: Kind_OBJECT,
@@ -5144,6 +5348,9 @@
   Object.defineProperty(package$language, 'Bps', {
     get: Bps_getInstance
   });
+  Object.defineProperty(package$language, 'ExtractStrictIds', {
+    get: ExtractStrictIds_getInstance
+  });
   var package$structured = package$libs.structured || (package$libs.structured = {});
   package$structured.StructuredModeBase = StructuredModeBase;
   Object.defineProperty(package$structured, 'QueryMode', {
@@ -5162,6 +5369,12 @@
     get: OrderingComparator_getInstance
   });
   package$utils.UtilsBase = UtilsBase;
+  Object.defineProperty(package$utils, 'AppendOptimized', {
+    get: AppendOptimized_getInstance
+  });
+  Object.defineProperty(package$utils, 'AssertAll', {
+    get: AssertAll_getInstance
+  });
   var package$meta = package$core.meta || (package$core.meta = {});
   Object.defineProperty(package$meta, 'MetaInterpreterLib', {
     get: MetaInterpreterLib_getInstance
@@ -5480,9 +5693,9 @@
   PrologWithArgumentationImpl.prototype.anyMguWith = PrologWithArgumentation.prototype.anyMguWith;
   PrologWithArgumentationImpl.prototype.anyUnifyWith = PrologWithArgumentation.prototype.anyUnifyWith;
   PrologWithArgumentationImpl.prototype.list = PrologWithArgumentation.prototype.list;
-  PrologWithArgumentationImpl.prototype.listFromIterable = PrologWithArgumentation.prototype.listFromIterable;
-  PrologWithArgumentationImpl.prototype.listFrom = PrologWithArgumentation.prototype.listFrom;
   PrologWithArgumentationImpl.prototype.listFromSequence = PrologWithArgumentation.prototype.listFromSequence;
+  PrologWithArgumentationImpl.prototype.listFrom = PrologWithArgumentation.prototype.listFrom;
+  PrologWithArgumentationImpl.prototype.listFromIterable = PrologWithArgumentation.prototype.listFromIterable;
   PrologWithArgumentationImpl.prototype.matchAny = PrologWithArgumentation.prototype.matchAny;
   PrologWithArgumentationImpl.prototype.mguWithOccurCheck = PrologWithArgumentation.prototype.mguWithOccurCheck;
   PrologWithArgumentationImpl.prototype.mguAny = PrologWithArgumentation.prototype.mguAny;