diff --git a/reduct/boolean-reduct/cut-unnecessary-and.metta b/reduct/boolean-reduct/cut-unnecessary-and.metta
index 05b7e33c..c0c46078 100644
--- a/reduct/boolean-reduct/cut-unnecessary-and.metta
+++ b/reduct/boolean-reduct/cut-unnecessary-and.metta
@@ -13,23 +13,26 @@
 ;;            whether the transformation function is applied or not.
 ;; Example: input: POA ==> (AND (OR (AND B D) (NOT E))), parent ==> (OR C (AND (OR (AND B D) (NOT E))))
 ;;          output: ((OR C (AND B D) (NOT E)) () True)
-(: andCut (-> Expression Expression (Expression Expression Bool)))
+; (: andCut (-> Expression Expression (Expression Expression Bool)))
 (= (andCut $parent $current)
         (let*
           (
-              ; (() (println! (===Inside AndCut===)))
-              ; (() (println! (Current $current : Parent : $parent)))
+              ; ($log (println! (===Inside AndCut===)))
+              ; ($log' (println! (Current $current : Parent : $parent)))
               ($parentSec (collapse (removeEmptyAND (superpose $parent))))
               ($currentSec (if (=== $parent $current) $parentSec (collapse (removeEmptyAND (superpose $current)))))
               (($guardSet $child) (getLiteralChildren $currentSec))
-              ($tail (if-decons-expr-custom $child $h $t (cdr-atom $child) "No child"))
+              (($h $t) (if (== (get-metatype $child) Expression) (decons-atom $child) (() ())))
+              ($then (cdr-atom $child))
+              ($tail (if-decons-expr-custom $child $h $t $then "No child"))
+              ; ($log (println! ("Tail: " $tail)))
           )
           (if (and (== $tail ()) (== $guardSet ())) ;; Has no guardSet and has single child
               (let*
                   (
-                      ; (() (println! (===Inside AndCut===)))
-                      ; (() (println! (Current $current : Parent : $parent)))
-                      ($childFirst (if-decons-expr-custom $child $h $t $h (empty)))
+                      ; ($log (println! (===Inside AndCut===)))
+                      ; ($log' (println! (Current $current : Parent : $parent)))
+                      ($childFirst (if-decons-expr-custom $child $h $t $h ()))
                       (($grandLiterals $grandChildren) (getLiteralChildren $childFirst))
                       ($allLiterals (collapse (getGuardSet (superpose $grandChildren))))
                       ($common (intersections $allLiterals))
@@ -40,15 +43,15 @@
                                         (addChildren $updatedParent $grandChildren)))
                       ($updatedParent'' (addLiterals $updatedParent' $grandLiterals))
 
-                      ; (() (println! (=== Inside AndCut Log ===)))
-                      ; (() (println! (All Literals: $allLiterals)))
-                      ; (() (println! (GrandChildren: $grandChildren : GrandLiterals: $grandLiterals)))
-                      ; (() (println! (UpdatedParent: $updatedParent : UpdatedParent': $updatedParent' )))
-                      ; (() (println! (UpdatedParent'': $updatedParent'' )))
-                      ; (() (println! (ChildFirst: $childFirst)))
-                      ; (() (println! (Child: $child)))
-                      ; (() (println! (AllLiterals: $allLiterals)))
-                      ; (() (println! (Common: $common)))
+                      ; ($l (println! (===Inside AndCut Log===)))
+                      ; ($l (println! (All Literals: $allLiterals)))
+                      ; ($l (println! (GrandChildren: $grandChildren : GrandLiterals: $grandLiterals)))
+                      ; ($l (println! (UpdatedParent: $updatedParent : UpdatedParent': $updatedParent' )))
+                      ; ($l (println! (UpdatedParent'': $updatedParent'' )))
+                      ; ($l (println! (ChildFirst: $childFirst)))
+                      ; ($l (println! (Child: $child)))
+                      ; ($l (println! (AllLiterals: $allLiterals)))
+                      ; ($l (println! (Common: $common)))
 
                   )
                   (if (== $common ())
@@ -62,7 +65,7 @@
 )
 
 ;; Function to find intersections between all literals in a nested tuple
-(: intersections (-> Expression Expression))
+; (: intersections (-> Expression Expression))
 (= (intersections $nestedTuple)
    (case $nestedTuple 
      ((() $nestedTuple)
@@ -78,7 +81,7 @@
 
 ;; A helper function used to apply andCut in the until function.
 ;; This function keeps the state of the until function updated for a single function application.
-(: applyAndCut (-> (Expression Bool (Expression Expression)) (Expression Bool (Expression Expression))))
+; (: applyAndCut (-> (Expression Bool (Expression Expression)) (Expression Bool (Expression Expression))))
 (= (applyAndCut ($parent $bool ($child $remainingChildren)))
       (let*
         (
diff --git a/reduct/boolean-reduct/cut-unnecessary-or.metta b/reduct/boolean-reduct/cut-unnecessary-or.metta
index 7f84eeab..ee5713af 100644
--- a/reduct/boolean-reduct/cut-unnecessary-or.metta
+++ b/reduct/boolean-reduct/cut-unnecessary-or.metta
@@ -7,12 +7,12 @@
 ;;            are not met, it returns the state unchanged.
 ;; Example: input: POA ==> (OR (AND (NOT D))), parent => (AND B (OR (AND (NOT D))))
 ;;          output: ((AND B (NOT D)) () True)
-(: orCut (-> Expression Expression (Expression Expression Bool)))
+; (: orCut (-> Expression Expression (Expression Expression Bool)))
 (= (orCut $parent $current)
    (let*
      (
-      ;; (() (println! (=== Inside OrCut ===)))
-      ;; (() (println! (Parameters ==> Parent: $parent Current: $current)))
+      ($log (println! (==== Inside OrCut ====)))
+      ; ($log' (println! (Parameters ==> Parent: $parent Current: $current)))
      )
      (case $current
         (
@@ -31,7 +31,7 @@
 ;; A function to return the literals and children of any given node.
 ;; It is used for cases where we need all the subExpressions of AND & OR nodes.
 ;;    Expressions like (NOT A) doesn't have any subExpression and are treated as a literal.
-(: getSubExpression (-> Expression Expression))
+; (: getSubExpression (-> Expression Expression))
 (= (getSubExpression $exp)
    (case $exp
      (
@@ -52,7 +52,7 @@
 
 ;; A helper function used to apply orCut function in the until function.
 ;; This function keeps the state of the until function updated for a single function application.
-(: applyOrCut (-> (Expression Bool (Expression Expression)) (Expression Bool (Expression Expression))))
+; (: applyOrCut (-> (Expression Bool (Expression Expression)) (Expression Bool (Expression Expression))))
 (= (applyOrCut ($parent $bool ($child $remainingChildren)))
       (let*
         (
diff --git a/reduct/boolean-reduct/delete-inconsistent-handle.metta b/reduct/boolean-reduct/delete-inconsistent-handle.metta
index 42a54ac4..69cd0961 100644
--- a/reduct/boolean-reduct/delete-inconsistent-handle.metta
+++ b/reduct/boolean-reduct/delete-inconsistent-handle.metta
@@ -59,7 +59,7 @@
 )
 
 ;; This function is used to handle nested current expressions 
-(: applyDeleteIncons (-> Expression Expression Expression (Expression Expression Bool)))
+; (: applyDeleteIncons (-> Expression Expression Expression (Expression Expression Bool)))
 (= (applyDeleteIncons $parent $current $dominantSet)
     (let*
         (
@@ -71,12 +71,11 @@
         )
         (if (== $children ())
             ($newParent $newCurrent $applied)
-            ; (deleteInconsistentHandle $parent $current $dominantSet)
             (let*
                 (
-                    ; (() (println! (Applying DeleteIncons on children...)))
+                    ; ($log (println! (Applying DeleteIncons on children...)))
                     (($child $rest) (decons-atom $children))
-                    ; (() (println! (Child: $child Rest: $rest)))
+                    ; ($log' (println! (Child: $child Rest: $rest)))
                     ($grandChild (getChildrenExp $child))
                     (($UpdatedChildren $unwt $appliedOnChild)
                                         (if (== $grandChild ())
@@ -86,19 +85,19 @@
                                           )
                                         )
                     )
-                    ; (() (println! (UpdatedChildren: $UpdatedChildren)))
+                    ; ($log'' (println! (UpdatedChildren: $UpdatedChildren)))
                     (($updatedCurrent $updatedchild $appliedOnCurrent) (if (=== $child $UpdatedChildren) (deleteInconsistentHandle $newCurrent $child $dominantSet) ((findAndReplace $child $UpdatedChildren $newCurrent) $UpdatedChildren $appliedOnChild)))
                     ($updatedParent (findAndReplace $newCurrent $updatedCurrent $newParent))
-                    ; (()(println! (Updated Parent: $UpdatedParent : UpdatedCurrent: $updatedCurrent Bool: (any $appliedOnCurrent $appliedOnChild $applied) )))
+                    ; ($log''' (println! (Updated Parent: $updatedParent : UpdatedCurrent: $updatedCurrent Bool: (any $appliedOnCurrent $appliedOnChild $applied) )))
                 )
-                ; (applyDeleteIncons $UpdatedParent $updatedCurrent $dominantSet (any ($appliedOnCurrent $appliedOnChild $applied)) $rest)
-                (applyDeleteIncons $UpdatedParent $updatedCurrent $dominantSet $appliedOnCurrent $rest)
+                ; (applyDeleteIncons $updatedParent $updatedCurrent $dominantSet (any ($appliedOnCurrent $appliedOnChild $applied)) $rest)
+                (applyDeleteIncons $updatedParent $updatedCurrent $dominantSet $appliedOnCurrent $rest)
             )    
         )
     )
 )
 
-(: applyDeleteIncons (-> Expression Expression Expression Bool Expression (Expression Expression Bool)))
+; (: applyDeleteIncons (-> Expression Expression Expression Bool Expression (Expression Expression Bool)))
 (= (applyDeleteIncons $parent $current $dominantSet $applied $children)   
     (if (== $children ())
         ($parent $current $applied)
@@ -117,7 +116,7 @@
     )
 )
 
-(: applyDeleteIncons (-> Expression Expression Expression Expression Bool Bool (Expression Expression Bool)))
+; (: applyDeleteIncons (-> Expression Expression Expression Expression Bool Bool (Expression Expression Bool)))
 (= (applyDeleteIncons $parent $current $dominantSet $children $appliedToParent $checkingChild)
     (if (== $children ())
         (deleteInconsistentHandle $parent $current $dominantSet)
diff --git a/reduct/boolean-reduct/rte-helpers.metta b/reduct/boolean-reduct/rte-helpers.metta
index 37b5126b..271d1b22 100644
--- a/reduct/boolean-reduct/rte-helpers.metta
+++ b/reduct/boolean-reduct/rte-helpers.metta
@@ -14,32 +14,43 @@
 ;;                Only AND nodes have guard sets.
 ;; Example: (AND (NOT A) (NOT B) A) -> ( (NOT A) (NOT B) A)
 (= (getGuardSet $exp)
-   (if-decons-expr-custom $exp $h $t
-       (if (== $h OR)
-           ()                
-           (getLiterals $exp)) 
-       $exp))  
+   (if (== (get-metatype $exp) Expression)
+    (let ($h $t) (decons-atom $exp)
+      (eval (if-decons-expr-custom $exp $h $t
+          (if (== $h OR)
+              ()               
+              (getLiterals $exp))
+          $exp))
+    )
+    $exp)
+)
 
 
 ;; A function similar to the getGuardSet function but returns a
 ;;    non deterministic list instead of a collapsed atom.
 ;; Example: (AND (NOT A) (NOT B) A) -> [(NOT A), (NOT B), A]
 (= (getGuardSetND $exp)
-   (if-decons-expr-custom $exp $h $t
-       (if (== $h OR)
-           (empty)             
-           (getLiteralsND $exp)) 
-       $exp))  
+   (if (or (not (== $exp ())) (== (get-metatype $exp) Expression))
+      (let*
+        (
+         (($h $t) (decons-atom $exp))
+         ($then (if (== $h OR) (empty) (getLiteralsND $exp)))
+         ($result (if-decons-expr-custom $exp $h $t $then $exp))
+        )
+        $result
+      )
+      $exp
+    )
+)  
 
 (= (addLiterals $exp $elements)
    (let*
      (
         ($op (car-atom $exp))
         ($guardSet (getLiterals $exp))
-        ($newGuardSet (unionAtom $guardSet $elements))
+        ($newGuardSet (union-atom $guardSet $elements))
         ($newGuardSet' (collapse (unique (superpose $newGuardSet))))
-        ($updatedSubExpression (unionAtom $newGuardSet' (getChildrenExp $exp)))
-
+        ($updatedSubExpression (union-atom $newGuardSet' (getChildrenExp $exp)))
         ($newExp (cons-atom $op $updatedSubExpression))
      )
      $newExp
@@ -75,8 +86,8 @@
      (
         ($op (car-atom $exp))
         ($oldChildren (getChildrenExp $exp))
-        ($newChildren (concatTuple $oldChildren $children))
-        ($updatedSubExpression (concatTuple (getLiterals $exp) $newChildren))
+        ($newChildren (eval (concatTuple $oldChildren $children)))
+        ($updatedSubExpression (eval (concatTuple (getLiterals $exp) $newChildren)))
         ($newExp (cons-atom $op $updatedSubExpression))
         
         ; (() (println! (OldChildren: $oldChildren)))
diff --git a/reduct/boolean-reduct/tests/cut-unnecessary-and-testold.metta b/reduct/boolean-reduct/tests/cut-unnecessary-and-test.metta
similarity index 88%
rename from reduct/boolean-reduct/tests/cut-unnecessary-and-testold.metta
rename to reduct/boolean-reduct/tests/cut-unnecessary-and-test.metta
index 48fb510e..ab88c869 100644
--- a/reduct/boolean-reduct/tests/cut-unnecessary-and-testold.metta
+++ b/reduct/boolean-reduct/tests/cut-unnecessary-and-test.metta
@@ -1,9 +1,6 @@
-! (register-module! ../../../../metta-moses) 
-
-! (import! &self metta-moses:reduct/boolean-reduct:rte-helpers)
-! (import! &self metta-moses:utilities:general-helpers)
-! (import! &self metta-moses:reduct/boolean-reduct:cut-unnecessary-and)
-
+!(import! &self ../rte-helpers)
+!(import! &self ../../../utilities/general-helpers)
+!(import! &self ../cut-unnecessary-and)
 
 
 ;; Test 01
@@ -18,7 +15,7 @@
     ((OR (AND (OR (AND C D) (AND C F))) A) (AND (OR (AND C D) (AND C F))) False)
 )
 
-;; Test 03
+; ;; Test 03
 !(assertEqual
     (andCut (OR A (AND (OR (AND B C) (AND E F) (AND G H))) F) (AND (OR (AND B C) (AND E F) (AND G H))))
     ((OR A F (AND B C) (AND E F) (AND G H)) () True)
diff --git a/reduct/boolean-reduct/tests/cut-unnecessary-or-test.metta b/reduct/boolean-reduct/tests/cut-unnecessary-or-test.metta
new file mode 100644
index 00000000..163baffb
--- /dev/null
+++ b/reduct/boolean-reduct/tests/cut-unnecessary-or-test.metta
@@ -0,0 +1,46 @@
+!(import! &self ../../../utilities/general-helpers)
+!(import! &self ../rte-helpers)
+!(import! &self ../cut-unnecessary-or)
+
+;Test 01: OR expressions with one child - orCut will be applied
+!(assertEqual 
+     (orCut (AND B (OR (AND (NOT D)))) (OR (AND (NOT D))))
+     ((AND B (NOT D)) () True)
+)
+
+!(assertEqual
+    (orCut (AND C (OR A)) (OR A))
+    ((AND C A) () True)
+)
+
+!(assertEqual
+     (orCut (AND H (OR (AND A B (AND A B))) (NOT E)) (OR (AND A B (AND A B))))
+     ((AND H (NOT E) A B (AND A B)) () True)
+)
+
+!(assertEqual
+     (orCut (AND (OR (AND A (NOT A) (OR A B )))) (OR (AND A (NOT A) (OR A B ))))
+     ((AND A (NOT A) (OR A B)) () True)
+)
+
+!(assertEqual
+    (orCut (AND (OR (AND A (OR A (NOT B))))) (OR (AND A (OR A (NOT B)))))
+    ((AND A (OR A (NOT B))) () True)
+)
+
+;Test 02:OR expression with more than one children - orCut won't be applied
+!(assertEqual
+     (orCut (AND (OR A B)) (OR A B))
+     ((AND (OR A B)) (OR A B) False)
+)
+;Test 03: AND and NOT expressions - orCut won't be applied
+!(assertEqual
+    (orCut (OR (AND (AND A (OR A (NOT B))))) (AND (AND A (OR A (NOT B)))))
+    ((OR (AND (AND A (OR A (NOT B))))) (AND (AND A (OR A (NOT B)))) False)
+)
+!(assertEqual
+    (orCut (AND (NOT (AND A (OR A (NOT B))))) (NOT (AND A (OR A (NOT B)))))
+    ((AND (NOT (AND A (OR A (NOT B))))) (NOT (AND A (OR A (NOT B)))) False)
+)
+
+!(assertEqual (orCut (AND A B (OR C D)) ()) ((AND A B (OR C D)) () False))
diff --git a/reduct/boolean-reduct/tests/cut-unnecessary-or-testold.metta b/reduct/boolean-reduct/tests/cut-unnecessary-or-testold.metta
deleted file mode 100644
index d01bf347..00000000
--- a/reduct/boolean-reduct/tests/cut-unnecessary-or-testold.metta
+++ /dev/null
@@ -1,47 +0,0 @@
-! (register-module! ../../../../metta-moses) 
-! (import! &self metta-moses:utilities:general-helpers)
-! (import! &self metta-moses:reduct/boolean-reduct:rte-helpers)
-! (import! &self metta-moses:reduct/boolean-reduct:cut-unnecessary-or)
-
-;Test 01: OR expressions with one child - orCut will be applied
-!(assertEqualToResult 
-     (orCut (AND B (OR (AND (NOT D)))) (OR (AND (NOT D))))
-     (((AND B (NOT D)) () True))
-)
-
-!(assertEqualToResult
-    (orCut (AND C (OR A)) (OR A))
-    (((AND C A) () True))
-)
-
-!(assertEqualToResult
-     (orCut (AND H (OR (AND A B (AND A B))) (NOT E)) (OR (AND A B (AND A B))))
-     (((AND H (NOT E) A B (AND A B)) () True))
-)
-
-!(assertEqualToResult
-     (orCut (AND (OR (AND A (NOT A) (OR A B )))) (OR (AND A (NOT A) (OR A B ))))
-     (((AND A (NOT A) (OR A B)) () True))
-)
-
-!(assertEqualToResult
-    (orCut (AND (OR (AND A (OR A (NOT B))))) (OR (AND A (OR A (NOT B)))))
-    (((AND A (OR A (NOT B))) () True))
-)
-
-;Test 02:OR expression with more than one children - orCut won't be applied
-!(assertEqualToResult
-     (orCut (AND (OR A B)) (OR A B))
-     (((AND (OR A B)) (OR A B) False))
-)
-;Test 03: AND and NOT expressions - orCut won't be applied
-!(assertEqualToResult
-    (orCut (OR (AND (AND A (OR A (NOT B))))) (AND (AND A (OR A (NOT B)))))
-    (((OR (AND (AND A (OR A (NOT B))))) (AND (AND A (OR A (NOT B)))) False))
-)
-!(assertEqualToResult
-    (orCut (AND (NOT (AND A (OR A (NOT B))))) (NOT (AND A (OR A (NOT B)))))
-    (((AND (NOT (AND A (OR A (NOT B))))) (NOT (AND A (OR A (NOT B)))) False))
-)
-
-!(assertEqualToResult (orCut (AND A B (OR C D)) ()) (((AND A B (OR C D)) () False)))
diff --git a/reduct/boolean-reduct/tests/delete-inconsistent-test.metta b/reduct/boolean-reduct/tests/delete-inconsistent-test.metta
new file mode 100644
index 00000000..f5422192
--- /dev/null
+++ b/reduct/boolean-reduct/tests/delete-inconsistent-test.metta
@@ -0,0 +1,47 @@
+; ; !(register-module! ../../../../metta-moses)
+
+!(import! &self ../../../utilities/general-helpers)
+!(import! &self ../rte-helpers)
+!(import! &self ../delete-inconsistent-handle)
+
+; ;; Testcases
+
+; ;; Test 01 - for an empty set and literal
+!(assertEqual (deleteInconsistentHandle (AND) () ()) ((AND) () False))
+!(assertEqual (deleteInconsistentHandle (AND (A)) (A) (B C)) ((AND (A)) (A) False))
+!(assertEqual (deleteInconsistentHandle (AND (A)) (A) (B C)) ((AND (A)) (A) False))
+!(assertEqual (deleteInconsistentHandle (AND (A)) (A) ((NOT A) B C)) ((AND (AND)) (AND) True)) ;; replaces A with AND
+!(assertEqual (deleteInconsistentHandle (AND (A)) (A) (B C (NOT A))) ((AND (AND)) (AND) True)) ;; 
+!(assertEqual (deleteInconsistentHandle (AND A) A (B C)) ((AND A) A False))
+
+;; Test 02 - for OR and NOT expressions
+!(assertEqual (deleteInconsistentHandle (AND (NOT (AND A B))) (NOT (AND A B)) ()) ((AND (NOT (AND A B))) (NOT (AND A B)) False))
+!(assertEqual (deleteInconsistentHandle (AND (OR A B (NOT A))) (OR A B (NOT A)) ()) ((AND (OR A B (NOT A))) (OR A B (NOT A)) False))
+!(assertEqual (deleteInconsistentHandle (AND (OR A B)) (OR A B) ((NOT A) B)) ((AND (OR A B)) (OR A B) False))
+!(assertEqual (deleteInconsistentHandle (AND (OR (AND A B) (AND A B) (NOT A))) (OR (AND A B) (AND A B) (NOT A)) ()) ((AND (OR (AND A B) (AND A B) (NOT A))) (OR (AND A B) (AND A B) (NOT A)) False))
+
+;; Test 03 - for different AND expressions
+!(assertEqual (deleteInconsistentHandle (OR (AND)) (AND) ()) ((OR (AND)) (AND) False))
+!(assertEqual (deleteInconsistentHandle (OR (AND (OR A B) (AND A B) A B)) (AND (OR A B) (AND A B) A B) ()) ((OR (AND (OR A B) (AND A B) A B)) (AND (OR A B) (AND A B) A B) False))
+!(assertEqual (deleteInconsistentHandle (OR (AND (OR A B) (AND A B) A B)) (AND (OR A B) (AND A B) A B) ((NOT B) A C)) ((OR (AND)) (AND) True)) ;; replaces the entire child of the OR to (AND) 
+!(assertEqual (deleteInconsistentHandle (OR (AND (NOT A) (NOT B) A)) (AND (NOT A) (NOT B) A) ()) ((OR (AND)) (AND) True)) ;; same with the above
+!(assertEqual (deleteInconsistentHandle (OR A B (AND E A) (AND (NOT A) (NOT B) C)) (AND (NOT A) (NOT B) C) ()) ((OR A B (AND E A) (AND (NOT A) (NOT B) C)) (AND (NOT A) (NOT B) C) False))
+!(assertEqual (deleteInconsistentHandle (OR A B (AND E A) (AND (NOT A) (NOT B) C)) (AND (NOT A) (NOT B) C) (F B G)) ((OR A B (AND E A) (AND)) (AND) True)) ;;
+!(assertEqual (deleteInconsistentHandle (OR A B (AND A (AND A B) (OR A B) (NOT B))) (AND A (AND A B) (OR A B) (NOT B)) ()) ((OR A B (AND A (AND A B) (OR A B) (NOT B))) (AND A (AND A B) (OR A B) (NOT B)) False))
+!(assertEqual (deleteInconsistentHandle (OR A B (AND A (AND A B) (OR A B) (NOT B))) (AND A (AND A B) (OR A B) (NOT B)) (B C E)) ((OR A B (AND)) (AND) True))
+!(assertEqual (deleteInconsistentHandle (OR (AND A (AND A B) (NOT E) (OR A B) (NOT B))) (AND A (AND A B) (NOT E) (OR A B) (NOT B)) (C E)) ((OR (AND)) (AND) True))
+!(assertEqual (deleteInconsistentHandle (OR (AND (AND A B) A)) (AND (AND A B) A) ()) ((OR (AND (AND A B) A)) (AND (AND A B) A) False))
+!(assertEqual (deleteInconsistentHandle (OR (AND (AND A B) A)) (AND (AND A B) A) ((NOT B))) ((OR (AND (AND A B) A)) (AND (AND A B) A) False))
+!(assertEqual (deleteInconsistentHandle (OR (AND A B (NOT B))) (AND A B (NOT B)) ()) ((OR (AND)) (AND) True))
+!(assertEqual (deleteInconsistentHandle (OR (AND A (NOT B))) (AND A (NOT B)) (B)) ((OR (AND)) (AND) True))
+!(assertEqual (deleteInconsistentHandle (OR (AND A (NOT B))) (AND A (NOT B)) (A)) ((OR (AND A (NOT B))) (AND A (NOT B)) False))
+!(assertEqual (deleteInconsistentHandle (OR (AND A (NOT B))) (AND A (NOT B)) (D F G)) ((OR (AND A (NOT B))) (AND A (NOT B)) False))
+!(assertEqual (deleteInconsistentHandle (OR (AND A (NOT A) (NOT B))) (AND A (NOT A) (NOT B)) ()) ((OR (AND)) (AND) True))
+!(assertEqual (deleteInconsistentHandle (OR (AND (NOT A) (NOT B))) (AND (NOT A) (NOT B)) (C F A G)) ((OR (AND)) (AND) True))
+!(assertEqual (deleteInconsistentHandle (OR (AND (NOT A) (NOT B))) (AND (NOT A) (NOT B)) (C B F G)) ((OR (AND)) (AND) True))
+!(assertEqual (deleteInconsistentHandle (OR (AND (NOT A) (NOT B))) (AND (NOT A) (NOT B)) (C B A G)) ((OR (AND)) (AND) True))
+!(assertEqual (deleteInconsistentHandle (OR (AND (NOT A) (NOT B) C G)) (AND (NOT A) (NOT B) C G) (C B A G)) ((OR (AND)) (AND) True))
+
+
+!(assertEqual (applyDeleteIncons (OR (AND A B (NOT A) B)) (AND A B (NOT A) B) (A)) ((OR (AND)) (AND) True))
+!(assertEqual (applyDeleteIncons (AND (OR (AND A B (NOT A) B))) (OR (AND A B (NOT A) B)) (A)) ((AND (OR (AND))) (OR (AND)) True))
diff --git a/reduct/boolean-reduct/tests/delete-inconsistent-testold.metta b/reduct/boolean-reduct/tests/delete-inconsistent-testold.metta
deleted file mode 100644
index 05e629fb..00000000
--- a/reduct/boolean-reduct/tests/delete-inconsistent-testold.metta
+++ /dev/null
@@ -1,47 +0,0 @@
-! (register-module! ../../../../metta-moses)
-
-! (import! &self metta-moses:utilities:general-helpers)
-! (import! &self metta-moses:reduct/boolean-reduct:rte-helpers)
-! (import! &self metta-moses:reduct/boolean-reduct:delete-inconsistent-handle)
-
-;; Testcases
-
-;; Test 01 - for an empty set and literal
-! (assertEqualToResult (deleteInconsistentHandle (AND) () ()) (((AND) () False)))
-! (assertEqualToResult (deleteInconsistentHandle (AND (A)) (A) (B C)) (((AND (A)) (A) False)))
-! (assertEqualToResult (deleteInconsistentHandle (AND (A)) (A) (B C)) (((AND (A)) (A) False)))
-! (assertEqualToResult (deleteInconsistentHandle (AND (A)) (A) ((NOT A) B C)) (((AND (AND)) (AND) True))) ;; replaces A with AND
-! (assertEqualToResult (deleteInconsistentHandle (AND (A)) (A) (B C (NOT A))) (((AND (AND)) (AND) True))) ;; 
-! (assertEqualToResult (deleteInconsistentHandle (AND A) A (B C)) (((AND A) A False)))
-
-;; Test 02 - for OR and NOT expressions
-! (assertEqualToResult (deleteInconsistentHandle (AND (NOT (AND A B))) (NOT (AND A B)) ()) (((AND (NOT (AND A B))) (NOT (AND A B)) False)))
-! (assertEqualToResult (deleteInconsistentHandle (AND (OR A B (NOT A))) (OR A B (NOT A)) ()) (((AND (OR A B (NOT A))) (OR A B (NOT A)) False)))
-! (assertEqualToResult (deleteInconsistentHandle (AND (OR A B)) (OR A B) ((NOT A) B)) (((AND (OR A B)) (OR A B) False)))
-! (assertEqualToResult (deleteInconsistentHandle (AND (OR (AND A B) (AND A B) (NOT A))) (OR (AND A B) (AND A B) (NOT A)) ()) (((AND (OR (AND A B) (AND A B) (NOT A))) (OR (AND A B) (AND A B) (NOT A)) False)))
-
-;; Test 03 - for different AND expressions
-! (assertEqualToResult (deleteInconsistentHandle (OR (AND)) (AND) ()) (((OR (AND)) (AND) False)))
-! (assertEqualToResult (deleteInconsistentHandle (OR (AND (OR A B) (AND A B) A B)) (AND (OR A B) (AND A B) A B) ()) (((OR (AND (OR A B) (AND A B) A B)) (AND (OR A B) (AND A B) A B) False)))
-! (assertEqualToResult (deleteInconsistentHandle (OR (AND (OR A B) (AND A B) A B)) (AND (OR A B) (AND A B) A B) ((NOT B) A C)) (((OR (AND)) (AND) True))) ;; replaces the entire child of the OR to (AND) 
-! (assertEqualToResult (deleteInconsistentHandle (OR (AND (NOT A) (NOT B) A)) (AND (NOT A) (NOT B) A) ()) (((OR (AND)) (AND) True))) ;; same with the above
-! (assertEqualToResult (deleteInconsistentHandle (OR A B (AND E A) (AND (NOT A) (NOT B) C)) (AND (NOT A) (NOT B) C) ()) (((OR A B (AND E A) (AND (NOT A) (NOT B) C)) (AND (NOT A) (NOT B) C) False)))
-! (assertEqualToResult (deleteInconsistentHandle (OR A B (AND E A) (AND (NOT A) (NOT B) C)) (AND (NOT A) (NOT B) C) (F B G)) (((OR A B (AND E A) (AND)) (AND) True))) ;;
-! (assertEqualToResult (deleteInconsistentHandle (OR A B (AND A (AND A B) (OR A B) (NOT B))) (AND A (AND A B) (OR A B) (NOT B)) ()) (((OR A B (AND A (AND A B) (OR A B) (NOT B))) (AND A (AND A B) (OR A B) (NOT B)) False)))
-! (assertEqualToResult (deleteInconsistentHandle (OR A B (AND A (AND A B) (OR A B) (NOT B))) (AND A (AND A B) (OR A B) (NOT B)) (B C E)) (((OR A B (AND)) (AND) True)))
-! (assertEqualToResult (deleteInconsistentHandle (OR (AND A (AND A B) (NOT E) (OR A B) (NOT B))) (AND A (AND A B) (NOT E) (OR A B) (NOT B)) (C E)) (((OR (AND)) (AND) True)))
-! (assertEqualToResult (deleteInconsistentHandle (OR (AND (AND A B) A)) (AND (AND A B) A) ()) (((OR (AND (AND A B) A)) (AND (AND A B) A) False)))
-! (assertEqualToResult (deleteInconsistentHandle (OR (AND (AND A B) A)) (AND (AND A B) A) ((NOT B))) (((OR (AND (AND A B) A)) (AND (AND A B) A) False)))
-! (assertEqualToResult (deleteInconsistentHandle (OR (AND A B (NOT B))) (AND A B (NOT B)) ()) (((OR (AND)) (AND) True)))
-! (assertEqualToResult (deleteInconsistentHandle (OR (AND A (NOT B))) (AND A (NOT B)) (B)) (((OR (AND)) (AND) True)))
-! (assertEqualToResult (deleteInconsistentHandle (OR (AND A (NOT B))) (AND A (NOT B)) (A)) (((OR (AND A (NOT B))) (AND A (NOT B)) False)))
-! (assertEqualToResult (deleteInconsistentHandle (OR (AND A (NOT B))) (AND A (NOT B)) (D F G)) (((OR (AND A (NOT B))) (AND A (NOT B)) False)))
-! (assertEqualToResult (deleteInconsistentHandle (OR (AND A (NOT A) (NOT B))) (AND A (NOT A) (NOT B)) ()) (((OR (AND)) (AND) True)))
-! (assertEqualToResult (deleteInconsistentHandle (OR (AND (NOT A) (NOT B))) (AND (NOT A) (NOT B)) (C F A G)) (((OR (AND)) (AND) True)))
-! (assertEqualToResult (deleteInconsistentHandle (OR (AND (NOT A) (NOT B))) (AND (NOT A) (NOT B)) (C B F G)) (((OR (AND)) (AND) True)))
-! (assertEqualToResult (deleteInconsistentHandle (OR (AND (NOT A) (NOT B))) (AND (NOT A) (NOT B)) (C B A G)) (((OR (AND)) (AND) True)))
-! (assertEqualToResult (deleteInconsistentHandle (OR (AND (NOT A) (NOT B) C G)) (AND (NOT A) (NOT B) C G) (C B A G)) (((OR (AND)) (AND) True)))
-
-
-!(assertEqualToResult (applyDeleteIncons (OR (AND A B (NOT A) B)) (AND A B (NOT A) B) (A)) (((OR (AND)) (AND) True)))
-!(assertEqualToResult (applyDeleteIncons (AND (OR (AND A B (NOT A) B))) (OR (AND A B (NOT A) B)) (A)) (((AND (OR (AND))) (OR (AND)) True)))
diff --git a/reduct/boolean-reduct/tests/helper-functions-test.metta b/reduct/boolean-reduct/tests/helper-functions-test.metta
new file mode 100644
index 00000000..22647ea5
--- /dev/null
+++ b/reduct/boolean-reduct/tests/helper-functions-test.metta
@@ -0,0 +1,154 @@
+!(import! &self ../../../utilities/general-helpers)
+!(import! &self ../rte-helpers)
+!(import! &self ../delete-inconsistent-handle)
+!(import! &self ../zero-constraint-subsumption)
+!(import! &self ../cut-unnecessary-or)
+
+ ;; Test for getGuardSet
+
+ ;; Tests for new getGuardSet
+ ;; Test 01 - getGuardSet of a literal
+!(assertEqual (getGuardSet A) A)
+!(assertEqual (getGuardSet (A)) (A))
+
+ ; Test 02 - getGuardSet of OR and NOT expressions
+!(assertEqual (getGuardSet (OR)) ())
+!(assertEqual (getGuardSet (OR A B (NOT A))) ())
+!(assertEqual (getGuardSet (OR (AND A B) (AND A B) (NOT A))) ())
+
+ ;; Test 03 - getGuardSet of AND expressions
+!(assertEqual (getGuardSet (AND)) ())
+!(assertEqual (getGuardSet (AND A)) (A))
+!(assertEqual (getGuardSet (AND (NOT A) (NOT B) A)) ((NOT A) (NOT B) A))
+!(assertEqual (getGuardSet (AND A (AND A B) (OR A B) (NOT B))) (A (NOT B)))
+!(assertEqual (getGuardSet (AND (AND A B) A) ) (A))
+!(assertEqual (getGuardSet (AND A B (NOT B)) ) (A B (NOT B) ))
+!(assertEqual (getGuardSet (AND A (NOT A) (NOT B))) (A (NOT A) (NOT B) ))
+!(assertEqual (getGuardSet (AND (NOT A) A B)) ((NOT A) A B))
+
+ ;; Tests for getGuardSetND
+ ;; Test 01 - getGuardSet of a literal
+!(assertEqual (getGuardSetND A) A)
+!(assertEqual (getGuardSetND (A)) A)
+
+ ;; Test 02 - getGuardSetND of OR and NOT expressions
+!(assertEqual (collapse (getGuardSetND (OR))) ())
+!(assertEqual (collapse (getGuardSetND (OR A B (NOT A)))) ())
+!(assertEqual (collapse (getGuardSetND (OR (AND A B) (AND A B) (NOT A)))) ())
+
+ ;; Test 03 - getGuardSetND of AND expressions
+!(assertEqual (collapse (getGuardSetND (AND))) ())
+!(assertEqual (collapse (getGuardSetND (AND A))) (A))
+!(assertEqual (collapse (getGuardSetND (AND (NOT A) (NOT B) A))) ((NOT A) (NOT B) A))
+!(assertEqual (collapse (getGuardSetND (AND A (AND A B) (OR A B) (NOT B)))) (A (NOT B)))
+!(assertEqual (collapse (getGuardSetND (AND (AND A B) A))) (A))
+!(assertEqual (collapse (getGuardSetND (AND A B (NOT B)))) (A B (NOT B)))
+!(assertEqual (collapse (getGuardSetND (AND A (NOT A) (NOT B)))) (A (NOT A) (NOT B)))
+!(assertEqual (collapse (getGuardSetND (AND (NOT A) A B))) ((NOT A) A B))
+
+;; Test for isConsistentExp ;; Not Tested because it uses deleteInconsistentHandle
+!(assertEqual (isConsistentExp ()) True)
+!(assertEqual (isConsistentExp A) True)
+!(assertEqual (isConsistentExp (A)) True)
+!(assertEqual (isConsistentExp (AND)) True)
+!(assertEqual (isConsistentExp (AND (OR A B) (AND A B) A B)) True)
+!(assertEqual (isConsistentExp (AND (NOT A) (NOT B) A)) False)
+!(assertEqual (isConsistentExp (AND A B (NOT B))) False)
+!(assertEqual (isConsistentExp (OR A B (NOT A))) False)
+!(assertEqual (isConsistentExp (OR (AND A B) (AND A B) (NOT A))) True)
+!(assertEqual (isConsistentExp (AND A (NOT A) (NOT B))) False)
+
+!(assertEqual (nodeHasChildOrGuard (AND A B)) True)
+!(assertEqual (nodeHasChildOrGuard (AND A B C)) True)
+!(assertEqual (nodeHasChildOrGuard (OR A B C)) True)
+!(assertEqual (nodeHasChildOrGuard (AND)) False)
+
+;; Test for filterLiterals
+!(assertEqual (filterLiterals A) A)
+!(assertEqual (collapse (filterLiterals (AND A B C))) (collapse (empty)))
+!(assertEqual (filterLiterals (NOT A)) (NOT A))
+!(assertEqual (collaspe (filterLiterals AND)) (collapse (empty)))
+!(assertEqual (collapse (filterLiterals OR)) (collapse (empty)))
+
+;; Test for filterChildren
+
+!(assertEqual (collapse (filterChildren A)) (collapse (empty)))
+!(assertEqual (collapse (filterChildren (NOT A))) (collapse (empty)))
+!(assertEqual (filterChildren (OR A B C)) (OR A B C))
+!(assertEqual (filterChildren (AND A B C)) (AND A B C))
+!(assertEqual (filterChildren (OR A)) (OR A))
+
+;; Test for getChildren
+
+!(assertEqual (getChildrenExp ()) ())
+!(assertEqual (getChildrenExp (AND A B (OR A B) C E (OR E F) (OR A) (NOT F))) ((OR A B) (OR E F) (OR A)))
+!(assertEqual (getChildrenExp (AND (OR A B) A B C E (NOT F) (OR E F) (OR A))) ((OR A B) (OR E F) (OR A)))
+!(assertEqual (getChildrenExp (OR A B (AND A B) C E (AND E F) (AND A) (NOT F))) ((AND A B) (AND E F) (AND A)))
+!(assertEqual (getChildrenExp (OR (AND A B) A B C E (NOT F) (AND E F) (AND A))) ((AND A B) (AND E F) (AND A)))
+
+;; Test for getLiterals
+!(assertEqual (getLiterals ()) ())
+!(assertEqual (getLiterals (AND A)) (A))
+!(assertEqual (getLiterals (OR A)) (A))
+!(assertEqual (getLiterals (AND A B (OR A B) C E (OR E F) (OR A) (NOT F))) (A B C E (NOT F)))
+!(assertEqual (getLiterals (AND (OR A B) A B C E (NOT F) (OR E F) (OR A))) (A B C E (NOT F)))
+!(assertEqual (getLiterals (OR A B (AND A B) C E (AND E F) (AND A) (NOT F))) (A B C E (NOT F)))
+!(assertEqual (getLiterals (OR (AND A B) A B C E (NOT F) (AND E F) (AND A))) (A B C E (NOT F)))
+
+
+;; Test for getLiteralsND
+!(assertEqual (collapse (getLiteralsND ())) (()))
+!(assertEqual (collapse (getLiteralsND (AND A))) (A))
+!(assertEqual (collapse (getLiteralsND (OR A))) (A))
+!(assertEqual (collapse (getLiteralsND (AND A B (OR A B) C E (OR E F) (OR A) (NOT F)))) (A B C E (NOT F)))
+!(assertEqual (collapse (getLiteralsND (AND (OR A B) A B C E (NOT F) (OR E F) (OR A)))) (A B C E (NOT F)))
+!(assertEqual (collapse (getLiteralsND (OR A B (AND A B) C E (AND E F) (AND A) (NOT F)))) (A B C E (NOT F)))
+!(assertEqual (collapse (getLiteralsND (OR (AND A B) A B C E (NOT F) (AND E F) (AND A)))) (A B C E (NOT F)))
+
+;; Test for getLiteralChildren
+!(assertEqual (getLiteralChildren ()) (() ()))
+!(assertEqual (getLiteralChildren (AND A)) ((A) ()))
+!(assertEqual (getLiteralChildren (OR A)) ((A) ()))
+!(assertEqual (getLiteralChildren (AND A B (OR A B) C E (OR E F) (OR A) (NOT F))) ((A B C E (NOT F)) ((OR A B) (OR E F) (OR A))))
+!(assertEqual (getLiteralChildren (AND (OR A B) A B C E (NOT F) (OR E F) (OR A))) ((A B C E (NOT F)) ((OR A B) (OR E F) (OR A))))
+!(assertEqual (getLiteralChildren (OR A B (AND A B) C E (AND E F) (AND A) (NOT F))) ((A B C E (NOT F)) ((AND A B) (AND E F) (AND A))))
+!(assertEqual (getLiteralChildren (OR (AND A B) A B C E (NOT F) (AND E F) (AND A))) ((A B C E (NOT F)) ((AND A B) (AND E F) (AND A))))
+
+;; Test for addLiterals
+!(assertEqual (addLiterals (AND A B C (OR A B) E F) (A B G)) (AND A B C E F G (OR A B)))
+!(assertEqual (addLiterals (OR A B C (AND A B) E F) (A B G)) (OR A B C E F G (AND A B)))
+!(assertEqual (addLiterals (AND A B (OR A B)) (Z)) (AND A B Z (OR A B)))
+!(assertEqual (addLiterals (OR (AND A B) A B) (Z)) (OR A B Z (AND A B)))
+!(assertEqual (addLiterals (AND A B C (OR A B)) (A B C)) (AND A B C (OR A B)))
+!(assertEqual (addLiterals (AND A (OR A B) B C) (E F G)) (AND A B C E F G (OR A B)))
+
+;; Test for addChildren
+!(assertEqual (addChildren (AND A B C) ()) (AND A B C))
+!(assertEqual (addChildren (OR A B C) ()) (OR A B C))
+!(assertEqual (addChildren (OR) ((AND B C))) (OR (AND B C)))
+!(assertEqual (addChildren (AND) ((OR B C))) (AND (OR B C)))
+!(assertEqual (addChildren (AND (OR A B)) ((OR C D) (OR E F))) (AND (OR A B) (OR C D) (OR E F)))
+!(assertEqual (addChildren (OR (AND A B)) ((AND C D) (AND E F))) (OR (AND A B) (AND C D) (AND E F)))
+!(assertEqual (addChildren (AND A B C (OR A B)) ((OR A E) (OR B C) (OR A B E (AND A F)))) (AND A B C (OR A B) (OR A E) (OR B C) (OR A B E (AND A F))))
+!(assertEqual (addChildren (OR A B C (AND A B)) ((AND A E) (AND B C) (AND A B E (OR A F)))) (OR A B C (AND A B) (AND A E) (AND B C) (AND A B E (OR A F))))
+!(assertEqual (addChildren (AND A (OR A B) B C) ((OR B C))) (AND A B C (OR A B) (OR B C)))
+!(assertEqual (addChildren (OR A (AND A B) B C) ((AND B C))) (OR A B C (AND A B) (AND B C)))
+!(assertEqual (addChildren (OR A B C) ((AND A E) (AND B C) (AND A B E (OR A F)))) (OR A B C (AND A E) (AND B C) (AND A B E (OR A F))))
+
+;; Test for foldl
+!(assertEqual (foldl-l + 0 (1 2 3 4 5)) 15)
+!(assertEqual (foldl-l * 1 (2 2 2 2)) 16)
+!(assertEqual (foldl-l * 1 ()) 1)
+
+;; Test for any
+!(assertEqual (any (True False False)) True)
+!(assertEqual (any (False True False)) True)
+!(assertEqual (any (False False True)) True)
+!(assertEqual (any (False False False)) False)
+!(assertEqual (any (False False False False False False False)) False)
+!(assertEqual (any (False False True False False False False)) True)
+
+; ;; Test for getSubExpression ;; Not tested because it uses cutUnnecessaryOr
+!(assertEqual (getSubExpression (NOT A)) ())
+!(assertEqual (getSubExpression (OR A B (AND C D) (AND E F))) (A B (AND C D) (AND E F)))
+!(assertEqual (getSubExpression (AND A B (OR C D) (OR E F))) (A B (OR C D) (OR E F)))
diff --git a/reduct/boolean-reduct/tests/helper-functions-testold.metta b/reduct/boolean-reduct/tests/helper-functions-testold.metta
deleted file mode 100644
index 297f0410..00000000
--- a/reduct/boolean-reduct/tests/helper-functions-testold.metta
+++ /dev/null
@@ -1,156 +0,0 @@
-! (register-module! ../../../../metta-moses)
-
-! (import! &self metta-moses:utilities:general-helpers)
-! (import! &self metta-moses:reduct/boolean-reduct:rte-helpers)
-! (import! &self metta-moses:reduct/boolean-reduct:delete-inconsistent-handle)
-! (import! &self metta-moses:reduct/boolean-reduct:zero-constraint-subsumption)
-! (import! &self metta-moses:reduct/boolean-reduct:cut-unnecessary-or)
-
- ;; Test for getGuardSet
-
- ;; Tests for new getGuardSet
- ;; Test 01 - getGuardSet of a literal
-! (assertEqual (getGuardSet A) A)
-! (assertEqualToResult (getGuardSet (A)) ((A)))
-
- ;; Test 02 - getGuardSet of OR and NOT expressions
-! (assertEqualToResult (getGuardSet (OR)) ( ()))
-! (assertEqualToResult (getGuardSet (OR A B (NOT A))) ( ()))
-! (assertEqualToResult (getGuardSet (OR (AND A B) (AND A B) (NOT A))) ( ()))
-
- ;; Test 03 - getGuardSet of AND expressions
-! (assertEqualToResult (getGuardSet (AND)) ( ()))
-! (assertEqualToResult (getGuardSet (AND A)) ( (A)))
-! (assertEqualToResult (getGuardSet (AND (NOT A) (NOT B) A)) ( ( (NOT A) (NOT B) A)))
-! (assertEqualToResult (getGuardSet (AND A (AND A B) (OR A B) (NOT B))) ( ( A (NOT B))))
-! (assertEqualToResult (getGuardSet (AND (AND A B) A) ) ( (A)))
-! (assertEqualToResult (getGuardSet (AND A B (NOT B)) ) ( (  A B (NOT B) )))
-! (assertEqualToResult (getGuardSet (AND A (NOT A) (NOT B))) ( ( A (NOT A) (NOT B) )))
-! (assertEqualToResult (getGuardSet (AND (NOT A) A B)) ( ( (NOT A) A B)))
-
- ;; Tests for getGuardSetND
- ;; Test 01 - getGuardSet of a literal
-! (assertEqual (getGuardSetND A) A)
-! (assertEqualToResult (getGuardSetND (A)) (A))
-
- ;; Test 02 - getGuardSetND of OR and NOT expressions
-! (assertEqualToResult (getGuardSetND (OR)) ())
-! (assertEqualToResult (getGuardSetND (OR A B (NOT A))) ())
-! (assertEqualToResult (getGuardSetND (OR (AND A B) (AND A B) (NOT A))) ())
-
- ;; Test 03 - getGuardSetND of AND expressions
-! (assertEqualToResult (getGuardSetND (AND)) ())
-! (assertEqualToResult (getGuardSetND (AND A)) (A))
-! (assertEqualToResult (getGuardSetND (AND (NOT A) (NOT B) A)) ((NOT A) (NOT B) A))
-! (assertEqualToResult (getGuardSetND (AND A (AND A B) (OR A B) (NOT B))) (A (NOT B)))
-! (assertEqualToResult (getGuardSetND (AND (AND A B) A) ) (A))
-! (assertEqualToResult (getGuardSetND (AND A B (NOT B)) ) (A B (NOT B)))
-! (assertEqualToResult (getGuardSetND (AND A (NOT A) (NOT B))) (A (NOT A) (NOT B)))
-! (assertEqualToResult (getGuardSetND (AND (NOT A) A B)) ((NOT A) A B))
-
-;; Test for isConsistentExp
-! (assertEqualToResult (isConsistentExp ()) (True))
-! (assertEqualToResult (isConsistentExp A) (True))
-! (assertEqualToResult (isConsistentExp (A)) (True))
-! (assertEqualToResult (isConsistentExp (AND)) (True))
-! (assertEqualToResult (isConsistentExp (AND (OR A B) (AND A B) A B)) (True))
-! (assertEqualToResult (isConsistentExp (AND (NOT A) (NOT B) A)) (False))
-! (assertEqualToResult (isConsistentExp (AND A B (NOT B))) (False))
-! (assertEqualToResult (isConsistentExp (OR A B (NOT A))) (False))
-! (assertEqualToResult (isConsistentExp (OR (AND A B) (AND A B) (NOT A))) (True))
-! (assertEqualToResult (isConsistentExp (AND A (NOT A) (NOT B))) (False))
-
-! (assertEqualToResult (nodeHasChildOrGuard (AND A B)) (True))
-! (assertEqualToResult (nodeHasChildOrGuard (AND A B C)) (True))
-! (assertEqualToResult (nodeHasChildOrGuard (OR A B C)) (True))
-! (assertEqualToResult (nodeHasChildOrGuard (AND)) (False))
-
-;; Test for filterLiterals
-! (assertEqual (filterLiterals A) A)
-! (assertEqual (filterLiterals (AND A B C)) (empty))
-! (assertEqual (filterLiterals (NOT A)) (NOT A))
-! (assertEqual (filterLiterals AND) (empty))
-! (assertEqual (filterLiterals OR) (empty))
-
-;; Test for filterChildren
-
-! (assertEqual (filterChildren A) (empty))
-! (assertEqual (filterChildren (NOT A)) (empty))
-! (assertEqual (filterChildren (OR A B C)) (OR A B C))
-! (assertEqual (filterChildren (AND A B C)) (AND A B C))
-! (assertEqual (filterChildren (OR A)) (OR A))
-
-;; Test for getChildren
-
-! (assertEqual (getChildrenExp ()) ())
-! (assertEqual (getChildrenExp (AND A B (OR A B) C E (OR E F) (OR A) (NOT F))) ((OR A B) (OR E F) (OR A)))
-! (assertEqual (getChildrenExp (AND (OR A B) A B C E (NOT F) (OR E F) (OR A))) ((OR A B) (OR E F) (OR A)))
-! (assertEqual (getChildrenExp (OR A B (AND A B) C E (AND E F) (AND A) (NOT F))) ((AND A B) (AND E F) (AND A)))
-! (assertEqual (getChildrenExp (OR (AND A B) A B C E (NOT F) (AND E F) (AND A))) ((AND A B) (AND E F) (AND A)))
-
-;; Test for getLiterals
-! (assertEqual (getLiterals ()) ())
-! (assertEqual (getLiterals (AND A)) (A))
-! (assertEqual (getLiterals (OR A)) (A))
-! (assertEqual (getLiterals (AND A B (OR A B) C E (OR E F) (OR A) (NOT F))) (A B C E (NOT F)))
-! (assertEqual (getLiterals (AND (OR A B) A B C E (NOT F) (OR E F) (OR A))) (A B C E (NOT F)))
-! (assertEqual (getLiterals (OR A B (AND A B) C E (AND E F) (AND A) (NOT F))) (A B C E (NOT F)))
-! (assertEqual (getLiterals (OR (AND A B) A B C E (NOT F) (AND E F) (AND A))) (A B C E (NOT F)))
-
-
-;; Test for getLiteralsND
-! (assertEqualToResult (getLiteralsND ()) (()))
-! (assertEqualToResult (getLiteralsND (AND A)) (A))
-! (assertEqualToResult (getLiteralsND (OR A)) (A))
-! (assertEqualToResult (getLiteralsND (AND A B (OR A B) C E (OR E F) (OR A) (NOT F))) (A B C E (NOT F)))
-! (assertEqualToResult (getLiteralsND (AND (OR A B) A B C E (NOT F) (OR E F) (OR A))) (A B C E (NOT F)))
-! (assertEqualToResult (getLiteralsND (OR A B (AND A B) C E (AND E F) (AND A) (NOT F))) (A B C E (NOT F)))
-! (assertEqualToResult (getLiteralsND (OR (AND A B) A B C E (NOT F) (AND E F) (AND A))) (A B C E (NOT F)))
-
-;; Test for getLiteralChildren
-! (assertEqual (getLiteralChildren ()) (() ()))
-! (assertEqual (getLiteralChildren (AND A)) ((A) ()))
-! (assertEqual (getLiteralChildren (OR A)) ((A) ()))
-! (assertEqual (getLiteralChildren (AND A B (OR A B) C E (OR E F) (OR A) (NOT F))) ((A B C E (NOT F)) ((OR A B) (OR E F) (OR A))))
-! (assertEqual (getLiteralChildren (AND (OR A B) A B C E (NOT F) (OR E F) (OR A))) ((A B C E (NOT F)) ((OR A B) (OR E F) (OR A))))
-! (assertEqual (getLiteralChildren (OR A B (AND A B) C E (AND E F) (AND A) (NOT F))) ((A B C E (NOT F)) ((AND A B) (AND E F) (AND A))))
-! (assertEqual (getLiteralChildren (OR (AND A B) A B C E (NOT F) (AND E F) (AND A))) ((A B C E (NOT F)) ((AND A B) (AND E F) (AND A))))
-
-;; Test for addLiterals
-! (assertEqual (addLiterals (AND A B C (OR A B) E F) (A B G)) (AND A B C E F G (OR A B)))
-! (assertEqual (addLiterals (OR A B C (AND A B) E F) (A B G)) (OR A B C E F G (AND A B)))
-! (assertEqual (addLiterals (AND A B (OR A B)) (Z)) (AND A B Z (OR A B)))
-! (assertEqual (addLiterals (OR (AND A B) A B) (Z)) (OR A B Z (AND A B)))
-! (assertEqual (addLiterals (AND A B C (OR A B)) (A B C)) (AND A B C (OR A B)))
-! (assertEqual (addLiterals (AND A (OR A B) B C) (E F G)) (AND A B C E F G (OR A B)))
-
-;; Test for addChildren
-! (assertEqual (addChildren (AND A B C) ()) (AND A B C))
-! (assertEqual (addChildren (OR A B C) ()) (OR A B C))
-! (assertEqual (addChildren (OR) ((AND B C))) (OR (AND B C)))
-! (assertEqual (addChildren (AND) ((OR B C))) (AND (OR B C)))
-! (assertEqual (addChildren (AND (OR A B)) ((OR C D) (OR E F))) (AND (OR A B) (OR C D) (OR E F)))
-! (assertEqual (addChildren (OR (AND A B)) ((AND C D) (AND E F))) (OR (AND A B) (AND C D) (AND E F)))
-! (assertEqual (addChildren (AND A B C (OR A B)) ((OR A E) (OR B C) (OR A B E (AND A F)))) (AND A B C (OR A B) (OR A E) (OR B C) (OR A B E (AND A F))))
-! (assertEqual (addChildren (OR A B C (AND A B)) ((AND A E) (AND B C) (AND A B E (OR A F)))) (OR A B C (AND A B) (AND A E) (AND B C) (AND A B E (OR A F))))
-! (assertEqual (addChildren (AND A (OR A B) B C) ((OR B C))) (AND A B C (OR A B) (OR B C)))
-! (assertEqual (addChildren (OR A (AND A B) B C) ((AND B C))) (OR A B C (AND A B) (AND B C)))
-! (assertEqual (addChildren (OR A B C) ((AND A E) (AND B C) (AND A B E (OR A F)))) (OR A B C (AND A E) (AND B C) (AND A B E (OR A F))))
-
-;; Test for foldl
-!(assertEqual (foldl + 0 (1 2 3 4 5)) 15)
-!(assertEqual (foldl * 1 (2 2 2 2)) 16)
-!(assertEqual (foldl * 1 ()) 1)
-
-;; Test for any
-!(assertEqual (any (True False False)) True)
-!(assertEqual (any (False True False)) True)
-!(assertEqual (any (False False True)) True)
-!(assertEqual (any (False False False)) False)
-!(assertEqual (any (False False False False False False False)) False)
-!(assertEqual (any (False False True False False False False)) True)
-
-;; Test for getSubExpression
-!(assertEqual (getSubExpression (NOT A)) ())
-!(assertEqual (getSubExpression (OR A B (AND C D) (AND E F))) (A B (AND C D) (AND E F)))
-!(assertEqual (getSubExpression (AND A B (OR C D) (OR E F))) (A B (OR C D) (OR E F)))
diff --git a/scripts/run-tests.py b/scripts/run-tests.py
index 09413e41..9b0c8ce7 100644
--- a/scripts/run-tests.py
+++ b/scripts/run-tests.py
@@ -35,7 +35,11 @@ def extract_and_print(result, path, idx) -> bool:
 
     # Treat exit code 0 as success, anything else as failure
     if result.returncode == 0:
-        extracted = "test passed"
+        if "❌" in extracted:
+            has_failure = True
+            extracted = f"test failed (output: {extracted})"
+        else:
+            extracted = "test passed"
     else:
         has_failure = True
         extracted = f"test failed (output: {extracted})"
diff --git a/utilities/general-helpers.metta b/utilities/general-helpers.metta
index 12cdae9a..ed0277e0 100644
--- a/utilities/general-helpers.metta
+++ b/utilities/general-helpers.metta
@@ -65,7 +65,8 @@
 (= (~= $a $b) (not (== $a $b)))
 ;Function to cocatinate two tuples (A B) (C D) ==> (A B C D)
 ;; (: concatTuple (-> Expression Expression Expression))
- (= (concatTuple $x $y) (collapse (union (superpose $x) (superpose $y)))) ;; FIX: No longer working on version 0.2.3
+(= (concatTuple $x $y) (union-atom $x $y))
+;  (= (concatTuple $x $y) (collapse (union (superpose $x) (superpose $y)))) ;; FIX: No longer working on version 0.2.3
 (: ++ (-> Expression Expression Expression))
 (= (++ $x $y)
    (case ((isSymbol $x) (isSymbol $y))
@@ -125,11 +126,11 @@
 (= (findAndReplace $old $new $list) ;; FIX: No longer working on version 0.2.3
     ; (let*
     ;   (
-        ; (() (println! ""))
-        ; (() (println! (==> === Inside findAndReplace === <==)))
-        ; (() (println! (Parameters ==> Old: $old New: $new List: $list)))
-        ; (() (println! (Result ==> (collapse (replace $old $new (superpose $list))))))
-        ; (() (println! ""))
+    ;     ($log (println! ""))
+    ;     ($log' (println! (==> === Inside findAndReplace === <==)))
+    ;     ($log'' (println! (Parameters ==> Old: $old New: $new List: $list)))
+    ;     ($log''' (println! (Result ==> (collapse (replace $old $new (superpose $list))))))
+    ;     ($log'''' (println! ""))
     ;   )
       (if (== () (subtraction-atom $old $list)) 
         $new
@@ -216,7 +217,7 @@
 ; ;; Example: input ==> (True True False), output ==> True
 ; ;;          input ==> (False False False), output ==> False
 ; ;;          input ==> (False True False), output ==> True
-(: any (-> Atom Bool))
+; (: any (-> Atom Bool))
 (= (any $bools) (is-member True $bools))
 
 ;; Fix curry is not working in petta 
@@ -713,13 +714,17 @@
 (if (== $tail ()) $updatedMap (expToMMap $tail $updatedMap $compFunc))))
 
 ;; A trick function to make chain reduce when using union-atom
+;; This is causing infinite loop in some cases. use the direct union-atom instead.
 ; (: (-> unionAtom (-> Expression Expression Expression)))
-(= (unionAtom $x $y) (union-atom $x $y))
-(= (unionAtom $a $b) 
-    (if-decons-expr-custom $a $head $tail
-        (chain (unionAtom $tail $b) $rest
-            (cons-atom $head $rest))
-        $b))
+; (= (unionAtom $x $y) (union-atom $x $y))
+; (= (unionAtom $a $b)
+;     (if-decons-expr-custom $a $head $tail
+;         ; (trace! ("Done With chain") 
+;         (chain (unionAtom $tail $b) $rest
+;             (cons-atom $head $rest))
+;             ; )
+;         $b)
+; )
 
 ;; helper function to generate list of numbers ranging from 0 to n
 ;; (: genList (-> Number Expression))
diff --git a/utilities/tests/ordered-set-test.metta b/utilities/tests/ordered-set-testold.metta
similarity index 100%
rename from utilities/tests/ordered-set-test.metta
rename to utilities/tests/ordered-set-testold.metta