@tuprolog/arg2p-core 0.6.5 → 0.6.6

package/kotlin/arg2p-core.js

@@ -77,6 +77,8 @@
   var equals = Kotlin.equals;
   var DomainError = $module$_2p_solve.it.unibo.tuprolog.solve.exception.error.DomainError;
   var DomainError$Expected = $module$_2p_solve.it.unibo.tuprolog.solve.exception.error.DomainError.Expected;
+  var SolveOptions = $module$_2p_solve.it.unibo.tuprolog.solve.SolveOptions;
+  var Long$Companion$MAX_VALUE = Kotlin.Long.MAX_VALUE;
   var Unit = Kotlin.kotlin.Unit;
   var filter = Kotlin.kotlin.sequences.filter_euau3h$;
   var prolog = $module$_2p_dsl_core.it.unibo.tuprolog.dsl.prolog;
@@ -114,6 +116,7 @@
   var IllegalArgumentException_init = Kotlin.kotlin.IllegalArgumentException_init;
   var copyToArray = Kotlin.kotlin.collections.copyToArray;
   var hashCode = Kotlin.hashCode;
+  var Collection = Kotlin.kotlin.collections.Collection;
   var AliasedLibrary = $module$_2p_solve.it.unibo.tuprolog.solve.library.AliasedLibrary;
   var compareBy = Kotlin.kotlin.comparisons.compareBy_bvgy4j$;
   var sortedWith = Kotlin.kotlin.sequences.sortedWith_vjgqpk$;
@@ -926,36 +929,18 @@
   PrologWithArgumentationImpl.prototype.write1 = function (term) {
     return this.$delegate_38xz9p$_0.write1(term);
   };
-  PrologWithArgumentationImpl.prototype.neq2 = function ($receiver, right) {
-    return this.$delegate_38xz9p$_0.neq2($receiver, right);
-  };
-  PrologWithArgumentationImpl.prototype.nid2 = function ($receiver, right) {
-    return this.$delegate_38xz9p$_0.nid2($receiver, right);
-  };
-  PrologWithArgumentationImpl.prototype.power = function ($receiver, right) {
-    return this.$delegate_38xz9p$_0.power($receiver, right);
-  };
-  PrologWithArgumentationImpl.prototype.eq2 = function ($receiver, right) {
-    return this.$delegate_38xz9p$_0.eq2($receiver, right);
-  };
-  PrologWithArgumentationImpl.prototype.arithNeq2 = function ($receiver, right) {
-    return this.$delegate_38xz9p$_0.arithNeq2($receiver, right);
-  };
-  PrologWithArgumentationImpl.prototype.id2 = function ($receiver, right) {
-    return this.$delegate_38xz9p$_0.id2($receiver, right);
-  };
-  PrologWithArgumentationImpl.prototype.arithEq2 = function ($receiver, right) {
-    return this.$delegate_38xz9p$_0.arithEq2($receiver, right);
-  };
-  PrologWithArgumentationImpl.prototype.pow = function ($receiver, right) {
-    return this.$delegate_38xz9p$_0.pow($receiver, right);
-  };
   PrologWithArgumentationImpl.prototype.anyAnd = function ($receiver, other) {
     return this.$delegate_38xz9p$_0.anyAnd($receiver, other);
   };
   PrologWithArgumentationImpl.prototype.append = function ($receiver, item, items) {
     return this.$delegate_38xz9p$_0.append($receiver, item, items);
   };
+  PrologWithArgumentationImpl.prototype.arithEq2 = function ($receiver, right) {
+    return this.$delegate_38xz9p$_0.arithEq2($receiver, right);
+  };
+  PrologWithArgumentationImpl.prototype.arithNeq2 = function ($receiver, right) {
+    return this.$delegate_38xz9p$_0.arithNeq2($receiver, right);
+  };
   PrologWithArgumentationImpl.prototype.concat = function ($receiver, other) {
     return this.$delegate_38xz9p$_0.concat($receiver, other);
   };
@@ -971,6 +956,9 @@
   PrologWithArgumentationImpl.prototype.anyDiv = function ($receiver, other) {
     return this.$delegate_38xz9p$_0.anyDiv($receiver, other);
   };
+  PrologWithArgumentationImpl.prototype.eq2 = function ($receiver, right) {
+    return this.$delegate_38xz9p$_0.eq2($receiver, right);
+  };
   PrologWithArgumentationImpl.prototype.anyEqualsTo = function ($receiver, other) {
     return this.$delegate_38xz9p$_0.anyEqualsTo($receiver, other);
   };
@@ -983,6 +971,9 @@
   PrologWithArgumentationImpl.prototype.anyGreaterThanOrEqualsTo = function ($receiver, other) {
     return this.$delegate_38xz9p$_0.anyGreaterThanOrEqualsTo($receiver, other);
   };
+  PrologWithArgumentationImpl.prototype.id2 = function ($receiver, right) {
+    return this.$delegate_38xz9p$_0.id2($receiver, right);
+  };
   PrologWithArgumentationImpl.prototype.anyIf = function ($receiver, other) {
     return this.$delegate_38xz9p$_0.anyIf($receiver, other);
   };
@@ -1013,6 +1004,12 @@
   PrologWithArgumentationImpl.prototype.anyMinus = function ($receiver, other) {
     return this.$delegate_38xz9p$_0.anyMinus($receiver, other);
   };
+  PrologWithArgumentationImpl.prototype.neq2 = function ($receiver, right) {
+    return this.$delegate_38xz9p$_0.neq2($receiver, right);
+  };
+  PrologWithArgumentationImpl.prototype.nid2 = function ($receiver, right) {
+    return this.$delegate_38xz9p$_0.nid2($receiver, right);
+  };
   PrologWithArgumentationImpl.prototype.anyNonGreaterThan = function ($receiver, other) {
     return this.$delegate_38xz9p$_0.anyNonGreaterThan($receiver, other);
   };
@@ -1724,7 +1721,7 @@
         switch (this.state_0) {
           case 0:
             this.state_0 = 2;
-            this.result_0 = this.local$$receiver.yieldAll_swo9gw$(map(this.local$closure$solver.solve(this.local$closure$goal), DynamicLoader$AbstractWithLib$solve$lambda$lambda(this.local$closure$request)), this);
+            this.result_0 = this.local$$receiver.yieldAll_swo9gw$(map(this.local$closure$solver.solveWithOptions(this.local$closure$goal, SolveOptions.Companion.someEagerlyWithTimeout(1000, Long$Companion$MAX_VALUE)), DynamicLoader$AbstractWithLib$solve$lambda$lambda(this.local$closure$request)), this);
             if (this.result_0 === COROUTINE_SUSPENDED)
               return COROUTINE_SUSPENDED;
             continue;
@@ -3777,7 +3774,7 @@
       var tmp$_2 = to(AppendOptimized_getInstance().signature, AppendOptimized_getInstance());
       var tmp$_3 = to(AssertAll_getInstance().signature, AssertAll_getInstance());
       var $this = ArgumentHash_getInstance();
-      return tmp$_1.aliased(tmp$, mapOf_0([tmp$_2, tmp$_3, to($this.signature, $this.wrappedImplementation)]), tmp$_0);
+      return tmp$_1.aliased(tmp$, mapOf_0([tmp$_2, tmp$_3, to($this.signature, $this.wrappedImplementation), to(Contains_getInstance().signature, Contains_getInstance()), to(ContainsAny_getInstance().signature, ContainsAny_getInstance())]), tmp$_0);
     }
   });
   Object.defineProperty(UtilsBase.prototype, 'baseFlags', {
@@ -3984,6 +3981,206 @@
       new ArgumentHash();
     }return ArgumentHash_instance;
   }
+  function Contains() {
+    Contains_instance = this;
+    this.signature = new Signature('contains', 2);
+  }
+  function Coroutine$Contains$solve$lambda(closure$request_0, closure$list_0, closure$elem_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$list = closure$list_0;
+    this.local$closure$elem = closure$elem_0;
+    this.local$$receiver = $receiver_0;
+  }
+  Coroutine$Contains$solve$lambda.$metadata$ = {
+    kind: Kotlin.Kind.CLASS,
+    simpleName: null,
+    interfaces: [CoroutineImpl]
+  };
+  Coroutine$Contains$solve$lambda.prototype = Object.create(CoroutineImpl.prototype);
+  Coroutine$Contains$solve$lambda.prototype.constructor = Coroutine$Contains$solve$lambda;
+  Coroutine$Contains$solve$lambda.prototype.doResume = function () {
+    do
+      try {
+        switch (this.state_0) {
+          case 0:
+            var tmp$ = this.local$closure$request;
+            var $receiver = this.local$closure$list.toList();
+            var any$result;
+            any$break: do {
+              var tmp$_0;
+              if (Kotlin.isType($receiver, Collection) && $receiver.isEmpty()) {
+                any$result = false;
+                break any$break;
+              }tmp$_0 = $receiver.iterator();
+              while (tmp$_0.hasNext()) {
+                var element = tmp$_0.next();
+                var closure$elem = this.local$closure$elem;
+                if (Unificator.Companion.default.match(element, closure$elem)) {
+                  any$result = true;
+                  break any$break;
+                }}
+              any$result = false;
+            }
+             while (false);
+            this.state_0 = 2;
+            this.result_0 = this.local$$receiver.yield_11rb$(tmp$.replyWithCondition(any$result, 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 Contains$solve$lambda(closure$request_0, closure$list_0, closure$elem_0) {
+    return function ($receiver_0, continuation_0, suspended) {
+      var instance = new Coroutine$Contains$solve$lambda(closure$request_0, closure$list_0, closure$elem_0, $receiver_0, this, continuation_0);
+      if (suspended)
+        return instance;
+      else
+        return instance.doResume(null);
+    };
+  }
+  Contains.prototype.solve = function (request) {
+    var elem = request.arguments.get_za3lpa$(0);
+    var list = request.arguments.get_za3lpa$(1);
+    if (!Kotlin.isType(list, List)) {
+      throw TypeError.Companion.forGoal(request.context, request.signature, TypeError$Expected.LIST, list);
+    }return sequence(Contains$solve$lambda(request, list, elem));
+  };
+  Contains.$metadata$ = {
+    kind: Kind_OBJECT,
+    simpleName: 'Contains',
+    interfaces: [Primitive]
+  };
+  var Contains_instance = null;
+  function Contains_getInstance() {
+    if (Contains_instance === null) {
+      new Contains();
+    }return Contains_instance;
+  }
+  function ContainsAny() {
+    ContainsAny_instance = this;
+    this.signature = new Signature('contains_any', 2);
+  }
+  function Coroutine$ContainsAny$solve$lambda(closure$request_0, closure$list_0, closure$elemList_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$list = closure$list_0;
+    this.local$closure$elemList = closure$elemList_0;
+    this.local$$receiver = $receiver_0;
+  }
+  Coroutine$ContainsAny$solve$lambda.$metadata$ = {
+    kind: Kotlin.Kind.CLASS,
+    simpleName: null,
+    interfaces: [CoroutineImpl]
+  };
+  Coroutine$ContainsAny$solve$lambda.prototype = Object.create(CoroutineImpl.prototype);
+  Coroutine$ContainsAny$solve$lambda.prototype.constructor = Coroutine$ContainsAny$solve$lambda;
+  Coroutine$ContainsAny$solve$lambda.prototype.doResume = function () {
+    do
+      try {
+        switch (this.state_0) {
+          case 0:
+            var tmp$ = this.local$closure$request;
+            var $receiver = this.local$closure$list.toSequence();
+            var any$result;
+            any$break: do {
+              var tmp$_0;
+              tmp$_0 = $receiver.iterator();
+              loop_label: while (tmp$_0.hasNext()) {
+                var element = tmp$_0.next();
+                var $receiver_0 = this.local$closure$elemList.toSequence();
+                var any$result_0;
+                any$break_0: do {
+                  var tmp$_1;
+                  tmp$_1 = $receiver_0.iterator();
+                  while (tmp$_1.hasNext()) {
+                    var element_0 = tmp$_1.next();
+                    if (Unificator.Companion.default.match(element, element_0)) {
+                      any$result_0 = true;
+                      break any$break_0;
+                    }}
+                  any$result_0 = false;
+                }
+                 while (false);
+                if (any$result_0) {
+                  any$result = true;
+                  break any$break;
+                }}
+              any$result = false;
+            }
+             while (false);
+            this.state_0 = 2;
+            this.result_0 = this.local$$receiver.yield_11rb$(tmp$.replyWithCondition(any$result, 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 ContainsAny$solve$lambda(closure$request_0, closure$list_0, closure$elemList_0) {
+    return function ($receiver_0, continuation_0, suspended) {
+      var instance = new Coroutine$ContainsAny$solve$lambda(closure$request_0, closure$list_0, closure$elemList_0, $receiver_0, this, continuation_0);
+      if (suspended)
+        return instance;
+      else
+        return instance.doResume(null);
+    };
+  }
+  ContainsAny.prototype.solve = function (request) {
+    var elemList = request.arguments.get_za3lpa$(0);
+    var list = request.arguments.get_za3lpa$(1);
+    if (!Kotlin.isType(list, List)) {
+      throw TypeError.Companion.forGoal(request.context, request.signature, TypeError$Expected.LIST, list);
+    }if (!Kotlin.isType(elemList, List)) {
+      throw TypeError.Companion.forGoal(request.context, request.signature, TypeError$Expected.LIST, list);
+    }return sequence(ContainsAny$solve$lambda(request, list, elemList));
+  };
+  ContainsAny.$metadata$ = {
+    kind: Kind_OBJECT,
+    simpleName: 'ContainsAny',
+    interfaces: [Primitive]
+  };
+  var ContainsAny_instance = null;
+  function ContainsAny_getInstance() {
+    if (ContainsAny_instance === null) {
+      new ContainsAny();
+    }return ContainsAny_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        ')));
@@ -5032,7 +5229,7 @@
   }
   function ArgumentationGraph() {
     ArgumentationGraph_instance = this;
-    this.theoryCode = trimIndent('\n    buildArgumentationGraph :-\n        buildArguments,\n        buildAttacks.\n    buildArguments :-\n    \tbuildArgumentsFromPremises,\n    \tbuildArgumentsFromEmptyRules,\n    \tfindall([RuleID, RuleBody, RuleHead], (\n    \t    parser::classic_rule(RuleID, RuleBody, RuleHead),\n    \t    \\+ emptyRule([RuleID, RuleBody, RuleHead])\n        ), Rules),\n    \tbuildArgumentsFromRules(b, Rules, Rules, n).\n    buildArgumentsFromPremises :-\n        findall(\n            _,\n            (\n                parser::classic_rule(PremiseID, Premise),\n                checkStrict(PremiseID, DefPrem),\n                ground(Premise),\n                context_assert(argument([[PremiseID], none, Premise, [], [[], [], DefPrem]])),\n                context_assert(conc(Premise) :- argument([[PremiseID], none, Premise, [], [[], [], DefPrem]])),\n                context_assert(newConc(a, Premise)),\n                utils::hash(argument([[PremiseID], none, Premise, [], [[], [], DefPrem]]), Id),\n                context_assert(arg(Id) :- 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                context_assert(conc(Premise) :- argument([[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]])),\n                context_assert(newConc(a, Premise)),\n                utils::hash(argument([[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]]), Id),\n                context_assert(arg(Id) :- argument([[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]]))\n            ),\n            _\n        ).\n    emptyRule([RuleID, Body, RuleHead]) :-\n        parser::classic_rule(RuleID, Body, RuleHead),\n        \\+ (member(X, Body), X \\= ~(_), X \\= prolog(_)),\n        checkPrologClauses(Body).\n    checkPrologClauses([]) :- !.\n    checkPrologClauses([~(_)|T]) :- checkPrologClauses(T), !.\n    checkPrologClauses([prolog(Check)|T]) :-\n        (callable(Check) -> call(Check); Check),\n        checkPrologClauses(T).\n    clean(Tn, Rules) :-\n        invert(Tn, Tx),\n        context_retract(newConc(Tx, _)),\n        buildArgumentsFromRules(Tx, Rules, Rules, n).\n    check_new(Tn, H) :-\n        copy_term(H, [_, RuleBody, _]),\n        member(prolog(_), RuleBody), !.\n    check_new(Tn, H) :-\n        copy_term(H, [_, RuleBody, _]),\n        member(X, RuleBody),\n        invert(Tn, Tx),\n        context_check(newConc(Tx, [X])).\n    invert(a, b).\n    invert(b, a).\n    buildArgumentsFromRules(_, Rules, [], n).\n    buildArgumentsFromRules(Tn, Rules, [], y) :- clean(Tn, Rules).\n    buildArgumentsFromRules(Tn, Rules, [H|T], _) :-\n        once(check_new(Tn, H)),\n        copy_term(H, HH),\n        findall(true, buildArgumentsFromRule(Tn, HH), R),\n        R \\== [],\n        buildArgumentsFromRules(Tn, Rules, T, y), !.\n    buildArgumentsFromRules(Tn, Rules, [_|T], X) :-\n        buildArgumentsFromRules(Tn, Rules, T, X).\n    buildArgumentsFromRule(Tn, [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        context_assert(conc(RuleHead) :- argument(NewArgument)),\n        context_assert(newConc(Tn, RuleHead)),\n    \tcontext_assert(argument(NewArgument)),\n    \tutils::hash(argument(NewArgument), Id),\n    \tcontext_assert(arg(Id) :- 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]) :- \\+ parser::check_strict(Id).\n    checkStrict(Id, []) :- parser::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, \\+ parser::check_strict(TopRule).\n    lastDefeasibleRules(Supports, TopRule, LastRules) :-\n    \tparser::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([~(_)|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(clause(conc([Statement]), 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(Conf, Head, Guard).\n    findPossibleAttackers([_, _, Head, _, _], Conf) :-\n        conflict(Conf, Head).\n    findPossibleAttackers([_, _, _, Prem, _], [Conf]) :-\n        member(~(Conf), Prem).\n    findPossibleAttackers([_, RuleID, _, _, _], [undercut(RuleID)]).\n    buildAttacks :-\n    \tbuildDirectAttacks,\n    \tbuildTransitiveAttacks.\n    buildDirectAttacks :-\n        findall(_, buildDirectAttack, _).\n    buildDirectAttack :-\n        context_check(argument(A)),\n        findPossibleAttackers(A, BB),\n    \tcontext_check(clause(conc(BB), 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    \tutils::hash(argument(A), IdA),\n    \tutils::hash(argument(B), IdB),\n    \tcontext_assert(att(IdB, IdA) :- attack(T, B, A, A)),\n    \tfail.\n    buildDirectAttack.\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        utils::hash(argument(A), IdA),\n        utils::hash(argument(C), IdC),\n        context_assert(att(IdA, IdC) :- attack(T, B, 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    expanded_conflict(HeadA, HeadB) :-\n        conflict(HeadA, HeadB).\n    expanded_conflict(HeadA, HeadB) :-\n        conflict(HeadA, HeadB, Guard),\n        (callable(Guard) -> call(Guard); Guard).\n    rebuts([IDPremisesA, RuleA, RuleHeadA, _, _], [IDPremisesB, RuleB, RuleHeadB, _, Info]) :-\n    \tRuleB \\== none,\n        Info \\== [[], [], []],\n    \texpanded_conflict(RuleHeadA, RuleHeadB).\n    contraryRebuts([IDPremisesA, RuleA, [RuleHeadA], _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n    \tRuleA \\== none,\n    \tRuleB \\== none,\n    \tmember(~(RuleHeadA), Body).\n    undermines([IDPremisesA, RuleA, RuleHeadA, _, _], [[IDPremiseB], none, RuleHeadB, _, Info]) :-\n    \tInfo \\== [[], [], []],\n    \texpanded_conflict(RuleHeadA, RuleHeadB).\n    contraryUndermines([IDPremisesA, none, [RuleHeadA], _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n    \tRuleB \\== none,\n    \tmember(~(RuleHeadA), Body).\n    undercuts([_, _, [undercut(RuleB)], _, _], [_, RuleB, _, _, [[RuleB], _, _]]).\n    check(-Atom).\n    conflict([Atom], [-Atom]) :- \\+ check(Atom).\n    conflict([-Atom], [Atom]).\n    conflict([o(Atom)], [o(-Atom)]) :- \\+ check(Atom).\n    conflict([o(-Atom)], [o(Atom)]).\n    conflict([p(Atom)], [o(-Atom)]) :- \\+ check(Atom).\n    conflict([o(-Atom)], [p(Atom)]).\n    conflict([p(-Atom)], [o(Atom)]).\n    conflict([o(Atom)], [p(-Atom)]) :- \\+ check(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    parser::classic_rule(RuleID, RuleBody, RuleHead),\n    \t    \\+ emptyRule([RuleID, RuleBody, RuleHead])\n        ), Rules),\n        findall(X, context_check(newConc(a, [X])), N),\n    \tbuildArgumentsFromRules(N, b, Rules, Rules, n).\n    buildArgumentsFromPremises :-\n        findall(\n            _,\n            (\n                parser::classic_rule(PremiseID, Premise),\n                checkStrict(PremiseID, DefPrem),\n                ground(Premise),\n                context_assert(argument([[PremiseID], none, Premise, [], [[], [], DefPrem]])),\n                context_assert(conc(Premise) :- argument([[PremiseID], none, Premise, [], [[], [], DefPrem]])),\n                context_assert(newConc(a, Premise)),\n                utils::hash(argument([[PremiseID], none, Premise, [], [[], [], DefPrem]]), Id),\n                context_assert(arg(Id) :- 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                context_assert(conc(RuleHead) :- argument([[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]])),\n                context_assert(newConc(a, RuleHead)),\n                utils::hash(argument([[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]]), Id),\n                context_assert(arg(Id) :- argument([[RuleID], RuleID, RuleHead, RulePrem, [DefRule, DefRule, []]]))\n            ),\n            _\n        ).\n    emptyRule([RuleID, Body, RuleHead]) :-\n        parser::classic_rule(RuleID, Body, RuleHead),\n        \\+ (member(X, Body), X \\= ~(_), X \\= prolog(_)),\n        checkPrologClauses(Body).\n    checkPrologClauses([]) :- !.\n    checkPrologClauses([~(_)|T]) :- checkPrologClauses(T), !.\n    checkPrologClauses([prolog(Check)|T]) :-\n        (callable(Check) -> call(Check); Check),\n        checkPrologClauses(T).\n    clean(Tn, Rules) :-\n        invert(Tn, Tx),\n        context_retract(newConc(Tx, _)),\n        findall(X, context_check(newConc(Tn, [X])), N),\n        buildArgumentsFromRules(N, Tx, Rules, Rules, n).\n    invert(a, b).\n    invert(b, a).\n    buildArgumentsFromRules(_, _, Rules, [], n) :- !.\n    buildArgumentsFromRules(_, Tn, Rules, [], y) :- !, clean(Tn, Rules).\n    buildArgumentsFromRules(N, Tn, Rules, [[Id, Body, Conc]|T], _) :-\n        utils::contains_any(Body, N),\n        findall(true, buildArgumentsFromRule(Tn, [Id, Body, Conc]), R),\n        R \\== [],\n        buildArgumentsFromRules(N, Tn, Rules, T, y), !.\n    buildArgumentsFromRules(N, Tn, Rules, [_|T], X) :-\n        buildArgumentsFromRules(N, Tn, Rules, T, X).\n    buildArgumentsFromRule(Tn, [RuleID, RuleBody, RuleHead]) :-\n    \truleBodyIsSupported(RuleID, RuleHead, RuleBody, RuleBody, [[], [], [], []], Argument),\n        context_assert(newConc(Tn, RuleHead)).\n    checkStrict(Id, []) :- parser::check_strict(Id), !.\n    checkStrict(Id, [Id]).\n    defRules(Id, Def, Def) :- parser::check_strict(Id), !.\n    defRules(Id, Def, [Id|Def]).\n    lastDefRules(Id, LDef, LDef) :- parser::check_strict(Id), !.\n    lastDefRules(Id, LDef, [Id]) :- Id \\== none, \\+ parser::check_strict(Id).\n    argumentInfo(RuleId, LDef, Def, Prem, [FLDef, FDef, FPrem]) :-\n        utils::sortDistinct(Prem, FPrem),\n        defRules(RuleId, Def, NDef),\n        utils::sortDistinct(NDef, FDef),\n        lastDefRules(RuleId, LDef, NLDef),\n        utils::sortDistinct(NLDef, FLDef).\n    ruleBodyIsSupported(RuleID, RuleHead, RuleBody, [], [TAll, TLDef, TDef, TPrem], Argument) :-\n        ground(RuleHead),\n        \\+ context_check(clause(conc(RuleHead), argument([_, RuleID, RuleHead, RuleBody, _]))),\n        utils::appendLists(TAll, All),\n        \\+ utils::contains(RuleID, All),\n        utils::appendLists(TLDef, LDef),\n        utils::appendLists(TDef, Def),\n        utils::appendLists(TPrem, Prem),\n        argumentInfo(RuleID, LDef, Def, Prem, Info),\n        utils::sort([RuleID|All], Rules),\n        Argument = [Rules, RuleID, RuleHead, RuleBody, Info],\n        context_assert(conc(RuleHead) :- argument(Argument)),\n        context_assert(argument(Argument)),\n        utils::hash(argument(Argument), Id),\n        context_assert(arg(Id) :- argument(Argument)).\n    ruleBodyIsSupported(RuleID, RuleHead, RuleBody, [~(_)|Others], Info, Argument) :-\n    \truleBodyIsSupported(RuleID, RuleHead, RuleBody, Others, Info, Argument).\n    ruleBodyIsSupported(RuleID, RuleHead, RuleBody, [prolog(Check)|Others], Info, Argument) :-\n    \t(callable(Check) -> call(Check); Check),\n    \truleBodyIsSupported(RuleID, RuleHead, RuleBody, Others, Info, Argument).\n    ruleBodyIsSupported(RuleId, RuleHead, RuleBody, [Statement|Others], [All, LDef, Def, Prem], Argument) :-\n        context_check(clause(conc([Statement]), argument([ArgumentID, RuleID, [Statement], Body, [NLDef, NDef, NPrem]]))),\n    \truleBodyIsSupported(RuleId, RuleHead, RuleBody, Others, [[ArgumentID|All], [NLDef|LDef], [NDef|Def], [NPrem|Prem]], Argument),\n    \tcontext_assert(support([ArgumentID, RuleID, [Statement], Body, [NLDef, NDef, NPrem]], Argument)).\n    findPossibleAttackers([_, _, Head, _, _], Conf) :-\n        conflict(Conf, Head, Guard).\n    findPossibleAttackers([_, _, Head, _, _], Conf) :-\n        conflict(Conf, Head).\n    findPossibleAttackers([_, _, _, Prem, _], [Conf]) :-\n        member(~(Conf), Prem).\n    findPossibleAttackers([_, RuleID, _, _, _], [undercut(RuleID)]).\n    buildAttacks :-\n    \tbuildDirectAttacks,\n    \tbuildTransitiveAttacks.\n    buildDirectAttacks :-\n        findall(_, buildDirectAttack, _).\n    buildDirectAttack :-\n        context_check(argument(A)),\n        findPossibleAttackers(A, BB),\n    \tcontext_check(clause(conc(BB), 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    \tutils::hash(argument(A), IdA),\n    \tutils::hash(argument(B), IdB),\n    \tcontext_assert(att(IdB, IdA) :- attack(T, B, A, A)),\n    \tfail.\n    buildDirectAttack.\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        utils::hash(argument(A), IdA),\n        utils::hash(argument(C), IdC),\n        context_assert(att(IdA, IdC) :- attack(T, B, 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    expanded_conflict(HeadA, HeadB) :-\n        conflict(HeadA, HeadB).\n    expanded_conflict(HeadA, HeadB) :-\n        conflict(HeadA, HeadB, Guard),\n        (callable(Guard) -> call(Guard); Guard).\n    rebuts([IDPremisesA, RuleA, RuleHeadA, _, _], [IDPremisesB, RuleB, RuleHeadB, _, Info]) :-\n    \tRuleB \\== none,\n        Info \\== [[], [], []],\n    \texpanded_conflict(RuleHeadA, RuleHeadB).\n    contraryRebuts([IDPremisesA, RuleA, [RuleHeadA], _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n    \tRuleA \\== none,\n    \tRuleB \\== none,\n    \tutils::contains(~(RuleHeadA), Body).\n    undermines([IDPremisesA, RuleA, RuleHeadA, _, _], [[IDPremiseB], none, RuleHeadB, _, Info]) :-\n    \tInfo \\== [[], [], []],\n    \texpanded_conflict(RuleHeadA, RuleHeadB).\n    contraryUndermines([IDPremisesA, none, [RuleHeadA], _, _], [IDPremisesB, RuleB, RuleHeadB, Body, Info]) :-\n    \tRuleB \\== none,\n    \tutils::contains(~(RuleHeadA), Body).\n    undercuts([_, _, [undercut(RuleB)], _, _], [_, RuleB, _, _, [[RuleB], _, _]]).\n    check(-Atom).\n    conflict([Atom], [-Atom]) :- \\+ check(Atom).\n    conflict([-Atom], [Atom]).\n    conflict([o(Atom)], [o(-Atom)]) :- \\+ check(Atom).\n    conflict([o(-Atom)], [o(Atom)]).\n    conflict([p(Atom)], [o(-Atom)]) :- \\+ check(Atom).\n    conflict([o(-Atom)], [p(Atom)]).\n    conflict([p(-Atom)], [o(Atom)]).\n    conflict([o(Atom)], [p(-Atom)]) :- \\+ check(Atom).\n    conflict([sup(X, Y)], [sup(Y, X)]).\n        ');
   }
   ArgumentationGraph.$metadata$ = {
     kind: Kind_OBJECT,
@@ -5545,6 +5742,12 @@
   Object.defineProperty(package$utils, 'ArgumentHash', {
     get: ArgumentHash_getInstance
   });
+  Object.defineProperty(package$utils, 'Contains', {
+    get: Contains_getInstance
+  });
+  Object.defineProperty(package$utils, 'ContainsAny', {
+    get: ContainsAny_getInstance
+  });
   var package$meta = package$core.meta || (package$core.meta = {});
   Object.defineProperty(package$meta, 'MetaInterpreterLib', {
     get: MetaInterpreterLib_getInstance
@@ -5808,21 +6011,17 @@
   PrologWithArgumentation.prototype.unifyWithOccurCheck = PrologScopeWithTheories.prototype.unifyWithOccurCheck;
   PrologWithArgumentation.prototype.var1 = PrologScopeWithTheories.prototype.var1;
   PrologWithArgumentation.prototype.write1 = PrologScopeWithTheories.prototype.write1;
-  PrologWithArgumentation.prototype.neq2 = PrologScopeWithTheories.prototype.neq2;
-  PrologWithArgumentation.prototype.nid2 = PrologScopeWithTheories.prototype.nid2;
-  PrologWithArgumentation.prototype.power = PrologScopeWithTheories.prototype.power;
-  PrologWithArgumentation.prototype.eq2 = PrologScopeWithTheories.prototype.eq2;
-  PrologWithArgumentation.prototype.arithNeq2 = PrologScopeWithTheories.prototype.arithNeq2;
-  PrologWithArgumentation.prototype.id2 = PrologScopeWithTheories.prototype.id2;
-  PrologWithArgumentation.prototype.arithEq2 = PrologScopeWithTheories.prototype.arithEq2;
-  PrologWithArgumentation.prototype.pow = PrologScopeWithTheories.prototype.pow;
   PrologWithArgumentation.prototype.anyAnd = PrologScopeWithTheories.prototype.anyAnd;
+  PrologWithArgumentation.prototype.arithEq2 = PrologScopeWithTheories.prototype.arithEq2;
+  PrologWithArgumentation.prototype.arithNeq2 = PrologScopeWithTheories.prototype.arithNeq2;
   PrologWithArgumentation.prototype.substitutionContainsKey = PrologScopeWithTheories.prototype.substitutionContainsKey;
   PrologWithArgumentation.prototype.substitutionContainsValue = PrologScopeWithTheories.prototype.substitutionContainsValue;
   PrologWithArgumentation.prototype.anyDiv = PrologScopeWithTheories.prototype.anyDiv;
+  PrologWithArgumentation.prototype.eq2 = PrologScopeWithTheories.prototype.eq2;
   PrologWithArgumentation.prototype.anyEqualsTo = PrologScopeWithTheories.prototype.anyEqualsTo;
   PrologWithArgumentation.prototype.anyGreaterThan = PrologScopeWithTheories.prototype.anyGreaterThan;
   PrologWithArgumentation.prototype.anyGreaterThanOrEqualsTo = PrologScopeWithTheories.prototype.anyGreaterThanOrEqualsTo;
+  PrologWithArgumentation.prototype.id2 = PrologScopeWithTheories.prototype.id2;
   PrologWithArgumentation.prototype.anyIf = PrologScopeWithTheories.prototype.anyIf;
   PrologWithArgumentation.prototype.anyIfVararg = PrologScopeWithTheories.prototype.anyIfVararg;
   PrologWithArgumentation.prototype.anyImpliedBy = PrologScopeWithTheories.prototype.anyImpliedBy;
@@ -5835,6 +6034,8 @@
   PrologWithArgumentation.prototype.anyMatches = PrologScopeWithTheories.prototype.anyMatches;
   PrologWithArgumentation.prototype.anyMguWith = PrologScopeWithTheories.prototype.anyMguWith;
   PrologWithArgumentation.prototype.anyMinus = PrologScopeWithTheories.prototype.anyMinus;
+  PrologWithArgumentation.prototype.neq2 = PrologScopeWithTheories.prototype.neq2;
+  PrologWithArgumentation.prototype.nid2 = PrologScopeWithTheories.prototype.nid2;
   PrologWithArgumentation.prototype.anyNonGreaterThan = PrologScopeWithTheories.prototype.anyNonGreaterThan;
   PrologWithArgumentation.prototype.anyNonLowerThan = PrologScopeWithTheories.prototype.anyNonLowerThan;
   PrologWithArgumentation.prototype.anyNotEqualsTo = PrologScopeWithTheories.prototype.anyNotEqualsTo;