occam-verify-cli 0.0.941 → 0.0.943

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,10 +4,14 @@ 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.find((substitution) => {
+  const substitution = substitutions.findSubstitution((substitution) => {
     const substitutionMatchesMetavariableNodeA = substitution.matchMetavariableNode(metavariableNodeA);
 
     if (substitutionMatchesMetavariableNodeA) {
@@ -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.push(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.pop();
+      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;
+}

package/src/unify/premiseAgainstProofStep.js

@@ -0,0 +1,54 @@
+"use strict";
+
+import { subproofNodeAsSubproofString } from "../utilities/unify";
+
+export default function unifyPremiseAgainstProofStep(premiseA, proofStepB, substitutions, localContextA, localContextB) {
+  let premiseUnified = false;
+
+  const premiseAStatementNode = premiseA.getStatementNode();
+
+  if (premiseAStatementNode !== null) {
+    const proofStepBSubproofNode = proofStepB.getSubproofNode(),
+          proofStepBStatementNode = proofStepB.getStatementNode(),
+          subproofNodeB = proofStepBSubproofNode, ///
+          statementNodeB = proofStepBStatementNode, ///
+          statementNodeA = premiseAStatementNode, ///
+          statementStringA = localContextA.nodeAsString(statementNodeA)
+
+    substitutions.snapshot();
+
+    if (subproofNodeB !== null) {
+      const subproofStringB = subproofNodeAsSubproofString(subproofNodeB, localContextB);
+
+      localContextB.trace(`Unifying the '${subproofStringB}' subproof against the premise's '${statementStringA}' statement...`, subproofNodeB);
+
+      const subproofUnified = premiseA.unifySubproof(subproofNodeB, substitutions, localContextA, localContextB);
+
+      if (subproofUnified) {
+        localContextB.debug(`...unified the '${subproofStringB}' subproof against the premise's '${statementStringA}' statement.`, subproofNodeB);
+
+        premiseUnified = true;
+      }
+    }
+
+    if (statementNodeB !== null) {
+      const statementStringB = localContextB.nodeAsString(statementNodeB);
+
+      localContextB.trace(`Unifying the '${statementStringB}' statement against the premise's '${statementStringA}' statement...`, statementNodeB);
+
+      const statementUnified = premiseA.unifyStatement(statementNodeB, substitutions, localContextA, localContextB);
+
+      if (statementUnified) {
+        localContextB.debug(`...unified the '${statementStringB}' statement against the premise's '${statementStringA}' statement.`, statementNodeB);
+
+        premiseUnified = true;
+      }
+    }
+
+    premiseUnified ?
+      substitutions.continue() :
+        substitutions.rollback(localContextA, localContextB);
+  }
+
+  return premiseUnified;
+}

package/src/unify/premisesAgainstProofSteps.js

@@ -0,0 +1,23 @@
+"use strict";
+
+import LocalContext from "../context/local";
+import unifyPremiseAgainstProofStep from "../unify/premiseAgainstProofStep";
+
+import { reverse, correlate } from "../utilities/array";
+
+export default function unifyPremisesAgainstProofSteps(premisesA, proofStepsB, substitutions, fileContextA, localContextB) {
+  premisesA = reverse(premisesA); ///
+
+  proofStepsB = reverse(proofStepsB); ///
+
+  const premisesUnified = correlate(premisesA, proofStepsB, (premiseA, proofStepB) => {
+    const localContextA = LocalContext.fromFileContext(fileContextA),
+          premiseUnified = unifyPremiseAgainstProofStep(premiseA, proofStepB, substitutions, localContextA, localContextB);
+
+    if (premiseUnified) {
+      return true;
+    }
+  });
+
+  return premisesUnified;
+}

package/src/unify/statementAgainstMetaType.js

@@ -7,27 +7,19 @@ import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 
 const metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type!");
 
-export default function unifyStatementAgainstMetaType(statementNodeA, metaTypeNodeB, localContext, unifyAhead) {
+export default function unifyStatementAgainstMetaType(statementNode, metaTypeNode, localContext) {
   let statementVerifiedAgainstMetaType = false;
 
-  const metaTypeNode = metaTypeNodeB, ///
-        metaTypeTerminalNode = metaTypeTerminalNodeQuery(metaTypeNode),
+  const metaTypeTerminalNode = metaTypeTerminalNodeQuery(metaTypeNode),
         content = metaTypeTerminalNode.getContent();
 
   if (content === STATEMENT_META_TYPE_NAME) {
-    let unifiedAhead = false;
-
     const { verifyStatement } = shim,
           derived = false,
           assignments = [],
-          statementNode = statementNodeA, ///
           statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
 
-    if (statementVerified) {
-      unifiedAhead = unifyAhead();
-    }
-
-    statementVerifiedAgainstMetaType = unifiedAhead; ///
+    statementVerifiedAgainstMetaType = statementVerified;
   }
 
   return statementVerifiedAgainstMetaType;

package/src/unify/suppositionAgainstProofStep.js

@@ -0,0 +1,54 @@
+"use strict";
+
+import { subproofNodeAsSubproofString } from "../utilities/unify";
+
+export default function unifySuppositionAgainstProofStep(suppositionA, proofStepB, substitutions, localContextA, localContextB) {
+  let suppositionUnified = false;
+
+  const suppositionAStatementNode = suppositionA.getStatementNode();
+
+  if (suppositionAStatementNode !== null) {
+    const proofStepBSubproofNode = proofStepB.getSubproofNode(),
+          proofStepBStatementNode = proofStepB.getStatementNode(),
+          subproofNodeB = proofStepBSubproofNode, ///
+          statementNodeB = proofStepBStatementNode, ///
+          statementNodeA = suppositionAStatementNode, ///
+          statementStringA = localContextA.nodeAsString(statementNodeA)
+
+    substitutions.snapshot();
+
+    if (subproofNodeB !== null) {
+      const subproofStringB = subproofNodeAsSubproofString(subproofNodeB, localContextB);
+
+      localContextB.trace(`Unifying the '${subproofStringB}' subproof against the supposition's '${statementStringA}' statement...`, subproofNodeB);
+
+      const subproofUnified = suppositionA.unifySubproof(subproofNodeB, substitutions, localContextA, localContextB);
+
+      if (subproofUnified) {
+        localContextB.debug(`...unified the '${subproofStringB}' subproof against the supposition's '${statementStringA}' statement.`, subproofNodeB);
+
+        suppositionUnified = true;
+      }
+    }
+
+    if (statementNodeB !== null) {
+      const statementStringB = localContextB.nodeAsString(statementNodeB);
+
+      localContextB.trace(`Unifying the '${statementStringB}' statement against the supposition's '${statementStringA}' statement...`, statementNodeB);
+
+      const statementUnified = suppositionA.unifyStatement(statementNodeB, substitutions, localContextA, localContextB);
+
+      if (statementUnified) {
+        localContextB.debug(`...unified the '${statementStringB}' statement against the supposition's '${statementStringA}' statement.`, statementNodeB);
+
+        suppositionUnified = true;
+      }
+    }
+
+    suppositionUnified ?
+      substitutions.continue() :
+        substitutions.rollback(localContextA, localContextB);
+  }
+
+  return suppositionUnified;
+}

package/src/unify/suppositionsAgainstProofSteps.js

@@ -0,0 +1,23 @@
+"use strict";
+
+import LocalContext from "../context/local";
+import unifySuppositionAgainstProofStep from "./suppositionAgainstProofStep";
+
+import { reverse, correlate } from "../utilities/array";
+
+export default function unifySuppositionsAgainstProofSteps(suppositionsA, proofStepsB, substitutions, fileContextA, localContextB) {
+  suppositionsA = reverse(suppositionsA); ///
+
+  proofStepsB = reverse(proofStepsB); ///
+
+  const suppositionsUnified = correlate(suppositionsA, proofStepsB, (suppositionA, proofStepB) => {
+    const localContextA = LocalContext.fromFileContext(fileContextA),
+          suppositionUnified = unifySuppositionAgainstProofStep(suppositionA, proofStepB, substitutions, localContextA, localContextB);
+
+    if (suppositionUnified) {
+      return true;
+    }
+  });
+
+  return suppositionsUnified;
+}

package/src/unify/termAgainstTerm.js

@@ -2,18 +2,14 @@
 
 import { areTermNodesEqual } from "../utilities/equivalences";
 
-export default function unifyTermAgainstTerm(termNodeA, termNodeB, localContext, unifyAhead) {
+export default function unifyTermAgainstTerm(leftTermNode, rightTermNode, localContext) {
   let termUnifiedAgainstTerm = false;
 
-  const leftTermNode = termNodeA, ///
-        rightTermNode = termNodeB,  ///
-        equivalences = localContext.getEquivalences(),
+  const equivalences = localContext.getEquivalences(),
         termNodesEqual = areTermNodesEqual(leftTermNode, rightTermNode, equivalences);
 
   if (termNodesEqual) {
-    const unifiedAhead = unifyAhead();
-
-    termUnifiedAgainstTerm = unifiedAhead;  ///
+    termUnifiedAgainstTerm = true;
   }
 
   return termUnifiedAgainstTerm;

package/src/unify/termAgainstType.js

@@ -4,26 +4,25 @@ import shim from "../shim";
 
 import { first } from "../utilities/array";
 
-export default function unifyTermAgainstType(termNodeA, typeNodeB, localContext, unifyAhead) {
+export default function unifyTermAgainstType(termNode, typeNode, localContext) {
   let termUnifiedAgainstType;
 
   const { verifyTerm } = shim,
         terms = [],
-        termVerified = verifyTerm(termNodeA, terms, localContext, () => {
-          let unifiedAhead = false;
+        termVerified = verifyTerm(termNode, terms, localContext, () => {
+          let verifiedAhead = false;
 
           const firstTerm = first(terms),
                 term = firstTerm, ///
                 termType = term.getType(),
-                typeNode = typeNodeB, ///
                 type = localContext.findTypeByTypeNode(typeNode),
                 termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
 
           if (termTypeEqualToOrSubTypeOfType) {
-            unifiedAhead = unifyAhead();
+            verifiedAhead = true;
           }
 
-          return unifiedAhead;
+          return verifiedAhead;
         });
 
   termUnifiedAgainstType = termVerified; ///