occam-verify-cli 0.0.1003 → 0.0.1006

package/src/subproof.js

@@ -0,0 +1,99 @@
+"use strict";
+
+import Supposition from "./supposition";
+import LocalContext from "./context/local";
+import SubDerivation from "./subDerivation";
+
+import { nodeQuery, nodesQuery } from "./utilities/query";
+import {subproofNodeAsSubproofString, subproofStringFromSubproofNode} from "./utilities/subproof";
+
+const suppositionNodesQuery = nodesQuery("/subproof/supposition"),
+      subDerivationNodeQuery = nodeQuery("/subproof/subDerivation");
+
+export default class Subproof {
+  constructor(string, suppositions, subDerivation) {
+    this.string = string;
+    this.suppositions = suppositions;
+    this.subDerivation = subDerivation;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getNode() {
+    return this.node;
+  }
+
+  getSuppositions() {
+    return this.suppositions;
+  }
+
+  getSubDerivation() {
+    return this.subDerivation;
+  }
+
+  getLastProofStep() { return this.subDerivation.getLastProofStep(); }
+
+  getStatements() {
+    const lastProofStep = this.getLastProofStep(),
+          suppositionStatements = this.suppositions.map((supposition) => {
+            const suppositionStatement = supposition.getStatement();
+
+            return suppositionStatement;
+          }),
+          lastProofStepStatement = lastProofStep.getStatement(),
+          statements = [
+            ...suppositionStatements,
+            lastProofStepStatement
+          ];
+
+    return statements;
+  }
+
+
+  verify(substitutions, localContext) {
+    let subproofVerified = false;
+
+    localContext = LocalContext.fromLocalContext(localContext);  ///
+
+    const suppositionsVerified = this.suppositions.every((supposition) => {
+      const suppositionVerified = supposition.verify(localContext);
+
+      if (suppositionVerified) {
+        return true;
+      }
+    });
+
+    if (suppositionsVerified) {
+      const subDerivationVerified = this.subDerivation.verify(substitutions, localContext);
+
+      if (subDerivationVerified) {
+        subproofVerified = true;
+      }
+    }
+
+    return subproofVerified;
+  }
+
+  static fromSubproofNode(subproofNode, fileContext) {
+    let subproof = null;
+
+    if (subproofNode !== null) {
+      const subproofString = subproofStringFromSubproofNode(subproofNode, fileContext),
+            suppositionNodes = suppositionNodesQuery(subproofNode),
+            subDerivationNode = subDerivationNodeQuery(subproofNode),
+            string = subproofString,  ///
+            suppositions = suppositionNodes.map((suppositionNode) => {
+              const supposition = Supposition.fromSuppositionNode(suppositionNode, fileContext);
+
+              return supposition;
+            }),
+            subDerivation = SubDerivation.fromSubDerivationNode(subDerivationNode, fileContext);
+
+      subproof = new Subproof(string, suppositions, subDerivation);
+    }
+
+    return subproof;
+  }
+}

package/src/substitution/frameForMetavariable.js

@@ -9,8 +9,8 @@ const substitutionFrameNodeQuery = nodeQuery("/substitution/frame!"),
       substitutionMetavariableNodeQuery = nodeQuery("/substitution/metavariable!");
 
 export default class FrameForMetavariableSubstitution extends Substitution {
-  constructor(frameNode, metavariableNode) {
-    super();
+  constructor(string, frameNode, metavariableNode) {
+    super(string);
 
     this.frameNode = frameNode;
     this.metavariableNode = metavariableNode;
@@ -69,17 +69,7 @@ export default class FrameForMetavariableSubstitution extends Substitution {
     return metavariableNodeMatches;
   }
 
-  asString(localContextA, localContextB) {
-    const frameNodeB = this.frameNode,  ///
-          frameStringB = localContextB.nodeAsString(frameNodeB),
-          metavariableNodeA = this.metavariableNode,  ///
-          metavariableStringA = localContextA.nodeAsString(metavariableNodeA),
-          string = `[${frameStringB} for ${metavariableStringA}]`;
-
-    return string;
-  }
-
-  static fromSubstitutionNode(substitutionNode) {
+  static fromSubstitutionNode(substitutionNode, localContextA, localContextB) {
     let frameForMetavariableSubstitution = null;
 
     const substitutionFrameNode = substitutionFrameNodeQuery(substitutionNode);
@@ -87,16 +77,18 @@ export default class FrameForMetavariableSubstitution extends Substitution {
     if (substitutionFrameNode !== null) {
       const substitutionMetavariableNode = substitutionMetavariableNodeQuery(substitutionNode),
             metavariableNode = substitutionMetavariableNode,  ///
-            frameNode = substitutionFrameNode;  ///
+            frameNode = substitutionFrameNode,  ///
+            string = stringFromFrameNodeAndMetavariableNode(frameNode, metavariableNode, localContextA, localContextB);
 
-      frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(frameNode, metavariableNode);
+        frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frameNode, metavariableNode);
     }
 
     return frameForMetavariableSubstitution;
   }
 
-  static fromFrameNodeAndMetavariableNode(frameNode, metavariableNode) {
-    const frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(frameNode, metavariableNode);
+  static fromFrameNodeAndMetavariableNode(frameNode, metavariableNode, localContextA, localContextB) {
+    const string = stringFromFrameNodeAndMetavariableNode(frameNode, metavariableNode, localContextA, localContextB),
+          frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frameNode, metavariableNode);
 
     return frameForMetavariableSubstitution;
   }
@@ -146,3 +138,14 @@ function transformMetavariableNode(metavariableNode, substitutions) {
 
   return transformedMetavariableNode;
 }
+
+function stringFromFrameNodeAndMetavariableNode(frameNode, metavariableNode, localContextA, localContextB) {
+  const frameNodeB = frameNode,  ///
+        frameStringB = localContextB.nodeAsString(frameNodeB),
+        metavariableNodeA = metavariableNode,  ///
+        metavariableStringA = localContextA.nodeAsString(metavariableNodeA),
+        string = `[${frameStringB} for ${metavariableStringA}]`;
+
+  return string;
+}
+

package/src/substitution/statementForMetavariable.js

@@ -7,8 +7,8 @@ import FrameForMetavariableSubstitution from "../substitution/frameForMetavariab
 import { stripBracketsFromStatement } from "../utilities/brackets";
 
 export default class StatementForMetavariableSubstitution extends Substitution {
-  constructor(statementNode, metavariableNode, substitution) {
-    super();
+  constructor(string, statementNode, metavariableNode, substitution) {
+    super(string);
 
     this.statementNode = statementNode;
     this.metavariableNode = metavariableNode;
@@ -53,49 +53,32 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return metavariableNodeMatches;
   }
 
-  asString(localContextA, localContextB) {
-    let string;
-
-    const statementNodeB = this.statementNode,  ///
-          statementStringB = localContextB.nodeAsString(statementNodeB),
-          metavariableNodeA = this.metavariableNode,  ///
-          metavariableStringA = localContextA.nodeAsString(metavariableNodeA);
-
-    if (this.substitution === null) {
-      string = `[${statementStringB} for ${metavariableStringA}]`;
-    } else {
-      const substitutionString = this.substitution.asString(localContextA, localContextA);
-
-      string = `[${statementStringB} for ${metavariableStringA}${substitutionString}]`;
-    }
-
-    return string;
-  }
-
-  static fromStatementNodeAndMetavariableNode(statementNode, metavariableNode) {
+  static fromStatementNodeAndMetavariableNode(statementNode, metavariableNode, localContextA, localContextB) {
     statementNode = stripBracketsFromStatement(statementNode); ///
 
     const substitution = null,
-          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(statementNode, metavariableNode, substitution);
+          string = stringFromStatementNodeMetavariableNodeAndSubstitution(statementNode, metavariableNode, substitution, localContextA, localContextB),
+          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, statementNode, metavariableNode, substitution);
 
     return statementForMetavariableSubstitution;
   }
 
-  static fromStatementNodeMetavariableNodeAndSubstitutionNode(statementNode, metavariableNode, substitutionNode) {
+  static fromStatementNodeMetavariableNodeAndSubstitutionNode(statementNode, metavariableNode, substitutionNode, localContextA, localContextB) {
     statementNode = stripBracketsFromStatement(statementNode); ///
 
-    const substitution = substitutionFromSubstitutionNode(substitutionNode),
-          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(statementNode, metavariableNode, substitution);
+    const substitution = substitutionFromSubstitutionNode(substitutionNode, localContextA, localContextB),
+          string = stringFromStatementNodeMetavariableNodeAndSubstitution(statementNode, metavariableNode, substitution, localContextA, localContextB),
+          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, statementNode, metavariableNode, substitution);
 
     return statementForMetavariableSubstitution;
   }
 }
 
-function substitutionFromSubstitutionNode(substitutionNode) {
+function substitutionFromSubstitutionNode(substitutionNode, localContextA, localContextB) {
   let substitution = null;
 
   if (substitution === null) {
-    const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionNode(substitutionNode);
+    const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionNode(substitutionNode, localContextA, localContextB);
 
     if (termForVariableSubstitution !== null) {
       substitution = termForVariableSubstitution; ///
@@ -103,7 +86,7 @@ function substitutionFromSubstitutionNode(substitutionNode) {
   }
 
   if (substitution === null) {
-    const frameForMetavariableSubstitution = FrameForMetavariableSubstitution.fromSubstitutionNode(substitutionNode);
+    const frameForMetavariableSubstitution = FrameForMetavariableSubstitution.fromSubstitutionNode(substitutionNode, localContextA, localContextB);
 
     if (frameForMetavariableSubstitution !== null) {
       substitution = frameForMetavariableSubstitution;  ///
@@ -112,3 +95,22 @@ function substitutionFromSubstitutionNode(substitutionNode) {
 
   return substitution;
 }
+
+function stringFromStatementNodeMetavariableNodeAndSubstitution(statementNode, metavariableNode, substitution, localContextA, localContextB) {
+  let string;
+
+  const statementNodeB = statementNode,  ///
+        statementStringB = localContextB.nodeAsString(statementNodeB),
+        metavariableNodeA = metavariableNode,  ///
+        metavariableStringA = localContextA.nodeAsString(metavariableNodeA);
+
+  if (substitution === null) {
+    string = `[${statementStringB} for ${metavariableStringA}]`;
+  } else {
+    const substitutionString = substitution.asString(localContextA, localContextA);
+
+    string = `[${statementStringB} for ${metavariableStringA}${substitutionString}]`;
+  }
+
+  return string;
+}

package/src/substitution/termForVariable.js

@@ -10,8 +10,8 @@ const termVariableNodeQuery = nodeQuery("/term/variable!"),
       substitutionsVariableNodeQuery = nodeQuery("/substitution/variable!");
 
 export default class TermForVariableSubstitution extends Substitution {
-  constructor(termNode, variableNode) {
-    super();
+  constructor(string, termNode, variableNode) {
+    super(string);
 
     this.termNode = termNode;
     this.variableNode = variableNode;
@@ -88,16 +88,6 @@ export default class TermForVariableSubstitution extends Substitution {
     return unifiedWithEquivalence;
   }
 
-  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) {
     let termForVariableSubstitution = null;
 
@@ -117,10 +107,11 @@ export default class TermForVariableSubstitution extends Substitution {
     return termForVariableSubstitution;
   }
 
-  static fromTernNodeAndVariableNode(termNode, variableNode) {
+  static fromTernNodeAndVariableNode(termNode, variableNode, localContextA, localContextB) {
     termNode = stripBracketsFromTerm(termNode); ///
 
-    const termForVariableSubstitution = new TermForVariableSubstitution(termNode, variableNode);
+    const string = stringFromTermNodeAndVariableNode(termNode, variableNode, localContextA, localContextB),
+          termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode);
 
     return termForVariableSubstitution;
   }
@@ -170,3 +161,13 @@ function transformVariableNode(variableNode, substitutions) {
 
   return transformedVariableNode;
 }
+
+function stringFromTermNodeAndVariableNode(termNode, variableNode, localContextA, localContextB) {
+  const termNodeB = termNode,  ///
+        termStringB = localContextB.nodeAsString(termNodeB),
+        variableNodeA = variableNode,  ///
+        variableStringA = localContextA.nodeAsString(variableNodeA),
+        string = `[${termStringB} for ${variableStringA}]`;
+
+  return string;
+}

package/src/substitution.js

@@ -1,6 +1,14 @@
 "use strict";
 
 export default class Substitution {
+  constructor(string) {
+    this.string = string;
+  }
+
+  getString() {
+    return this.string;
+  }
+
   isSimple() {
     const simple = true;
 

package/src/substitutions.js

@@ -177,16 +177,15 @@ export default class Substitutions {
     return complexSubstitution;
   }
 
-  addSubstitution(substitution, localContextA, localContextB) {
+  addSubstitution(substitution, localContext) {
     this.array.push(substitution);
 
-    const substitutionNode = substitution.getNode(),
-          substitutionString = substitution.asString(localContextA, localContextB);
+    const substitutionString = substitution.getString();
 
-    localContextB.trace(`Added the ${substitutionString} substitution.`, substitutionNode);
+    localContext.trace(`Added the ${substitutionString} substitution.`);
   }
 
-  removeSubstitution(substitution, localContextA, localContextB) {
+  removeSubstitution(substitution, localContext) {
     const substitutionA = substitution; ///
 
     prune(this.array, (substitution) => {
@@ -198,15 +197,15 @@ export default class Substitutions {
     });
 
     const substitutionNode = substitution.getNode(),
-          substitutionString = substitution.asString(localContextA, localContextB);
+          substitutionString = substitution.getString();
 
-    localContextB.trace(`Removed the ${substitutionString} substitution.`, substitutionNode);
+    localContext.trace(`Removed the ${substitutionString} substitution.`, substitutionNode);
   }
 
-  unifyWithEquivalences(equivalences, localContextA, localContextB) {
+  unifyWithEquivalences(equivalences, localContext) {
     const unifiedWithEquivalences = this.everySubstitution((substitution) => {
       const substitutions = this, ///
-            substitutionUnifiedWithEquivalence = substitution.unifyWithEquivalences(equivalences, substitutions, localContextA, localContextB);
+            substitutionUnifiedWithEquivalence = substitution.unifyWithEquivalences(equivalences, substitutions, localContext);
 
       if (substitutionUnifiedWithEquivalence) {
         return true;
@@ -232,7 +231,7 @@ export default class Substitutions {
     ];
   }
 
-  rollback(localContextA, localContextB) {
+  rollback(localContext) {
     const array = [
       ...this.array
     ];
@@ -240,7 +239,7 @@ export default class Substitutions {
     rightDifference(this.savedArray, array);
 
     array.forEach((substitution) => {
-      this.removeSubstitution(substitution, localContextA, localContextB);
+      this.removeSubstitution(substitution, localContext);
     });
 
     this.array = [
@@ -254,9 +253,9 @@ export default class Substitutions {
     this.savedArray = null;
   }
 
-  asString(localContextA, localContextB) {
+  getString(localContextA, localContextB) {
     let string = this.array.reduce((string, substitution) => {
-      const substitutionString = substitution.asString(localContextA, localContextB);
+      const substitutionString = substitution.getString(localContextA, localContextB);
 
       string = (string === null) ?
                  substitutionString :

package/src/supposition.js

@@ -1,72 +1,117 @@
 "use strict";
 
-import metaLevelUnifier from "./unifier/metaLevel";
+import ProofStep from "./proofStep";
+import UnqualifiedStatement from "./statement/unqualified";
 
-import { match } from "./utilities/array";
-import { nodeAsString } from "./utilities/string";
-import { nodeQuery, nodesQuery } from "./utilities/query";
+import { trim } from "./utilities/string";
+import { nodeQuery } from "./utilities/query";
+import { assignAssignments } from "./utilities/assignments";
 
-const subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
-      subproofAssertionStatementNodesQuery = nodesQuery("/subproofAssertion/statement"),
-      subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement/statement!"),
-      subproofLastProofStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/lastProofStep/unqualifiedStatement|qualifiedStatement/statement!");
+const unqualifiedStatementNodeQuery = nodeQuery("/supposition/unqualifiedStatement");
 
 export default class Supposition {
-  constructor(statementNode) {
-    this.statementNode = statementNode;
+  constructor(fileContext, unqualifiedStatement) {
+    this.fileContext = fileContext;
+    this.unqualifiedStatement = unqualifiedStatement;
   }
 
-  getStatementNode() {
-    return this.statementNode;
+  getFileContext() {
+    return this.fileContext;
   }
 
-  unifyStatement(statementNodeB, substitutions, localContextA, localContextB) {
-    let statementUnified = false;
+  getUnqualifiedStatement() {
+    return this.unqualifiedStatement;
+  }
 
-    if (this.statementNode !== null) {
-      const nodeA = this.statementNode,  ///
-            nodeB = statementNodeB,  ///
-            unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+  getString() { return this.unqualifiedStatement.getString(); }
+
+  getStatement() { return this.unqualifiedStatement.getStatement(); }
+
+  // unifyStatement(statementNodeB, substitutions, localContextA, localContextB) {
+  //   let statementUnified = false;
+  //
+  //   if (this.statementNode !== null) {
+  //     const nodeA = this.statementNode,  ///
+  //           nodeB = statementNodeB,  ///
+  //           unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+  //
+  //     statementUnified = unified; ///
+  //   }
+  //
+  //   return statementUnified;
+  // }
+
+  // unifySubproof(subproofNodeB, substitutions, localContextA, localContextB) {
+  //   let subproofUnified = false;
+  //
+  //   if (this.statementNode !== null) {
+  //     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) {
+  //           return true;
+  //         }
+  //       });
+  //     }
+  //   }
+  //
+  //   return subproofUnified;
+  // }
+
+  verify(localContext) {
+    let verified = false,
+        suppositionString = this.getString(); ///
+
+    suppositionString = trim(suppositionString);  ///
+
+    if (this.unqualifiedStatement !== null) {
+      localContext.trace(`Verifying the '${suppositionString}' supposition...`);
+
+      const stated = true,
+            assignments = [],
+            unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, localContext);
+
+      if (unqualifiedStatementVerified) {
+        const assignmentsAssigned = assignAssignments(assignments, localContext);
+
+        if (assignmentsAssigned) {
+          const proofStep = ProofStep.fromUnqualifiedStatement(this.unqualifiedStatement);
+
+          localContext.addProofStep(proofStep);
+
+          verified = true;
+        }
+      }
 
-      statementUnified = unified; ///
+    } else {
+      localContext.debug(`The '${suppositionString}' supposition cannot be verified because it is nonsense.`);
     }
 
-    return statementUnified;
-  }
-
-  unifySubproof(subproofNodeB, substitutions, localContextA, localContextB) {
-    let subproofUnified = false;
-
-    if (this.statementNode !== null) {
-      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) {
-            return true;
-          }
-        });
-      }
+    if (verified) {
+      localContext.debug(`...verified the '${suppositionString}' supposition.`);
     }
 
-    return subproofUnified;
+    return verified;
   }
 
-  static fromStatementNode(statementNode) {
-    const supposition = new Supposition(statementNode);
+  static fromSuppositionNode(suppositionNode, fileContext) {
+    const unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
+          unqualifiedStatement = UnqualifiedStatement.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
+          supposition = new Supposition(fileContext, unqualifiedStatement);
 
     return supposition;
   }

package/src/unifier/statementWithCombinator.js

@@ -1,9 +1,9 @@
 "use strict";
 
+import shim from "../shim";
 import Unifier from "../unifier";
 import unifyTermWithType from "../unify/termWithType";
 import unifyFrameWithMetaType from "../unify/frameWithMetaType";
-import unifyStatementWithMetaType from "../unify/statementWithMetaType";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -31,9 +31,12 @@ class StatementWithCombinatorUnifier extends Unifier {
       nodeQueryA: statementNodeQuery,
       nodeQueryB: metaTypeNodeQuery,
       unify: (statementNodeA, metaTypeNodeB, assignments, stated, localContext) => {
-        const metaTypeNode = metaTypeNodeB, ///
+        const { MetaType, Statement } = shim,
+              metaTypeNode = metaTypeNodeB, ///
               statementNode = statementNodeA, ///
-              statementUnifiedWithMetaType = unifyStatementWithMetaType(statementNode, metaTypeNode, assignments, stated, localContext);
+              metaType = MetaType.fromMetaTypeNode(metaTypeNode, localContext),
+              statement = Statement.fromStatementNode(statementNode, localContext),
+              statementUnifiedWithMetaType = statement.unifyWithMetaType(metaType, assignments, stated, localContext);
 
         return statementUnifiedWithMetaType;
       }

package/src/unify/metavariableWithFrame.js

@@ -27,7 +27,7 @@ export default function unifyMetavariableWithFrame(metavariableNodeA, frameNodeB
     } else {
       const frameNode = frameNodeB, ///
             metavariableNode = metavariableNodeA, ///
-            frameForMetavariableSubstitution = FrameForMetavariableSubstitution.fromFrameNodeAndMetavariableNode(frameNode, metavariableNode),
+            frameForMetavariableSubstitution = FrameForMetavariableSubstitution.fromFrameNodeAndMetavariableNode(frameNode, metavariableNode, localContextA, localContextB),
             substitution = frameForMetavariableSubstitution;  ///
 
       substitutions.addSubstitution(substitution, localContextA, localContextB);

package/src/unify/metavariableWithStatement.js

@@ -27,7 +27,7 @@ export default function unifyMetavariableWithStatement(metavariableNodeA, statem
     } else {
       const statementNode = statementNodeB, ///
             metavariableNode = metavariableNodeA, ///
-            statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementNodeAndMetavariableNode(statementNode, metavariableNode),
+            statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementNodeAndMetavariableNode(statementNode, metavariableNode, localContextA, localContextB),
             substitution = statementForMetavariableSubstitution;  ///
 
       substitutions.addSubstitution(substitution, localContextA, localContextB);

package/src/unify/metavariableWithStatementGivenSubstitution.js

@@ -28,7 +28,7 @@ export default function unifyMetavariableWithStatementGivenSubstitution(metavari
       const statementNode = statementNodeB, ///
             substitutionNode = substitutionNodeA, ///
             metavariableNode = metavariableNodeA, ///
-            statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementNodeMetavariableNodeAndSubstitutionNode(statementNode, metavariableNode, substitutionNode),
+            statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementNodeMetavariableNodeAndSubstitutionNode(statementNode, metavariableNode, substitutionNode, localContextA, localContextB),
             substitution = statementForMetavariableSubstitution;  ///
 
       substitutions.addSubstitution(substitution, localContextA, localContextB);

package/src/unify/variableWithTerm.js

@@ -24,7 +24,7 @@ export default function unifyVariableWithTerm(variableNodeA, termNodeB, substitu
     } else {
       const termNode = termNodeB, ///
             variableNode = variableNodeA, ///
-            termForVariableSubstitution = TermForVariableSubstitution.fromTernNodeAndVariableNode(termNode, variableNode),
+            termForVariableSubstitution = TermForVariableSubstitution.fromTernNodeAndVariableNode(termNode, variableNode, localContextA, localContextB),
             substitution = termForVariableSubstitution;  ///
 
       substitutions.addSubstitution(substitution, localContextA, localContextB);