occam-verify-cli 0.0.1063 → 0.0.1065

package/src/consequent.js

@@ -1,7 +1,5 @@
 "use strict";
 
-import LocalContext from "./context/local";
-import metaLevelUnifier from "./unifier/metaLevel";
 import UnqualifiedStatement from "./statement/unqualified";
 
 import { nodeQuery } from "./utilities/query";
@@ -29,26 +27,15 @@ export default class Consequent {
   unifyStatement(statement, substitutions, localContext) {
     let statementUnified;
 
-    const consequent = this, ///
-          statementString = statement.getString(),
-          consequentStatement = consequent.getStatement(),
-          consequentStatementString = consequentStatement.getString();
+    const statementString = statement.getString(),
+          consequentString = this.getString();
 
-    localContext.trace(`Unifying the '${statementString}' statement with the consequent's '${consequentStatementString}' statement...`);
+    localContext.trace(`Unifying the '${statementString}' statement with the '${consequentString}' consequent...`);
 
-    const statementNode = statement.getNode(),
-          consequentStatementNode = consequentStatement.getNode(),
-          nodeA = consequentStatementNode,  ///
-          nodeB = statementNode,  ///
-          fileContextA = this.fileContext,  ///
-          localContextA = LocalContext.fromFileContext(fileContextA),
-          localContextB = localContext, ///
-          unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
-
-    statementUnified = unified; ///
+    statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, this.fileContext, localContext);
 
     if (statementUnified) {
-      localContext.debug(`...unified the '${statementString}' statement with the consequent's '${consequentStatementString}' statement.`);
+      localContext.debug(`...unified the '${statementString}' statement with the '${consequentString}' consequent.`);
     }
 
     return statementUnified;

package/src/metavariable.js

@@ -13,7 +13,7 @@ import { metavariableNodeFromMetavariableString } from "./utilities/node";
 const argumentNodeQuery = nodeQuery("/metavariable/argument"),
       metaTypeNodeQuery = nodeQuery("/metavariableDeclaration/metaType"),
       metavariableNodeQuery = nodeQuery("/metavariableDeclaration/metavariable"),
-      statementMetavariableNodeQuery = nodeQuery("/statement/metavariable");
+      statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!");
 
 class Metavariable {
   constructor(fileContext, string, node, name, metaType) {
@@ -174,40 +174,38 @@ class Metavariable {
           substitutionString = substitution.getString(),
           metavariableString = this.string; ///
 
-    localContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}' metavariable givne the '${substitutionString}' substitution...`);
-
-    // let metavariableUnifiedWithStatementGivenSubstitution = false;
-    //
-    // const metavariableNode = metavariable.getNode(),
-    //   substitutionNode = substitution.getNode(),
-    //   complexSubstitution = substitutions.findComplexSubstitutionByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode);
-    //
-    // if (complexSubstitution !== null) {
-    //   const statementNode = statement.getNode(),
-    //     statementNodeMatches = complexSubstitution.matchStatementNode(statementNode);
-    //
-    //   if (statementNodeMatches) {
-    //     metavariableUnifiedWithStatementGivenSubstitution = true;
-    //   }
-    // } else {
-    //   const metavariableNameA = metavariableNameFromMetavariableNode(metavariableNode),
-    //     metavariableA = localContextA.findMetavariableByMetavariableName(metavariableNameA),
-    //     metavariableB = metavariableFromStatementNode(statement, localContextB);
-    //
-    //   if (metavariableA === metavariableB) {
-    //     metavariableUnifiedWithStatementGivenSubstitution = false;  ///
-    //   } else {
-    //     const statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContextA, localContextB),
-    //       substitution = statementForMetavariableSubstitution;  ///
-    //
-    //     substitutions.addSubstitution(substitution, localContextA, localContextB);
-    //
-    //     metavariableUnifiedWithStatementGivenSubstitution = true;
-    //   }
-    // }
+    localContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}' metavariable given the '${substitutionString}' substitution...`);
+
+    const statementNode = statement.getNode(),
+          metavariableNode = this.node, ///
+          substitutionNode = substitution.getNode(),
+          complexSubstitution = substitutions.findComplexSubstitutionByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode);
+
+    if (complexSubstitution !== null) {
+      const statementNodeMatches = complexSubstitution.matchStatementNode(statementNode);
+
+      if (statementNodeMatches) {
+        statementUnifiedGivenSubstitution = true;
+      }
+    } else {
+      const metavariable = metavariableFromStatementNode(statementNode, localContext);
+
+      if (this === metavariable) {  ///
+        statementUnifiedGivenSubstitution = false;  ///
+      } else {
+        const metavariable = this,  ///
+              statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext);
+
+        substitution = statementForMetavariableSubstitution;  ///
+
+        substitutions.addSubstitution(substitution, localContext);
+
+        statementUnifiedGivenSubstitution = true;
+      }
+    }
 
     if (statementUnifiedGivenSubstitution) {
-      localContext.trace(`...unified the '${statementString}' statement with the '${metavariableString}' metavariable givne the '${substitutionString}' substitution.`);
+      localContext.trace(`...unified the '${statementString}' statement with the '${metavariableString}' metavariable given the '${substitutionString}' substitution.`);
     }
 
     return statementUnifiedGivenSubstitution;
@@ -294,6 +292,21 @@ function metaTypeFromJSON(json, fileContext) {
   return metaType;
 }
 
+function metavariableFromStatementNode(statementNode, localContext) {
+  let metavariable = null;
+
+  const statementMetavariableNode = statementMetavariableNodeQuery(statementNode)
+
+  if (statementMetavariableNode !== null) {
+    const metavariableNode = statementMetavariableNode, ///
+          metavariableName = metavariableNameFromMetavariableNode(metavariableNode);
+
+    metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
+  }
+
+  return metavariable;
+}
+
 function statementMetavariableFromStatementNode(statementNode, localContext) {
   let statementMetavariable = null;
 

package/src/premise.js

@@ -1,8 +1,6 @@
 "use strict";
 
 import shim from "./shim";
-import LocalContext from "./context/local";
-import metaLevelUnifier from "./unifier/metaLevel";
 import SubproofAssertion from "./assertion/subproof";
 import UnqualifiedStatement from "./statement/unqualified";
 
@@ -80,26 +78,15 @@ export default class Premise {
   unifyStatement(statement, substitutions, localContext) {
     let statementUnified;
 
-    const premise = this, ///
-          statementString = statement.getString(),
-          premiseStatement = premise.getStatement(),
-          premiseStatementString = premiseStatement.getString();
-
-    localContext.trace(`Unifying the '${statementString}' statement with the premise's '${premiseStatementString}' statement...`);
+    const statementString = statement.getString(),
+          premiseString = this.getString();
 
-    const statementNode = statement.getNode(),
-          premiseStatementNode = premiseStatement.getNode(),
-          nodeA = premiseStatementNode,  ///
-          nodeB = statementNode,  ///
-          fileContextA = this.fileContext,  ///
-          localContextA = LocalContext.fromFileContext(fileContextA),
-          localContextB = localContext, ///
-          unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+    localContext.trace(`Unifying the '${statementString}' statement with the '${premiseString}' premise...`);
 
-    statementUnified = unified; ///
+    statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, this.fileContext, localContext);
 
     if (statementUnified) {
-      localContext.debug(`...unified the '${statementString}' statement with the premise's '${premiseStatementString}' statement.`);
+      localContext.debug(`...unified the '${statementString}' statement with the '${premiseString}' premise.`);
     }
 
     return statementUnified;

package/src/proofStep.js

@@ -71,7 +71,7 @@ class ProofStep {
 
       verified = qualifiedStatementVerified;  ///
     } else if (this.unqualifiedStatement !== null) {
-      const stated = true,
+      const stated = false,
             assignments = [],
             unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, localContext);
 

package/src/statement/unqualified.js

@@ -45,6 +45,23 @@ export default class UnqualifiedStatement {
     return verified;
   }
 
+  unifyStatement(statement, substitutions, fileContext, localContext) {
+    let statementUnified;
+
+    const statementString = statement.getString(),
+          unqualifiedStatementString = this.getString();  ///
+
+    localContext.trace(`Unifying the '${statementString}' statement with the '${unqualifiedStatementString}' unqualified statement...`);
+
+    statementUnified = this.statement.unifyStatement(statement, substitutions, fileContext, localContext);
+
+    if (statementUnified) {
+      localContext.debug(`...unified the '${statementString}' statement with the '${unqualifiedStatementString}' unqualified statement.`);
+    }
+
+    return statementUnified;
+  }
+
   toJSON() {
     const statementJSON = this.statement.toJSON(),
           statement = statementJSON,  ///

package/src/statement.js

@@ -3,7 +3,8 @@
 import shim from "./shim";
 import unifyMixins from "./mixins/statement/unify";
 import verifyMixins from "./mixins/statement/verify";
-import StatementSubstitution from "./substitution/statement";
+import LocalContext from "./context/local";
+import metaLevelUnifier from "./unifier/metaLevel";
 import statementAsCombinatorVerifier from "./verifier/statementAsCombinator";
 
 import { nodeQuery, nodesQuery } from "./utilities/query";
@@ -11,14 +12,14 @@ import { STATEMENT_META_TYPE_NAME } from "./metaTypeNames";
 import { statementNodeFromStatementString } from "./utilities/node";
 
 const statementNodeQuery = nodeQuery("/*//statement"),
+      substitutionNodeQuery = nodeQuery("/statement/substitution"),
       statementVariableNodesQuery = nodesQuery("/statement//variable"),
       statementMetavariableNodesQuery = nodesQuery("/statement//metavariable");
 
 class Statement {
-  constructor(string, node, substitution) {
+  constructor(string, node) {
     this.string = string;
     this.node = node;
-    this.substitution = substitution;
   }
 
   getString() {
@@ -29,10 +30,6 @@ class Statement {
     return this.node;
   }
 
-  getSubstitution() {
-    return this.substitution;
-  }
-
   isEqualTo(statement) {
     const node = statement.getNode(),
           matches = this.node.match(node),
@@ -172,14 +169,35 @@ class Statement {
     return verifiedGivenMetaType;
   }
 
+  unifyStatement(statement, substitutions, fileContext, localContext) {
+    let statementUnified;
+
+    const statementA = this,  ///
+          statementB = statement, ///
+          statementAString = statementA.getString(),
+          statementBString = statementB.getString();
+
+    localContext.trace(`Unifying the '${statementBString}' statement with the '${statementAString}' statement...`);
+
+    const statementANode = statementA.getNode(),
+          statementBNode = statementB.getNode(),
+          nodeA = statementANode, ///
+          nodeB = statementBNode, ///
+          fileContextA = fileContext, ///
+          localContextA = LocalContext.fromFileContext(fileContextA),
+          localContextB = localContext, ///
+          unifiedAtMetaLevel = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+
+    statementUnified = unifiedAtMetaLevel; ///
+
+    localContext.debug(`...unified the '${statementBString}' statement with the '${statementAString}' statement.`);
+
+    return statementUnified;
+  }
+
   toJSON() {
-    const substitutionJSON = (this.substitution !== null) ?
-                                this.substitution.toJSON() :
-                                  null,
-          substitution = substitutionJSON,  ///
-          string = this.string, ///
+    const string = this.string, ///
           json = {
-            substitution,
             string
           };
 
@@ -192,17 +210,8 @@ class Statement {
           lexer = fileContext.getLexer(),
           parser = fileContext.getParser(),
           statementNode = statementNodeFromStatementString(statementString, lexer, parser),
-          node = statementNode;  ///
-
-    let { substitution } = json;
-
-    json = substitution;  ///
-
-    const statementSubstitution = StatementSubstitution.fromJSON(json, fileContext);
-
-    substitution = statementSubstitution; ///
-
-    const statement = new Statement(string, node, substitution);
+          node = statementNode,  ///
+          statement = new Statement(string, node);
 
     return statement;
   }
@@ -212,11 +221,9 @@ class Statement {
 
     if (statementNode !== null) {
       const node = statementNode, ///
-            string = localContext.nodeAsString(node),
-            statementSubstitution = StatementSubstitution.fromStatementNode(statementNode, localContext),
-            substitution = statementSubstitution; ///
+            string = localContext.nodeAsString(node);
 
-      statement = new Statement(string, node, substitution);
+      statement = new Statement(string, node);
     }
 
     return statement;
@@ -226,9 +233,7 @@ class Statement {
     const statementNode = statementNodeQuery(definedAssertionNode),
           node = statementNode, ///
           string = localContext.nodeAsString(node),
-          statementSubstitution = StatementSubstitution.fromStatementNode(statementNode, localContext),
-          substitution = statementSubstitution, ///
-          statement = new Statement(string, node, substitution);
+          statement = new Statement(string, node);
 
     return statement;
   }
@@ -237,9 +242,7 @@ class Statement {
     const statementNode = statementNodeQuery(containedAssertionNode),
           node = statementNode, ///
           string = localContext.nodeAsString(node),
-          statementSubstitution = StatementSubstitution.fromStatementNode(statementNode, localContext),
-          substitution = statementSubstitution, ///
-          statement = new Statement(string, node, substitution);
+          statement = new Statement(string, node);
 
     return statement;
   }

package/src/substitution/statementForMetavariable.js

@@ -81,7 +81,7 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     statement = Statement.fromStatementNode(statementNode, localContext); ///
 
     const metavariableNode = metavariable.getNode(),
-          string = stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext);
+          string = stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution);
 
     substitution = substitutionFromSubstitution(substitution, localContext);
 
@@ -91,53 +91,46 @@ export default class StatementForMetavariableSubstitution extends Substitution {
   }
 }
 
-function stringFromStatementAndMetavariable(statement, metavariable) {
-  const statementString = statement.getString(),
-        metavariableString = metavariable.getString(),
-        string = `[${statementString} for ${metavariableString}]`;
+function substitutionFromSubstitution(substitution, localContext) {
+  if (substitution === null) {
+    const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitution(substitution, localContext);
 
-  return string;
-}
+    if (termForVariableSubstitution !== null) {
+      substitution = termForVariableSubstitution; ///
+    }
+  }
 
+  if (substitution === null) {
+    const frameForMetavariableSubstitution = FrameForMetavariableSubstitution.fromSubstitution(substitution, localContext);
 
-function substitutionFromSubstitution(substitution, localContextA, localContextB) {
-  // let substitution = null;
+    if (frameForMetavariableSubstitution !== null) {
+      substitution = frameForMetavariableSubstitution;  ///
+    }
+  }
 
-  debugger
+  return substitution;
+}
 
-  // if (substitution === null) {
-  //   const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitution(substitutionNode, localContextA, localContextB);
-  //
-  //   if (termForVariableSubstitution !== null) {
-  //     substitution = termForVariableSubstitution; ///
-  //   }
-  // }
-  //
-  // if (substitution === null) {
-  //   const frameForMetavariableSubstitution = FrameForMetavariableSubstitution.fromSubstitution(substitutionNode, localContextA, localContextB);
-  //
-  //   if (frameForMetavariableSubstitution !== null) {
-  //     substitution = frameForMetavariableSubstitution;  ///
-  //   }
-  // }
+function stringFromStatementAndMetavariable(statement, metavariable) {
+  const statementString = statement.getString(),
+        metavariableString = metavariable.getString(),
+        string = `[${statementString} for ${metavariableString}]`;
 
-  return substitution;
+  return string;
 }
 
-function stringFromStatementMetavariableAndSubstitution(statementNode, metavariableNode, substitution, localContextA, localContextB) {
+function stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution) {
   let string;
 
-  const statementNodeB = statementNode,  ///
-        statementStringB = localContextB.nodeAsString(statementNodeB),
-        metavariableNodeA = metavariableNode,  ///
-        metavariableStringA = localContextA.nodeAsString(metavariableNodeA);
+  const statementString = statement.getString(),
+        metavariableString = metavariable.getString();
 
   if (substitution === null) {
-    string = `[${statementStringB} for ${metavariableStringA}]`;
+    string = `[${statementString} for ${metavariableString}]`;
   } else {
-    const substitutionString = substitution.asString(localContextA, localContextA);
+    const substitutionString = substitution.getString();
 
-    string = `[${statementStringB} for ${metavariableStringA}${substitutionString}]`;
+    string = `[${statementString} for ${metavariableString}${substitutionString}]`;
   }
 
   return string;

package/src/substitution/termForVariable.js

@@ -83,7 +83,7 @@ export default class TermForVariableSubstitution extends Substitution {
     return unifiedWithEquivalence;
   }
 
-  static fromSubstitution(substitution) {
+  static fromSubstitution(substitution, localContext) {
     let termForVariableSubstitution = null;
 
     const substitutionNode = substitution.getNode();
@@ -91,30 +91,33 @@ export default class TermForVariableSubstitution extends Substitution {
     let substitutionTermNode = substitutionTermNodeQuery(substitutionNode);
 
     if (substitutionTermNode !== null) {
-      let termNode = substitutionTermNode;  ///
-
-      termNode = stripBracketsFromTerm(termNode); ///
+      let termNode;
 
       const substitutionVariableNode = substitutionsVariableNodeQuery(substitutionNode),
             variableNode = substitutionVariableNode;  ///
 
-      termForVariableSubstitution = new TermForVariableSubstitution(termNode, variableNode);
+      termNode = substitutionTermNode;  ///
+
+      termNode = stripBracketsFromTerm(termNode); ///
+
+      const { Term, Variable } = shim,
+            term = Term.fromTermNode(termNode, localContext),
+            variable = Variable.fromVariableNode(variableNode, localContext),
+            string = stringFromTermAndVariable(term, variable);
+
+      termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode);
     }
 
     return termForVariableSubstitution;
   }
 
-  static fromTernAndVariable(term, variable, localContext) {
+  static fromTernAndVariable(term, variable) {
     let termNode = term.getNode();
 
     termNode = stripBracketsFromTerm(termNode); ///
 
-    const { Term } = shim;
-
-    term = Term.fromTermNode(termNode, localContext); ///
-
-    const string = stringFromTermAndVariable(term, variable),
-          variableNode = variable.getNode(),
+    const variableNode = variable.getNode(),
+          string = stringFromTermAndVariable(term, variable),
           termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode);
 
     return termForVariableSubstitution;

package/src/supposition.js

@@ -1,8 +1,6 @@
 "use strict";
 
 import shim from "./shim";
-import LocalContext from "./context/local";
-import metaLevelUnifier from "./unifier/metaLevel";
 import SubproofAssertion from "./assertion/subproof";
 import UnqualifiedStatement from "./statement/unqualified";
 
@@ -111,26 +109,15 @@ export default class Supposition {
   unifyStatement(statement, substitutions, localContext) {
     let statementUnified;
 
-    const supposition = this, ///
-          statementString = statement.getString(),
-          suppositionStatement = supposition.getStatement(),
-          suppositionStatementString = suppositionStatement.getString();
-
-    localContext.trace(`Unifying the '${statementString}' statement with the supposition's '${suppositionStatementString}' statement...`);
+    const statementString = statement.getString(),
+          suppositionString = this.getString();
 
-    const statementNode = statement.getNode(),
-          suppositionStatementNode = suppositionStatement.getNode(),
-          nodeA = suppositionStatementNode,  ///
-          nodeB = statementNode,  ///
-          fileContextA = this.fileContext,  ///
-          localContextA = LocalContext.fromFileContext(fileContextA),
-          localContextB = localContext, ///
-          unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+    localContext.trace(`Unifying the '${statementString}' statement with the '${suppositionString}' supposition...`);
 
-    statementUnified = unified; ///
+    statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, this.fileContext, localContext);
 
     if (statementUnified) {
-      localContext.debug(`...unified the '${statementString}' statement with the supposition's '${suppositionStatementString}' statement.`);
+      localContext.debug(`...unified the '${statementString}' statement with the '${suppositionString}' supposition.`);
     }
 
     return statementUnified;

package/src/unifier/intrinsicLevel.js

@@ -11,15 +11,15 @@ const termNodeQuery = nodeQuery("/term!"),
 
 class IntrinsicLevelUnifier extends Unifier {
   unify(nodeA, nodeB, substitutions, localContextA, localContextB) {
-    let unified;
+    let unifiedAtIntrinsicLevel;
 
     const nonTerminalNodeA = nodeA, ///
           nonTerminalNodeB = nodeB, ///
           nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB);
 
-    unified = nonTerminalNodeUnified; ///
+    unifiedAtIntrinsicLevel = nonTerminalNodeUnified; ///
 
-    return unified;
+    return unifiedAtIntrinsicLevel;
   }
 
   static maps = [

package/src/unifier/metaLevel.js

@@ -16,15 +16,15 @@ const termNodeQuery = nodeQuery("/term!"),
 
 class MetaLevelUnifier extends Unifier {
   unify(nodeA, nodeB, substitutions, localContextA, localContextB) {
-    let unified;
+    let unifiedAtMetaLevel;
 
     const nonTerminalNodeA = nodeA, ///
           nonTerminalNodeB = nodeB, ///
           nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB);
 
-    unified = nonTerminalNodeUnified; ///
+    unifiedAtMetaLevel = nonTerminalNodeUnified; ///
 
-    return unified;
+    return unifiedAtMetaLevel;
   }
 
   static maps = [
@@ -39,30 +39,23 @@ class MetaLevelUnifier extends Unifier {
         if (matches) {
           statementUnified = true;
         } else {
-          const { Statement } = shim,
-                statementB = Statement.fromStatementNode(statementNodeB, localContextB),
-                statementMetavariableNodeA = statementMetavariableNodeQuery(statementNodeA);
+          const statementNode = statementNodeA, ///
+                statementMetavariableNode = statementMetavariableNodeQuery(statementNode);
 
-          if (statementMetavariableNodeA !== null) {
-            let statement;
-
-            const statementA = Statement.fromStatementNode(statementNodeA, localContextA);
-
-            statement = statementA; ///
-
-            const substitution = statement.getSubstitution();
-
-            statement = statementB; ///
-
-            const localContext = localContextB, ///
-                  metavariableNode = statementMetavariableNodeA,  ///
+          if (statementMetavariableNode !== null) {
+            const { Statement } = shim,
+                  metavariableNode = statementMetavariableNode, ///
                   metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-                  metavariable = localContextA.findMetavariableByMetavariableName(metavariableName);
+                  metavariable = localContextA.findMetavariableByMetavariableName(metavariableName),
+                  substitution = substitutionA,  ///
+                  localContext = localContextB, ///
+                  statementNode = statementNodeB, ///
+                  statement = Statement.fromStatementNode(statementNode, localContext);
 
             if (substitution === null) {
               statementUnified = metavariable.unifyStatement(statement, substitutions, localContext);
             } else {
-              const statementUnifiedGivenSubstitution = metavariableNode.unifyStatementGivenSubstitution(statement, substitution, substitutions, localContext);
+              const statementUnifiedGivenSubstitution = metavariable.unifyStatementGivenSubstitution(statement, substitution, substitutions, localContext);
 
               statementUnified = statementUnifiedGivenSubstitution; ///
             }
@@ -116,6 +109,8 @@ const metaLevelUnifier = new MetaLevelUnifier();
 export default metaLevelUnifier;
 
 function unifyStatementWithStatement(statementNodeA, statementNodeB, substitutions, localContextA, localContextB) {
+  substitutionA = null;
+
   const nonTerminalNodeA = statementNodeA, ///
         nonTerminalNodeB = statementNodeB, ///
         nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),

package/src/unifier/metavariable.js

@@ -11,15 +11,15 @@ const typeNodeQuery = nodeQuery("/type!"),
 
 class MetavariableUnifier extends Unifier {
   unify(metavariableNodeA, metavariableNodeB, localContext) {
-    let unified;
+    let metavariableUnified;
 
     const nonTerminalNodeA = metavariableNodeA, ///
           nonTerminalNodeB = metavariableNodeB, ///
           nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext);
 
-    unified = nonTerminalNodeUnified; ///
+    metavariableUnified = nonTerminalNodeUnified; ///
 
-    return unified;
+    return metavariableUnified;
   }
 
   static maps = [