occam-verify-cli 0.0.941 → 0.0.943

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

@@ -1,5 +1,6 @@
 "use strict";
 
+import Substitutions from "./substitutions";
 import metaLevelUnifier from "./unifier/metaLevel";
 
 export default class ProofStep {
@@ -16,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) {
@@ -26,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;  ///
@@ -57,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,  ///
         nodeB = statementNodeB,  ///
-        localContextA = localContext, ///
-        localContextB = localContext,  ///
-        substitutions = [],
+        statementStringA = localContextA.nodeAsString(statementNodeA),
+        statementStringB = localContextB.nodeAsString(statementNodeB);
+
+  localContextB.trace(`Unifying the '${statementStringB}' statement against the '${statementStringA}' statement...`, statementNodeB);
+
+  const substitutions = Substitutions.fromNothing(),
         unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
 
   if (unified) {
-    const substitutionsUnified = substitutions.every((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

@@ -3,8 +3,9 @@
 import Label from "./label";
 import Premise from "./premise";
 import Conclusion from "./conclusion";
-
-import { reverse, correlate } from "./utilities/array";
+import Substitutions from "./substitutions";
+import unifyPremisesAgainstProofSteps from "./unify/premisesAgainstProofSteps";
+import unifyConclusionAgainstStatement from "./unify/conclusionAgainstStatement";
 
 export default class Rule {
   constructor(labels, premises, conclusion, fileContext) {
@@ -33,12 +34,17 @@ export default class Rule {
   unifyStatement(statementNode, localContext) {
     let statementUnified = false;
 
-    const proofSteps = localContext.getProofSteps(),
-          substitutions = [],
-          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;  ///
     }
@@ -126,47 +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();
-
-  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;  ///
-  }
-
-  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) {
-  const statementUnified = conclusion.unifyStatement(statementNode, substitutions, fileContext, localContext),
-        conclusionUnified = statementUnified; ///
-
-  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;
 
@@ -83,6 +89,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(),
@@ -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),
@@ -106,7 +122,7 @@ function substituteTermNode(termNode, substitutions) {
   const termVariableNode = variableNodeQuery(termNode);
 
   if (termVariableNode !== null) {
-    substitutions.some((substitution) => {
+    substitutions.someSubstitution((substitution) => {
       const substitutionMatchesVariableNode = substitution.matchVariableNode(termVariableNode);
 
       if (substitutionMatchesVariableNode) {
@@ -121,7 +137,7 @@ function substituteTermNode(termNode, substitutions) {
 }
 
 function substituteVariableNode(variableNode, substitutions) {
-  substitutions.some((substitution) => {
+  substitutions.someSubstitution((substitution) => {
     const substitutionMatchesVariableNode = substitution.matchVariableNode(variableNode);
 
     if (substitutionMatchesVariableNode) {

package/src/substitutions.js

@@ -0,0 +1,143 @@
+"use strict";
+
+import StatementForMetavariableSubstitution from "./substitution/statementForMetavariable";
+
+import { prune, compare, rightDifference } from "./utilities/array";
+
+export default class Substitutions {
+  constructor(array, savedArray) {
+    this.array = array;
+    this.savedArray = savedArray;
+  }
+
+  getArray() {
+    return this.array;
+  }
+
+  getSavedArray() {
+    return this.savedArray;
+  }
+
+  hasChanged() {
+    const compares = compare(this.array, this.savedArray),
+          changed = !compares;  ///
+
+    return changed;
+  }
+
+  findSubstitution(callback) { return this.array.find(callback); }
+
+  someSubstitution(callback) { return this.array.some(callback); }
+
+  everySubstitution(callback) { return this.array.every(callback); }
+
+  addSubstitution(substitution, localContextA, localContextB) {
+    this.array.push(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) => {
+      const substitutionB = substitution; ///
+
+      if (substitutionA !== substitutionB) {
+        return true;
+      }
+    });
+
+    const substitutionNode = substitution.getNode(),
+          substitutionString = substitution.asString(localContextA, localContextB);
+
+    localContextB.trace(`Removed the '${substitutionString}' substitution.`, substitutionNode);
+  }
+
+  unifyAgainstEquivalences(equivalences, localContextA, localContextB) {
+    const substitutions = this, ///
+          unifiedAgainstEquivalences = this.everySubstitution((substitution) => {
+            const substitutionUnified = equivalences.some((equivalence) => {
+              const substitutionUnifiedAgainstEquivalence = substitution.unifyAgainstEquivalence(equivalence, substitutions, localContextA, localContextB);
+
+              if (substitutionUnifiedAgainstEquivalence) {
+                return true;
+              }
+            });
+
+            if (substitutionUnified) {
+              return true;
+            }
+          });
+
+    return unifiedAgainstEquivalences;
+  }
+
+  snapshot() {
+    this.savedArray = [
+      ...this.array
+    ];
+  }
+
+  rollback(localContextA, localContextB) {
+    const array = [
+      ...this.array
+    ];
+
+    rightDifference(this.savedArray, array);
+
+    array.forEach((substitution) => {
+      this.removeSubstitution(substitution, localContextA, localContextB);
+    });
+
+    this.array = [
+      ...this.savedArray
+    ];
+
+    this.savedArray = null;
+  }
+
+  continue() {
+    this.savedArray = null;
+  }
+
+  transform() {
+    ///
+  }
+
+  toJSON(tokens) {
+    const json = this.array.map((substitution) => {
+      const substitutionJSON = substitution.toJSON(tokens);
+
+      return substitutionJSON;
+    });
+
+    return json;
+  }
+
+  static fromNothing() {
+    const array = [],
+          savedArray = null,
+          substitutions = new Substitutions(array, savedArray);
+
+    return substitutions;
+  }
+
+  static fromJSONAndFileContext(json, fileContext) {
+    const substitutionsJSON = json, ///
+          array = substitutionsJSON.map((substitutionJSON) => {
+            const json = substitutionJSON,  ///
+                  statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromJSONAndFileContext(json, fileContext),
+                  substitution = statementForMetavariableSubstitution;  ///
+
+            return substitution;
+          }),
+          savedArray = null,
+          substitutions = new Substitutions(array, savedArray);
+
+    return substitutions;
+  }
+}

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

@@ -3,9 +3,9 @@
 import Label from "./label";
 import Consequent from "./consequent";
 import Supposition from "./supposition";
-import StatementForMetavariableSubstitution from "./substitution/statementForMetavariable";
-
-import { reverse, correlate } from "./utilities/array";
+import Substitutions from "./substitutions";
+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 = [],
-          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;  ///
     }
@@ -76,11 +81,7 @@ export default class TopLevelAssertion {
             return suppositionJSON;
           }),
           consequentJSON = this.consequent.toJSON(tokens),
-          substitutionsJSON = this.substitutions.map((substitution) => {
-            const substitutionJSON = substitution.toJSON();
-
-            return substitutionJSON;
-          }),
+          substitutionsJSON = this.substitutions.toJSON(tokens),
           labels = labelsJSON,  ///
           suppositions = suppositionsJSON,  ///
           consequent = consequentJSON,  ///
@@ -126,60 +127,12 @@ export default class TopLevelAssertion {
 
     const substitutionsJSON = substitutions;  ///
 
-    substitutions = substitutionsJSON.map((substitutionJSON) => {
-      const json = substitutionJSON,  ///
-            statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromJSONAndFileContext(json, fileContext),
-            substitution = statementForMetavariableSubstitution;  ///
+    json = substitutionsJSON; ///
 
-      return substitution;
-    });
+    substitutions = Substitutions.fromJSONAndFileContext(json, fileContext);
 
     return new Class(labels, suppositions, consequent, substitutions, fileContext);  ///
   }
 
   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;
-
-  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;  ///
-  }
-
-  return suppositionUnified;
-}
-
-function unifyConsequent(consequent, statementNode, substitutions, fileContext, localContext) {
-  const statementUnified = consequent.unifyStatement(statementNode, substitutions, fileContext, localContext),
-        consequentUnified = statementUnified; ///
-
-  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; ///
         }