diff --git a/src/AstTranslator.cpp b/src/AstTranslator.cpp
index 357cf36a3ac..9f8e39b5c65 100644
--- a/src/AstTranslator.cpp
+++ b/src/AstTranslator.cpp
@@ -291,11 +291,11 @@ std::unique_ptr<RamCondition> AstTranslator::translateConstraint(
                     binRel.getOperator(), std::move(valLHS), std::move(valRHS));
         }
 
-        /** for negations */
-        std::unique_ptr<RamCondition> visitNegation(const AstNegation& neg) override {
+        /** for provenance negation */
+        std::unique_ptr<RamCondition> visitProvenanceNegation(const AstProvenanceNegation& neg) override {
             const auto* atom = neg.getAtom();
             size_t auxiliaryArity = translator.getEvaluationArity(atom);
-            assert(auxiliaryArity <= atom->getArity() && "auxiliary arity out of bounds");
+            assert(auxiliaryArity < atom->getArity() && "auxiliary arity out of bounds");
             size_t arity = atom->getArity() - auxiliaryArity;
             std::vector<std::unique_ptr<RamExpression>> values;
 
@@ -303,22 +303,24 @@ std::unique_ptr<RamCondition> AstTranslator::translateConstraint(
             for (size_t i = 0; i < arity; i++) {
                 values.push_back(translator.translateValue(args[i], index));
             }
-            for (size_t i = 0; i < auxiliaryArity; i++) {
+            // we don't care about the provenance columns when doing the existence check
+            if (Global::config().has("provenance")) {
+                // undefined value for rule number
                 values.push_back(std::make_unique<RamUndefValue>());
+                // add the height annotation for provenanceNotExists
+                for (size_t h = 0; h + 1 < auxiliaryArity; h++) {
+                    values.push_back(translator.translateValue(args[arity + h + 1], index));
+                }
             }
-            if (arity > 0) {
-                return std::make_unique<RamNegation>(std::make_unique<RamExistenceCheck>(
-                        translator.translateRelation(atom), std::move(values)));
-            } else {
-                return std::make_unique<RamEmptinessCheck>(translator.translateRelation(atom));
-            }
+            return std::make_unique<RamNegation>(std::make_unique<RamProvenanceExistenceCheck>(
+                    translator.translateRelation(atom), std::move(values)));
         }
 
-        /** for provenance negation */
-        std::unique_ptr<RamCondition> visitProvenanceNegation(const AstProvenanceNegation& neg) override {
+        /** for negations */
+        std::unique_ptr<RamCondition> visitNegation(const AstNegation& neg) override {
             const auto* atom = neg.getAtom();
             size_t auxiliaryArity = translator.getEvaluationArity(atom);
-            assert(auxiliaryArity < atom->getArity() && "auxiliary arity out of bounds");
+            assert(auxiliaryArity <= atom->getArity() && "auxiliary arity out of bounds");
             size_t arity = atom->getArity() - auxiliaryArity;
             std::vector<std::unique_ptr<RamExpression>> values;
 
@@ -326,17 +328,15 @@ std::unique_ptr<RamCondition> AstTranslator::translateConstraint(
             for (size_t i = 0; i < arity; i++) {
                 values.push_back(translator.translateValue(args[i], index));
             }
-            // we don't care about the provenance columns when doing the existence check
-            if (Global::config().has("provenance")) {
-                // undefined value for rule number
+            for (size_t i = 0; i < auxiliaryArity; i++) {
                 values.push_back(std::make_unique<RamUndefValue>());
-                // add the height annotation for provenanceNotExists
-                for (size_t h = 0; h + 1 < auxiliaryArity; h++) {
-                    values.push_back(translator.translateValue(args[arity + h + 1], index));
-                }
             }
-            return std::make_unique<RamNegation>(std::make_unique<RamProvenanceExistenceCheck>(
-                    translator.translateRelation(atom), std::move(values)));
+            if (arity > 0) {
+                return std::make_unique<RamNegation>(std::make_unique<RamExistenceCheck>(
+                        translator.translateRelation(atom), std::move(values)));
+            } else {
+                return std::make_unique<RamEmptinessCheck>(translator.translateRelation(atom));
+            }
         }
     };
     return ConstraintTranslator(*this, index)(*lit);
@@ -532,13 +532,6 @@ std::unique_ptr<RamOperation> AstTranslator::ProvenanceClauseTranslator::createO
             for (AstArgument* arg : atom->getArguments()) {
                 values.push_back(translator.translateValue(arg, valueIndex));
             }
-        } else if (auto neg = dynamic_cast<AstNegation*>(lit)) {
-            for (AstArgument* arg : neg->getAtom()->getArguments()) {
-                values.push_back(translator.translateValue(arg, valueIndex));
-            }
-        } else if (auto con = dynamic_cast<AstBinaryConstraint*>(lit)) {
-            values.push_back(translator.translateValue(con->getLHS(), valueIndex));
-            values.push_back(translator.translateValue(con->getRHS(), valueIndex));
         } else if (auto neg = dynamic_cast<AstProvenanceNegation*>(lit)) {
             size_t auxiliaryArity = translator.getEvaluationArity(neg->getAtom());
             for (size_t i = 0; i < neg->getAtom()->getArguments().size() - auxiliaryArity; ++i) {
@@ -548,6 +541,13 @@ std::unique_ptr<RamOperation> AstTranslator::ProvenanceClauseTranslator::createO
             for (size_t i = 0; i < auxiliaryArity; ++i) {
                 values.push_back(std::make_unique<RamSignedConstant>(-1));
             }
+        } else if (auto neg = dynamic_cast<AstNegation*>(lit)) {
+            for (AstArgument* arg : neg->getAtom()->getArguments()) {
+                values.push_back(translator.translateValue(arg, valueIndex));
+            }
+        } else if (auto con = dynamic_cast<AstBinaryConstraint*>(lit)) {
+            values.push_back(translator.translateValue(con->getLHS(), valueIndex));
+            values.push_back(translator.translateValue(con->getRHS(), valueIndex));
         }
     }
 
diff --git a/src/ast/AstVisitor.h b/src/ast/AstVisitor.h
index 61c39b2429c..bd060aa7d2c 100644
--- a/src/ast/AstVisitor.h
+++ b/src/ast/AstVisitor.h
@@ -98,8 +98,8 @@ struct AstVisitor : public ast_visitor_tag {
 
         // literals
         FORWARD(Atom)
-        FORWARD(Negation)
         FORWARD(ProvenanceNegation)
+        FORWARD(Negation)
         FORWARD(BooleanConstraint)
         FORWARD(BinaryConstraint)
 
diff --git a/src/ram/RamVisitor.h b/src/ram/RamVisitor.h
index 33875703f7e..714769fb8b5 100644
--- a/src/ram/RamVisitor.h
+++ b/src/ram/RamVisitor.h
@@ -99,8 +99,8 @@ struct RamVisitor : public ram_visitor_tag {
         FORWARD(True);
         FORWARD(False);
         FORWARD(EmptinessCheck);
-        FORWARD(ExistenceCheck);
         FORWARD(ProvenanceExistenceCheck);
+        FORWARD(ExistenceCheck);
         FORWARD(Conjunction);
         FORWARD(Negation);
         FORWARD(Constraint);
@@ -218,8 +218,8 @@ struct RamVisitor : public ram_visitor_tag {
     LINK(Conjunction, Condition);
     LINK(Negation, Condition);
     LINK(Constraint, Condition);
-    LINK(ExistenceCheck, AbstractExistenceCheck);
     LINK(ProvenanceExistenceCheck, AbstractExistenceCheck);
+    LINK(ExistenceCheck, AbstractExistenceCheck);
     LINK(EmptinessCheck, Condition);
     LINK(AbstractExistenceCheck, Condition);
 
diff --git a/src/ram/analysis/RamIndexAnalysis.cpp b/src/ram/analysis/RamIndexAnalysis.cpp
index 4a63228b7ec..b7cdbdc78bd 100644
--- a/src/ram/analysis/RamIndexAnalysis.cpp
+++ b/src/ram/analysis/RamIndexAnalysis.cpp
@@ -412,8 +412,9 @@ SearchSignature RamIndexAnalysis::getSearchSignature(
     auto auxiliaryArity = provExistCheck->getRelation().getAuxiliaryArity();
 
     // values.size() - auxiliaryArity because we discard the height annotations
-    auto const numSig = values.size() - auxiliaryArity;
-    return searchSignature(auxiliaryArity, values.begin(), values.begin() + numSig);
+    auto const numSig = values.size(); // - auxiliaryArity;
+    // return searchSignature(auxiliaryArity, values.begin(), values.begin() + numSig);
+    return searchSignature(provExistCheck->getRelation().getArity(), provExistCheck->getValues());
 }
 
 SearchSignature RamIndexAnalysis::getSearchSignature(const RamExistenceCheck* existCheck) const {