occam-verify-cli 0.0.942 → 0.0.943

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,30 @@ 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 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() {
@@ -51,11 +82,20 @@ export default class Substitutions {
     ];
   }
 
-  rollback() {
-    const start = 0,
-          end = Infinity;
+  rollback(localContextA, localContextB) {
+    const array = [
+      ...this.array
+    ];
+
+    rightDifference(this.savedArray, array);
+
+    array.forEach((substitution) => {
+      this.removeSubstitution(substitution, localContextA, localContextB);
+    });
 
-    this.array.splice(start, end, ...this.savedArray);
+    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; ///
         }

package/src/unifier/metaLevel.js

@@ -19,11 +19,7 @@ class MetaLevelUnifier extends Unifier {
 
     const nonTerminalNodeA = nodeA, ///
           nonTerminalNodeB = nodeB, ///
-          nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
-            const unifiedAhead = true;
-
-            return unifiedAhead;
-          });
+          nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB);
 
     unified = nonTerminalNodeUnified; ///
 
@@ -34,14 +30,14 @@ class MetaLevelUnifier extends Unifier {
     {
       nodeQueryA: statementNodeQuery,
       nodeQueryB: statementNodeQuery,
-      unify: (statementNodeA, statementNodeB, substitutions, localContextA, localContextB, unifyAhead) => {
+      unify: (statementNodeA, statementNodeB, substitutions, localContextA, localContextB) => {
         let statementVerifiedAgainstStatement;
 
         const metavariableNodeA = metavariableNodeQuery(statementNodeA);
 
         if (metavariableNodeA !== null) {
           const substitutionNodeA = substitutionNodeQuery(statementNodeA),
-                metavariableUnifiedAgainstStatement = unifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB, unifyAhead);
+                metavariableUnifiedAgainstStatement = unifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB);
 
           statementVerifiedAgainstStatement = metavariableUnifiedAgainstStatement;  ///
         } else {
@@ -51,7 +47,7 @@ class MetaLevelUnifier extends Unifier {
                 nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
                 childNodesA = nonTerminalNodeAChildNodes, ///
                 childNodesB = nonTerminalNodeBChildNodes, ///
-                childNodesVerified = metaLevelUnifier.unifyChildNodes(childNodesA, childNodesB, substitutions, localContextA, localContextB, unifyAhead);
+                childNodesVerified = metaLevelUnifier.unifyChildNodes(childNodesA, childNodesB, substitutions, localContextA, localContextB);
 
           statementVerifiedAgainstStatement = childNodesVerified; ///
         }
@@ -62,9 +58,9 @@ class MetaLevelUnifier extends Unifier {
     {
       nodeQueryA: termVariableNodeQuery,
       nodeQueryB: termNodeQuery,
-      unify: (termVariableNodeA, termNodeB, substitutions, localContextA, localContextB, unifyAhead) => {
+      unify: (termVariableNodeA, termNodeB, substitutions, localContextA, localContextB) => {
         const variableNodeA = termVariableNodeA, ///
-              variableUnifiedAgainstTerm = unifyVariableAgainstTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB, unifyAhead);
+              variableUnifiedAgainstTerm = unifyVariableAgainstTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB);
 
         return variableUnifiedAgainstTerm;
       }

package/src/unifier/statementAgainstCombinator.js

@@ -17,11 +17,7 @@ class StatementAgainstCombinatorUnifier extends Unifier {
 
     const nonTerminalNodeA = statementNode, ///
           nonTerminalNodeB = combinatorStatementNode, ///
-          nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, () => {
-            const unifiedAhead = true;
-
-            return unifiedAhead;
-          });
+          nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext);
 
     statementUnifiedAgainstCombinator = nonTerminalNodeUnified; ///
 
@@ -32,8 +28,10 @@ class StatementAgainstCombinatorUnifier extends Unifier {
     {
       nodeQueryA: statementNodeQuery,
       nodeQueryB: metaTypeNodeQuery,
-      unify: (statementNodeA, metaTypeNodeB, localContext, unifyAhead) => {
-        const statementUnifiedAgainstMetaType = unifyStatementAgainstMetaType(statementNodeA, metaTypeNodeB, localContext, unifyAhead);
+      unify: (statementNodeA, metaTypeNodeB, localContext) => {
+        const metaTypeNode = metaTypeNodeB, ///
+              statementNode = statementNodeA, ///
+              statementUnifiedAgainstMetaType = unifyStatementAgainstMetaType(statementNode, metaTypeNode, localContext);
 
         return statementUnifiedAgainstMetaType;
       }
@@ -41,8 +39,10 @@ class StatementAgainstCombinatorUnifier extends Unifier {
     {
       nodeQueryA: termNodeQuery,
       nodeQueryB: typeNodeQuery,
-      unify: (termNodeA, typeNodeB, localContext, unifyAhead) => {
-        const termUnifiedAgainstType = unifyTermAgainstType(termNodeA, typeNodeB, localContext, unifyAhead);
+      unify: (termNodeA, typeNodeB, localContext) => {
+        const termNode = termNodeA, ///
+              typeNode = typeNodeB, ///
+              termUnifiedAgainstType = unifyTermAgainstType(termNode, typeNode, localContext);
 
         return termUnifiedAgainstType;
       }

package/src/unifier/termAgainstConstructor.js

@@ -9,12 +9,12 @@ const termNodeQuery = nodeQuery("/term"),
       typeNodeQuery = nodeQuery("/type");
 
 class TermAgainstConstructorUnifier extends Unifier {
-  unify(termNode, constructorTermNode, localContext, unifyAhead) {
+  unify(termNode, constructorTermNode, localContext) {
     let termUnifiedAgainstConstructor;
 
     const nonTerminalNodeA = termNode, ///
           nonTerminalNodeB = constructorTermNode, ///
-          nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, unifyAhead);
+          nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext);
 
     termUnifiedAgainstConstructor = nonTerminalNodeUnified; ///
 
@@ -25,8 +25,10 @@ class TermAgainstConstructorUnifier extends Unifier {
     {
       nodeQueryA: termNodeQuery,
       nodeQueryB: typeNodeQuery,
-      unify: (termNodeA, typeNodeB, localContext, unifyAhead) => {
-        const termUnifiedAgainstType = unifyTermAgainstType(termNodeA, typeNodeB, localContext, unifyAhead);
+      unify: (termNodeA, typeNodeB, localContext) => {
+        const termNode = termNodeA, ///
+              typeNode = typeNodeB, ///
+              termUnifiedAgainstType = unifyTermAgainstType(termNode, typeNode, localContext);
 
         return termUnifiedAgainstType;
       }

package/src/unifier.js

@@ -2,6 +2,7 @@
 
 import { nodeQuery } from "./utilities/query";
 import { terminalNodeMapFromNodes, areTerminalNodeMapsEqual } from "./utilities/unifier";
+import {isLastRemainingArgumentFunction} from "./utilities/arguments";
 
 const nonTerminalNodeQuery = nodeQuery("/*");
 
@@ -55,10 +56,25 @@ export default class Unifier {
             terminalNodeMapsEqual = areTerminalNodeMapsEqual(childTerminalNodeMapA, childTerminalNodeMapB);
 
       if (terminalNodeMapsEqual) {
-        const index = 0,
-              childNodesVerifyAhead = this.unifyChildNodesAhead(index, childNodesA, childNodesB, ...remainingArguments);
-
-        childNodesUnified = childNodesVerifyAhead; ///
+        const lastRemainingArgumentFunction = isLastRemainingArgumentFunction(remainingArguments);
+
+        if (lastRemainingArgumentFunction) {
+          const index = 0,
+                childNodesUnifiedAhead = this.unifyChildNodesAhead(index, childNodesA, childNodesB,...remainingArguments);
+
+          childNodesUnified = childNodesUnifiedAhead; ///
+        } else {
+          childNodesUnified = childNodesA.every((childNodeA, index) => {
+            const childNodeB = childNodesB[index],
+                  nodeA = childNodeA, ///
+                  nodeB = childNodeB, ///
+                  nodeUnified = this.unifyNode(nodeA, nodeB, ...remainingArguments);
+
+            if (nodeUnified) {
+              return true;
+            }
+          });
+        }
       }
     }
 
@@ -68,10 +84,18 @@ export default class Unifier {
   unifyTerminalNode(terminalNodeA, terminalNodeB, ...remainingArguments) { ///
     let terminalNodeUnified;
 
-    const unifyAhead = remainingArguments.pop(),
-          unifyiedAhead = unifyAhead();
+    const lastRemainingArgumentFunction = isLastRemainingArgumentFunction(remainingArguments);
+
+    if (lastRemainingArgumentFunction) {
+      const unifyAhead = remainingArguments.pop(),
+            unifiedAhead = unifyAhead();
 
-    terminalNodeUnified = unifyiedAhead;  ///
+      terminalNodeUnified = unifiedAhead;  ///
+
+      remainingArguments.push(unifiedAhead);
+    } else {
+      terminalNodeUnified = true;
+    }
 
     return terminalNodeUnified;
   }
@@ -134,9 +158,9 @@ export default class Unifier {
           childNodesALength = childNodesA.length;
 
     if (index === childNodesALength) {
-      const unifyiedAhead = unifyAhead();
+      const unifiedAhead = unifyAhead();
 
-      childNodesUnified = unifyiedAhead; ///
+      childNodesUnified = unifiedAhead; ///
     } else {
       const childNodeA = childNodesA[index],
             childNodeB = childNodesB[index],
@@ -146,9 +170,9 @@ export default class Unifier {
               remainingArguments.push(unifyAhead); ///
 
               const aheadIndex = index + 1,
-                    childNodesVerifyAhead = this.unifyChildNodesAhead(aheadIndex, childNodesA, childNodesB, ...remainingArguments);
+                    childNodesUnifiedAhead = this.unifyChildNodesAhead(aheadIndex, childNodesA, childNodesB, ...remainingArguments);
 
-              return childNodesVerifyAhead;
+              return childNodesUnifiedAhead;
             });
 
       childNodesUnified = nodeUnified;  ///

package/src/unify/conclusionAgainstStatement.js

@@ -0,0 +1,34 @@
+"use strict";
+
+import LocalContext from "../context/local";
+
+export default function unifyConclusionAgainstStatement(conclusionA, statementNodeB, substitutions, fileContextA, localContextB) {
+  let conclusionUnified = false;
+
+  const conclusionAStatementNode = conclusionA.getStatementNode();
+
+  if (conclusionAStatementNode !== null) {
+    const localContextA = LocalContext.fromFileContext(fileContextA),
+          statementNodeA = conclusionAStatementNode,  ///
+          statementStringA = localContextA.nodeAsString(statementNodeA),
+          statementStringB = localContextB.nodeAsString(statementNodeB);
+
+    substitutions.snapshot();
+
+    localContextB.trace(`Unifying the '${statementStringB}' statement against the conclusion's '${statementStringA}' statement...`, statementNodeB);
+
+    const statementUnified = conclusionA.unifyStatement(statementNodeB, substitutions, localContextA, localContextB);
+
+    conclusionUnified = statementUnified; ///
+
+    conclusionUnified ?
+      substitutions.continue() :
+        substitutions.rollback(localContextA, localContextB);
+
+    if (conclusionUnified) {
+      localContextB.debug(`...unified the '${statementStringB}' statement against the conclusion's '${statementStringA}' statement.`, statementNodeB);
+    }
+  }
+
+  return conclusionUnified;
+}

package/src/unify/consequentAgainstStatement.js

@@ -0,0 +1,34 @@
+"use strict";
+
+import LocalContext from "../context/local";
+
+export default function unifyConsequentAgainstStatement(consequentA, statementNodeB, substitutions, fileContextA, localContextB) {
+  let consequentUnified = false;
+
+  const consequentAStatementNode = consequentA.getStatementNode();
+
+  if (consequentAStatementNode !== null) {
+    const localContextA = LocalContext.fromFileContext(fileContextA),
+          statementNodeA = consequentAStatementNode,  ///
+          statementStringA = localContextA.nodeAsString(statementNodeA),
+          statementStringB = localContextB.nodeAsString(statementNodeB);
+
+    substitutions.snapshot();
+
+    localContextB.trace(`Unifying the '${statementStringB}' statement against the consequent's '${statementStringA}' statement...`, statementNodeB);
+
+    const statementUnified = consequentA.unifyStatement(statementNodeB, substitutions, localContextA, localContextB);
+
+    consequentUnified = statementUnified; ///
+
+    consequentUnified ?
+      substitutions.continue() :
+        substitutions.rollback(localContextA, localContextB);
+
+    if (consequentUnified) {
+      localContextB.debug(`...unified the '${statementStringB}' statement against the consequent's '${statementStringA}' statement.`, statementNodeB);
+    }
+  }
+
+  return consequentUnified;
+}

package/src/unify/metavariableAgainstStatement.js

@@ -4,7 +4,11 @@ import TermForVariableSubstitution from "../substitution/termForVariable";
 import unifyStatementAgainstStatement from "../unify/statementAtainstStatement";
 import StatementForMetavariableSubstitution from "../substitution/statementForMetavariable";
 
-export default function unifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB, unifyAhead) {
+import { nodeQuery } from "../utilities/query";
+
+const metavariableNodeQuery = nodeQuery("/statement/metavariable");
+
+export default function unifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB) {
   let metavariableUnifiedAgainstStatement = false;
 
   const substitution = substitutions.findSubstitution((substitution) => {
@@ -27,9 +31,7 @@ export default function unifyMetavariableAgainstStatement(metavariableNodeA, sta
             statementUnifiedAgainstStatement = unifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContext, localContext);
 
       if (statementUnifiedAgainstStatement) {
-        const unifiedAhead = unifyAhead();
-
-        metavariableUnifiedAgainstStatement = unifiedAhead;  ///
+        metavariableUnifiedAgainstStatement = true;
       }
     } else {
       const substitutionSubstitution = substitution.getSubstitution();
@@ -44,39 +46,47 @@ export default function unifyMetavariableAgainstStatement(metavariableNodeA, sta
               statementUnifiedAgainstStatement = unifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContext, localContext);
 
         if (statementUnifiedAgainstStatement) {
-          const unifiedAhead = unifyAhead();
-
-          metavariableUnifiedAgainstStatement = unifiedAhead;  ///
+          metavariableUnifiedAgainstStatement = true;
         }
       } else {
         const substitutionMatchesStatementNodeB = substitution.matchStatementNode(statementNodeB);
 
         if (substitutionMatchesStatementNodeB) {
-          const unifiedAhead = unifyAhead();
-
-          metavariableUnifiedAgainstStatement = unifiedAhead;  ///
+          metavariableUnifiedAgainstStatement = true;
         }
       }
     }
   } else {
-    let unifiedAhead;
+    const metavariableA = localContextA.findMetavariableByMetavariableNode(metavariableNodeA);
 
-    const statementNode = statementNodeB, ///
-          substitutionNode = substitutionNodeA, ///
-          metavariableNode = metavariableNodeA, ///
-          statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNodeStatementNodeAndSubstitutionNode(metavariableNode, statementNode, substitutionNode),
-          substitution = statementForMetavariableSubstitution;  ///
+    if (metavariableA !== null) {
+      const metavariableB = metavariableFromStatementNode(statementNodeB, localContextB);
 
-    substitutions.addSubstitution(substitution);
+      if (metavariableA !== metavariableB) {
+        const statementNode = statementNodeB, ///
+              substitutionNode = substitutionNodeA, ///
+              metavariableNode = metavariableNodeA, ///
+              statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNodeStatementNodeAndSubstitutionNode(metavariableNode, statementNode, substitutionNode),
+              substitution = statementForMetavariableSubstitution;  ///
 
-    unifiedAhead = unifyAhead();
+        substitutions.addSubstitution(substitution, localContextA, localContextB);
+      }
 
-    if (!unifiedAhead) {
-      substitutions.removeSubstitution(substitution);
+      metavariableUnifiedAgainstStatement = true;
     }
-
-    metavariableUnifiedAgainstStatement = unifiedAhead;  ///
   }
 
   return metavariableUnifiedAgainstStatement;
 }
+
+function metavariableFromStatementNode(statementNode, localContext) {
+  let metavariable = null;
+
+  const metavariableNode = metavariableNodeQuery(statementNode)
+
+  if (metavariableNode !== null) {
+    metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode);
+  }
+
+  return metavariable;
+}