occam-verify-cli 0.0.942 → 0.0.944

package/src/premise.js

@@ -1,6 +1,5 @@
 "use strict";
 
-import LocalContext from "./context/local";
 import metaLevelUnifier from "./unifier/metaLevel";
 
 import { match } from "./utilities/array";
@@ -22,15 +21,12 @@ export default class Premise {
     return this.statementNode;
   }
 
-  unifyStatement(statementNode, substitutions, fileContext, localContext) {
+  unifyStatement(statementNodeB, substitutions, localContextA, localContextB) {
     let statementUnified = false;
 
     if (this.statementNode !== null) {
       const nodeA = this.statementNode,  ///
-            nodeB = statementNode,  ///
-            fileContextA = fileContext, ///
-            localContextA = LocalContext.fromFileContext(fileContextA),
-            localContextB = localContext,  ///
+            nodeB = statementNodeB,  ///
             unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
 
       statementUnified = unified; ///
@@ -39,27 +35,25 @@ export default class Premise {
     return statementUnified;
   }
 
-  unifySubproof(subproofNode, substitutions, fileContext, localContext) {
+  unifySubproof(subproofNodeB, substitutions, localContextA, localContextB) {
     let subproofUnified = false;
 
     if (this.statementNode !== null) {
-      const subproofAssertionNode = subproofAssertionNodeQuery(this.statementNode);
-
-      if (subproofAssertionNode !== null) {
-        const fileContextA = fileContext, ///
-              localContextB = localContext,  ///
-              subproofSuppositionStatementNodes = subproofSuppositionStatementNodesQuery(subproofNode),
-              subproofLastProofStepStatementNode = subproofLastProofStepStatementNodeQuery(subproofNode),
-              subproofStatementNodes = [
-                ...subproofSuppositionStatementNodes,
-                subproofLastProofStepStatementNode
-              ],
-              subproofAssertionStatementNodes = subproofAssertionStatementNodesQuery(subproofAssertionNode);
-
-        subproofUnified = match(subproofAssertionStatementNodes, subproofStatementNodes, (subproofAssertionStatementNode, subproofStatementNode) => {
-          const localContextA = LocalContext.fromFileContext(fileContextA),
-                nodeA = subproofAssertionStatementNode,  ///
-                nodeB = subproofStatementNode, ///
+      const statementNodeA = this.statementNode,
+            subproofAssertionNodeA = subproofAssertionNodeQuery(statementNodeA);  ///
+
+      if (subproofAssertionNodeA !== null) {
+        const subproofAssertionStatementNodesA = subproofAssertionStatementNodesQuery(subproofAssertionNodeA),  ///
+              subproofSuppositionStatementNodesB = subproofSuppositionStatementNodesQuery(subproofNodeB), ///
+              subproofLastProofStepStatementNodeB = subproofLastProofStepStatementNodeQuery(subproofNodeB), ///
+              subproofStatementNodesB = [
+                ...subproofSuppositionStatementNodesB,
+                subproofLastProofStepStatementNodeB
+              ];
+
+        subproofUnified = match(subproofAssertionStatementNodesA, subproofStatementNodesB, (subproofAssertionStatementNodeA, subproofStatementNodeB) => {
+          const nodeA = subproofAssertionStatementNodeA,  ///
+                nodeB = subproofStatementNodeB, ///
                 unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
 
           if (unified) {

package/src/proofStep.js

@@ -17,7 +17,7 @@ export default class ProofStep {
     return this.statementNode;
   }
 
-  unifyStatement(statementNode, equivalences, localContext) {
+  unifyStatement(statementNode, equivalences, localContextA, localContextB) {
     let statementUnified = false;
 
     if (this.statementNode !== null) {
@@ -27,14 +27,14 @@ export default class ProofStep {
         const statementNodeA = statementNode, ///
               statementNodeB = this.statementNode;  ///
 
-        statementUnifiedAgainstStatement = unifyStatementAgainstStatement(statementNodeA, statementNodeB, equivalences, localContext);
+        statementUnifiedAgainstStatement = unifyStatementAgainstStatement(statementNodeA, statementNodeB, equivalences, localContextA, localContextB);
       }
 
       if (!statementUnifiedAgainstStatement) {
         const statementNodeA = statementNode, ///
               statementNodeB = this.statementNode;  ///
 
-        statementUnifiedAgainstStatement = unifyStatementAgainstStatement(statementNodeA, statementNodeB, equivalences, localContext);
+        statementUnifiedAgainstStatement = unifyStatementAgainstStatement(statementNodeA, statementNodeB, equivalences, localContextA, localContextB);
       }
 
       statementUnified = statementUnifiedAgainstStatement;  ///
@@ -58,32 +58,27 @@ export default class ProofStep {
   }
 }
 
-function unifyStatementAgainstStatement(statementNodeA, statementNodeB, equivalences, localContext) {
+function unifyStatementAgainstStatement(statementNodeA, statementNodeB, equivalences, localContextA, localContextB) {
   let statementUnifiedAgainstStatement = false;
 
-  const nodeA = statementNodeA,  ///
+  const statementStringA = localContextA.nodeAsString(statementNodeA),
+        statementStringB = localContextB.nodeAsString(statementNodeB);
+
+  localContextB.trace(`Unifying the '${statementStringB}' statement against the '${statementStringA}' statement...`, statementNodeB);
+
+  const substitutions = Substitutions.fromNothing(),
+        nodeA = statementNodeA,  ///
         nodeB = statementNodeB,  ///
-        localContextA = localContext, ///
-        localContextB = localContext,  ///
-        substitutions = Substitutions.fromNothing(),
         unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
 
   if (unified) {
-    const substitutionsUnified = substitutions.everySubstitution((substitution) => {
-      const substitutionUnified = equivalences.some((equivalence) => {
-        const substitutionUnifiedAgainstEquivalence = substitution.unifyAgainstEquivalence(equivalence, substitutions, localContext);
-
-        if (substitutionUnifiedAgainstEquivalence) {
-          return true;
-        }
-      });
+    const substitutionsUnifiedAgainstEquivalences = substitutions.unifyAgainstEquivalences(equivalences, localContextA, localContextB);
 
-      if (substitutionUnified) {
-        return true;
-      }
-    });
+    statementUnifiedAgainstStatement = substitutionsUnifiedAgainstEquivalences;  ///
+  }
 
-    statementUnifiedAgainstStatement = substitutionsUnified;  ///
+  if (statementUnifiedAgainstStatement) {
+    localContextB.debug(`...unified the '${statementStringB}' statement against the '${statementStringA}' statement.`, statementNodeB);
   }
 
   return statementUnifiedAgainstStatement;

package/src/rule.js

@@ -4,8 +4,8 @@ import Label from "./label";
 import Premise from "./premise";
 import Conclusion from "./conclusion";
 import Substitutions from "./substitutions";
-
-import { reverse, correlate } from "./utilities/array";
+import unifyPremisesAgainstProofSteps from "./unify/premisesAgainstProofSteps";
+import unifyConclusionAgainstStatement from "./unify/conclusionAgainstStatement";
 
 export default class Rule {
   constructor(labels, premises, conclusion, fileContext) {
@@ -34,12 +34,17 @@ export default class Rule {
   unifyStatement(statementNode, localContext) {
     let statementUnified = false;
 
-    const proofSteps = localContext.getProofSteps(),
-          substitutions = Substitutions.fromNothing(),
-          premisesUnified = unifyPremises(this.premises, proofSteps, substitutions, this.fileContext, localContext);
+    const substitutions = Substitutions.fromNothing(),
+          proofSteps = localContext.getProofSteps(),
+          premisesA = this.premises,
+          proofStepsB = proofSteps, ///
+          fileContextA = this.fileContext,  ///
+          localContextB = localContext, ///
+          premisesUnified = unifyPremisesAgainstProofSteps(premisesA, proofStepsB, substitutions, fileContextA, localContextB);
 
     if (premisesUnified) {
-      const conclusionUnified = unifyConclusion(this.conclusion, statementNode, substitutions, this.fileContext, localContext);
+      const conclusionA = this.conclusion,  ///
+            conclusionUnified = unifyConclusionAgainstStatement(conclusionA, statementNode, substitutions, fileContextA, localContextB);
 
       statementUnified = conclusionUnified;  ///
     }
@@ -127,62 +132,3 @@ export default class Rule {
     return rule;
   }
 }
-
-function matchPremise(premise, proofStep, substitutions, fileContext, localContext) {
-  let premiseUnified = false;
-
-  const subproofNode = proofStep.getSubproofNode(),
-        statementNode = proofStep.getStatementNode();
-
-  substitutions.snapshot();
-
-  if (subproofNode !== null) {
-    const subproofUnified = premise.unifySubproof(subproofNode, substitutions, fileContext, localContext);
-
-    premiseUnified = subproofUnified; ///
-  }
-
-  if (statementNode !== null) {
-    const statementUnified = premise.unifyStatement(statementNode, substitutions, fileContext, localContext);
-
-    premiseUnified = statementUnified;  ///
-  }
-
-  premiseUnified ?
-    substitutions.continue() :
-      substitutions.rollback();
-
-  return premiseUnified;
-}
-
-function unifyPremises(premises, proofSteps, substitutions, fileContext, localContext) {
-  premises = reverse(premises); ///
-
-  proofSteps = reverse(proofSteps); ///
-
-  const premisesUnified = correlate(premises, proofSteps, (premise, proofStep) => {
-    const premiseUnified = matchPremise(premise, proofStep, substitutions, fileContext, localContext);
-
-    if (premiseUnified) {
-      return true;
-    }
-  });
-
-  return premisesUnified;
-}
-
-function unifyConclusion(conclusion, statementNode, substitutions, fileContext, localContext) {
-  let conclusionUnified;
-
-  substitutions.snapshot();
-
-  const statementUnified = conclusion.unifyStatement(statementNode, substitutions, fileContext, localContext);
-
-  conclusionUnified = statementUnified; ///
-
-  conclusionUnified ?
-    substitutions.continue() :
-      substitutions.rollback();
-
-  return conclusionUnified;
-}

package/src/substitution/statementForMetavariable.js

@@ -32,6 +32,12 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return this.substitution;
   }
 
+  getNode() {
+    const node = this.statementNode;  ///
+
+    return node;
+  }
+
   matchStatementNode(statementNode, substitutions, localContextA, localContextB) {
     let statementNodeMatches;
 
@@ -60,7 +66,7 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return matchesMetavariableNode;
   }
 
-  unifyAgainstEquivalence(equivalence, substitutions, localContext) {
+  unifyAgainstEquivalence(equivalence, substitutions, localContextA, localContextB) {
     let unifiedAgainstEquivalence = false;  ///
 
     const metavariableNode = metavariableNodeQuery(this.statementNode);
@@ -73,8 +79,6 @@ export default class StatementForMetavariableSubstitution extends Substitution {
       const { metaLevelUnifier } = shim,
             nodeA = this.metavariableNode, ///
             nodeB = metavariableNode, ///
-            localContextA = localContext, ///
-            localContextB = localContext,  ///
             unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
 
       unifiedAgainstEquivalence = unified; ///
@@ -83,6 +87,16 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return unifiedAgainstEquivalence;
   }
 
+  asString(localContextA, localContextB) {
+    const statementNodeB = this.statementNode,  ///
+          statementStringB = localContextB.nodeAsString(statementNodeB),
+          metavariableNodeA = this.metavariableNode,  ///
+          metavariableStringA = localContextA.nodeAsString(metavariableNodeA),
+          string = `[${statementStringB} for ${metavariableStringA}]`;
+
+    return string;
+  }
+
   static fromJSONAndFileContext(json, fileContext) {
     const { metavariable, statement } = json,
             metavariableString = metavariable,  ///

package/src/substitution/termForVariable.js

@@ -23,6 +23,12 @@ export default class TermForVariableSubstitution extends Substitution {
     return this.termNode;
   }
 
+  getNode() {
+    const node = this.termNode; ///
+
+    return node;
+  }
+
   isTransformed(substitution) {
     const termNod = substitution.getTermNode(),
           variableNode = substitution.getVariableNode(),
@@ -45,7 +51,7 @@ export default class TermForVariableSubstitution extends Substitution {
     return matchesVariableNode;
   }
 
-  unifyAgainstEquivalence(equivalence, substitutions, localContext) {
+  unifyAgainstEquivalence(equivalence, substitutions, localContextA, localContextB) {
     let unifiedAgainstEquivalence;
 
     const equivalenceMatchesVariableNode = equivalence.matchVariableNode(this.variableNode);
@@ -61,6 +67,16 @@ export default class TermForVariableSubstitution extends Substitution {
     return unifiedAgainstEquivalence;
   }
 
+  asString(localContextA, localContextB) {
+    const termNodeB = this.termNode,  ///
+          termStringB = localContextB.nodeAsString(termNodeB),
+          variableNodeA = this.variableNode,  ///
+          variableStringA = localContextA.nodeAsString(variableNodeA),
+          string = `[${termStringB} for ${variableStringA}]`;
+
+    return string;
+  }
+
   static fromSubstitutionNode(substitutionNode) {
     const termNode = termNodeQuery(substitutionNode),
           variableNode = variableNodeQuery(substitutionNode),

package/src/substitution.js

@@ -24,4 +24,16 @@ export default class Substitution {
 
     return matchesMetavariableNode;
   }
+
+  unifyAgainstEquivalences(equivalences, substitutions, localContextA, localContextB) {
+    const unifiedAgainstEquivalences = equivalences.some((equivalence) => {
+      const substitutionUnifiedAgainstEquivalence = this.unifyAgainstEquivalence(equivalence, substitutions, localContextA, localContextB);
+
+      if (substitutionUnifiedAgainstEquivalence) {
+        return true;
+      }
+    });
+
+    return unifiedAgainstEquivalences;
+  }
 }

package/src/substitutions.js

@@ -2,7 +2,7 @@
 
 import StatementForMetavariableSubstitution from "./substitution/statementForMetavariable";
 
-import { prune, compare } from "./utilities/array";
+import { prune, compare, rightDifference } from "./utilities/array";
 
 export default class Substitutions {
   constructor(array, savedArray) {
@@ -31,9 +31,16 @@ export default class Substitutions {
 
   everySubstitution(callback) { return this.array.every(callback); }
 
-  addSubstitution(substitution) { this.array.push(substitution); }
+  addSubstitution(substitution, localContextA, localContextB) {
+    this.array.push(substitution);
 
-  removeSubstitution(substitution) {
+    const substitutionNode = substitution.getNode(),
+          substitutionString = substitution.asString(localContextA, localContextB);
+
+    localContextB.trace(`Added the '${substitutionString}' substitution.`, substitutionNode);
+  }
+
+  removeSubstitution(substitution, localContextA, localContextB) {
     const substitutionA = substitution; ///
 
     prune(this.array, (substitution) => {
@@ -43,6 +50,24 @@ export default class Substitutions {
         return true;
       }
     });
+
+    const substitutionNode = substitution.getNode(),
+          substitutionString = substitution.asString(localContextA, localContextB);
+
+    localContextB.trace(`Removed the '${substitutionString}' substitution.`, substitutionNode);
+  }
+
+  unifyAgainstEquivalences(equivalences, localContextA, localContextB) {
+    const unifiedAgainstEquivalences = this.everySubstitution((substitution) => {
+      const substitutions = this, ///
+            substitutionUnifiedAgainstEquivalence = substitution.unifyAgainstEquivalences(equivalences, substitutions, localContextA, localContextB);
+
+      if (substitutionUnifiedAgainstEquivalence) {
+        return true;
+      }
+    });
+
+    return unifiedAgainstEquivalences;
   }
 
   snapshot() {
@@ -51,11 +76,20 @@ export default class Substitutions {
     ];
   }
 
-  rollback() {
-    const start = 0,
-          end = Infinity;
+  rollback(localContextA, localContextB) {
+    const array = [
+      ...this.array
+    ];
 
-    this.array.splice(start, end, ...this.savedArray);
+    rightDifference(this.savedArray, array);
+
+    array.forEach((substitution) => {
+      this.removeSubstitution(substitution, localContextA, localContextB);
+    });
+
+    this.array = [
+      ...this.savedArray
+    ];
 
     this.savedArray = null;
   }

package/src/supposition.js

@@ -1,6 +1,5 @@
 "use strict";
 
-import LocalContext from "./context/local";
 import metaLevelUnifier from "./unifier/metaLevel";
 
 import { match } from "./utilities/array";
@@ -22,15 +21,12 @@ export default class Supposition {
     return this.statementNode;
   }
 
-  unifyStatement(statementNode, substitutions, fileContext, localContext) {
+  unifyStatement(statementNodeB, substitutions, localContextA, localContextB) {
     let statementUnified = false;
 
     if (this.statementNode !== null) {
       const nodeA = this.statementNode,  ///
-            nodeB = statementNode,  ///
-            fileContextA = fileContext, ///
-            localContextA = LocalContext.fromFileContext(fileContextA),
-            localContextB = localContext,  ///
+            nodeB = statementNodeB,  ///
             unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
 
       statementUnified = unified; ///
@@ -39,27 +35,25 @@ export default class Supposition {
     return statementUnified;
   }
 
-  unifySubproof(subproofNode, substitutions, fileContext, localContext) {
+  unifySubproof(subproofNodeB, substitutions, localContextA, localContextB) {
     let subproofUnified = false;
 
     if (this.statementNode !== null) {
-      const subproofAssertionNode = subproofAssertionNodeQuery(this.statementNode);
-
-      if (subproofAssertionNode !== null) {
-        const fileContextA = fileContext, ///
-              localContextB = localContext,  ///
-              subproofSuppositionStatementNodes = subproofSuppositionStatementNodesQuery(subproofNode),
-              subproofLastProofStepStatementNode = subproofLastProofStepStatementNodeQuery(subproofNode),
-              subproofStatementNodes = [
-                ...subproofSuppositionStatementNodes,
-                subproofLastProofStepStatementNode
-              ],
-              subproofAssertionStatementNodes = subproofAssertionStatementNodesQuery(subproofAssertionNode);
-
-        subproofUnified = match(subproofAssertionStatementNodes, subproofStatementNodes, (subproofAssertionStatementNode, subproofStatementNode) => {
-          const localContextA = LocalContext.fromFileContext(fileContextA),
-                nodeA = subproofAssertionStatementNode,  ///
-                nodeB = subproofStatementNode, ///
+      const statementNodeA = this.statementNode,
+            subproofAssertionNodeA = subproofAssertionNodeQuery(statementNodeA);  ///
+
+      if (subproofAssertionNodeA !== null) {
+        const subproofAssertionStatementNodesA = subproofAssertionStatementNodesQuery(subproofAssertionNodeA),  ///
+              subproofSuppositionStatementNodesB = subproofSuppositionStatementNodesQuery(subproofNodeB), ///
+              subproofLastProofStepStatementNodeB = subproofLastProofStepStatementNodeQuery(subproofNodeB), ///
+              subproofStatementNodesB = [
+                ...subproofSuppositionStatementNodesB,
+                subproofLastProofStepStatementNodeB
+              ];
+
+        subproofUnified = match(subproofAssertionStatementNodesA, subproofStatementNodesB, (subproofAssertionStatementNodeA, subproofStatementNodeB) => {
+          const nodeA = subproofAssertionStatementNodeA,  ///
+                nodeB = subproofStatementNodeB, ///
                 unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
 
           if (unified) {

package/src/topLevelAssertion.js

@@ -4,8 +4,8 @@ import Label from "./label";
 import Consequent from "./consequent";
 import Supposition from "./supposition";
 import Substitutions from "./substitutions";
-
-import { reverse, correlate } from "./utilities/array";
+import unifyConsequentAgainstStatement from "./unify/consequentAgainstStatement";
+import unifySuppositionsAgainstProofSteps from "./unify/suppositionsAgainstProofSteps";
 
 export default class TopLevelAssertion {
   constructor(labels, suppositions, consequent, substitutions, fileContext) {
@@ -39,12 +39,17 @@ export default class TopLevelAssertion {
   unifyStatement(statementNode, localContext) {
     let statementUnified = false;
 
-    const proofSteps = localContext.getProofSteps(),
-          substitutions = Substitutions.fromNothing(),
-          suppositionsUnified = unifySuppositions(this.suppositions, proofSteps, substitutions, this.fileContext, localContext);
+    const substitutions = Substitutions.fromNothing(),
+          proofSteps = localContext.getProofSteps(),
+          proofStepsB = proofSteps, ///
+          fileContextA = this.fileContext,  ///
+          suppositionsA = this.suppositions,  ///
+          localContextB = localContext, ///
+          suppositionsUnified = unifySuppositionsAgainstProofSteps(suppositionsA, proofStepsB, substitutions, fileContextA, localContextB);
 
     if (suppositionsUnified) {
-      const consequentUnified = unifyConsequent(this.consequent, statementNode, substitutions, this.fileContext, localContext);
+      const consequentA = this.consequent,  ///
+            consequentUnified = unifyConsequentAgainstStatement(consequentA, statementNode, substitutions, fileContextA, localContext);
 
       statementUnified = consequentUnified;  ///
     }
@@ -131,62 +136,3 @@ export default class TopLevelAssertion {
 
   static fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(Class, labels, suppositions, consequent, substitutions, fileContext) { return new Class(labels, suppositions, consequent, substitutions, fileContext); }
 }
-
-function unifySuppositions(suppositions, proofSteps, substitutions, fileContext, localContext) {
-  suppositions = reverse(suppositions); ///
-
-  proofSteps = reverse(proofSteps); ///
-
-  const suppositionsUnified = correlate(suppositions, proofSteps, (supposition, proofStep) => {
-    const suppositionUnified = unifySupposition(supposition, proofStep, substitutions, fileContext, localContext);
-
-    if (suppositionUnified) {
-      return true;
-    }
-  });
-
-  return suppositionsUnified;
-}
-
-function unifySupposition(supposition, proofStep, substitutions, fileContext, localContext) {
-  let suppositionUnified = false;
-
-  substitutions.snapshot();
-
-  const subproofNode = proofStep.getSubproofNode(),
-        statementNode = proofStep.getStatementNode();
-
-  if (subproofNode !== null) {
-    const subproofUnified = supposition.unifySubproof(subproofNode, substitutions, fileContext, localContext);
-
-    suppositionUnified = subproofUnified; ///
-  }
-
-  if (statementNode !== null) {
-    const statementUnified = supposition.unifyStatement(statementNode, substitutions, fileContext, localContext);
-
-    suppositionUnified = statementUnified;  ///
-  }
-
-  suppositionUnified ?
-    substitutions.continue() :
-      substitutions.rollback();
-
-  return suppositionUnified;
-}
-
-function unifyConsequent(consequent, statementNode, substitutions, fileContext, localContext) {
-  let consequentUnified;
-
-  substitutions.snapshot();
-
-  const statementUnified = consequent.unifyStatement(statementNode, substitutions, fileContext, localContext);
-
-  consequentUnified = statementUnified; ///
-
-  consequentUnified ?
-    substitutions.continue() :
-      substitutions.rollback();
-
-  return consequentUnified;
-}

package/src/unifier/equality.js

@@ -13,11 +13,7 @@ class EqualityUnifier extends Unifier {
 
     const nonTerminalNodeA = leftTermNode, ///
           nonTerminalNodeB = rightTermNode, ///
-          nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, () => {
-            const unifiedAhead = true;
-
-            return unifiedAhead;
-          });
+          nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext);
 
     equalityUnified = nonTerminalNodeUnified; ///
 
@@ -28,10 +24,13 @@ class EqualityUnifier extends Unifier {
     {
       nodeQueryA: termNodeQuery,
       nodeQueryB: termNodeQuery,
-      unify: (termNodeA, termNodeB, localContext, unifyAhead) => {
+      unify: (termNodeA, termNodeB, localContext) => {
         let termVerifiedAgainstTerm;
 
-        termVerifiedAgainstTerm = unifyTermAgainstTerm(termNodeA, termNodeB, localContext, unifyAhead);
+        const leftTermNode = termNodeA, ///
+              rightTermNode = termNodeB;  ///
+
+        termVerifiedAgainstTerm = unifyTermAgainstTerm(leftTermNode, rightTermNode, localContext);
 
         if (!termVerifiedAgainstTerm) {
           const nonTerminalNodeA = termNodeA, ///
@@ -40,7 +39,7 @@ class EqualityUnifier extends Unifier {
                 nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
                 childNodesA = nonTerminalNodeAChildNodes, ///
                 childNodesB = nonTerminalNodeBChildNodes, ///
-                childNodesVerified = equalityUnifier.unifyChildNodes(childNodesA, childNodesB, localContext, unifyAhead);
+                childNodesVerified = equalityUnifier.unifyChildNodes(childNodesA, childNodesB, localContext);
 
           termVerifiedAgainstTerm = childNodesVerified; ///
         }