code: function(FeAdd, FeDel, F, R) {
          var newExplicitFacts, resolvedExplicitFacts, validUpdateResults,
              FiAdd = [], Rins = [], deferred = q.defer(),
              Fi = Logics.getOnlyImplicitFacts(F), Fe,
  
              startAlgorithm = function() {
                  if(newExplicitFacts.length > 0) {
                      evaluationLoop(F);
                  } else {
                      deferred.resolve({
                          additions: resolvedExplicitFacts,
                          deletions: []
                      });
                  }
              },
  
              evaluationLoop = function() {
                  F = Utils.uniques(F, Fi);
                  Rins = Logics.restrictRuleSet(R, F);
                  Solver.evaluateRuleSet(Rins, F, true)
                      .then(function(values) {
                          FiAdd = values.cons;                        
                          if (Logics.unify(FiAdd, Fi)) {
                              setTimeout(evaluationLoop, 1);
                          } else {
                              deferred.resolve({
                                  additions: newExplicitFacts.concat(resolvedExplicitFacts, Fi),
                                  deletions: []
                              });
                          }
                      });
              };
  
          // Returns new explicit facts to be added
          validUpdateResults = Logics.updateValidTags(F, FeAdd, FeDel);
          newExplicitFacts = validUpdateResults.new;
          resolvedExplicitFacts = validUpdateResults.resolved;
          F = F.concat(newExplicitFacts);
          startAlgorithm();
  
          return deferred.promise;
      }
docs: Tags newly inferred facts, and (un)validates updated ones.
  Explicit facts are 'validity'-tagged, while
  implicit ones are 'causedBy'-tagged.
  @param FeAdd
  @param FeDel
  @param F
  @param R
  @returns {{additions: *, deletions: Array}}