occam-verify-cli 0.0.507 → 0.0.508

package/src/matcher/metastatementForMetavariable/premise.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import MetastatementForMetavariableMatcher from "../../matcher/metastatementForMetavariable";
+
+class PremiseMetastatementForMetavariableMatcher extends MetastatementForMetavariableMatcher {
+  static createSubstitutions = true;
+}
+
+export const premiseMetastatementForMetavariableMatcher = new PremiseMetastatementForMetavariableMatcher();

package/src/matcher/metastatementForMetavariable.js

@@ -0,0 +1,99 @@
+"use strict";
+
+import Matcher from "../matcher";
+import MetastatementForMetavariableSubstitution from "../substitution/metastatementForMetavariable";
+
+import { first } from "../utilities/array";
+import { metavariableNameFromMetavariableNode } from "../utilities/query";
+import { METAVARIABLE_RULE_NAME, METASTATEMENT_RULE_NAME } from "../ruleNames";
+
+export default class MetastatementForMetavariableMatcher extends Matcher {
+  matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
+    let nonTerminalNodeMatches = false;
+
+    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
+          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(),
+          nonTerminalNodeARuleNameMetastatementRuleName = (nonTerminalNodeARuleName === METASTATEMENT_RULE_NAME),
+          nonTerminalNodeBRuleNameMetastatementRuleName = (nonTerminalNodeBRuleName === METASTATEMENT_RULE_NAME);
+
+    if (nonTerminalNodeARuleNameMetastatementRuleName && nonTerminalNodeBRuleNameMetastatementRuleName) {
+      const metastatementNodeA = nonTerminalNodeA,  ///
+            metastatementNodeB = nonTerminalNodeB,  ///
+            metastatementNodeMatches = this.matchMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions);
+
+      if (metastatementNodeMatches) {
+        nonTerminalNodeMatches = true;  ///
+      } else {
+        nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+      }
+    } else if (nonTerminalNodeBRuleName === nonTerminalNodeARuleName) {
+      nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+    }
+
+    return nonTerminalNodeMatches;
+  }
+
+  matchMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions) {
+    let metastatementNodeMatches = false;
+
+    const nonTerminalNodeA = metastatementNodeA,  ///
+          nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
+          nonTerminalNodeAChildNodesLength = nonTerminalNodeAChildNodes.length;
+
+    if (nonTerminalNodeAChildNodesLength === 1) {
+      const firstNonTerminalNodeAChildNode = first(nonTerminalNodeAChildNodes),
+            cChildNodeA = firstNonTerminalNodeAChildNode,  ///
+            cChildNodeANonTerminalNode = cChildNodeA.isNonTerminalNode();
+
+      if (cChildNodeANonTerminalNode) {
+        const nonTerminalNodeA = cChildNodeA,  ///
+              nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
+              nonTerminalNodeARuleNameMetavariableRuleName = (nonTerminalNodeARuleName === METAVARIABLE_RULE_NAME);
+
+        if (nonTerminalNodeARuleNameMetavariableRuleName) {
+          const metavariableNodeA = nonTerminalNodeA,  ///
+                metaVariableNodeMatches = this.matchMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions);
+
+          metastatementNodeMatches = metaVariableNodeMatches; ///
+        }
+      }
+    }
+
+    return metastatementNodeMatches;
+  }
+
+  matchMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions) {
+    let metavariableNodeMatches;
+
+    const metavariableNameA = metavariableNameFromMetavariableNode(metavariableNodeA),
+          substitution = substitutions.find((substitution) => {
+            const metavariableName = substitution.getMetavariableName();
+
+            if (metavariableName === metavariableNameA) {
+              return true;
+            }
+          }) || null;
+
+    if (substitution !== null) {
+      const metastatementNode = metastatementNodeB, ///
+            substitutionNodesMatch = substitution.matchMetastatementNode(metastatementNode);
+
+      metavariableNodeMatches = substitutionNodesMatch;  ///
+    } else {
+      const { createSubstitutions } = this.constructor;
+
+      if (createSubstitutions) {
+        const metavariableName = metavariableNameA, ///
+              metastatementNode = metastatementNodeB, ///
+              metastatementForMetavariableSubstitution = MetastatementForMetavariableSubstitution.fromMetavariableNameAndMetastatementNode(metavariableName, metastatementNode),
+              substitution = metastatementForMetavariableSubstitution;  ///
+
+        substitutions.push(substitution);
+      }
+
+      metavariableNodeMatches = true;
+    }
+
+    return metavariableNodeMatches;
+  }
+}

package/src/matcher/statementForMetavariable/conclusion.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import StatementForMetavariableMatcher from "../../matcher/statementForMetavariable";
+
+class ConclusionStatementForMetavariableMatcher extends StatementForMetavariableMatcher {
+  static createSubstitutions = false;
+}
+
+export const conclusionStatementForMetavariableMatcher = new ConclusionStatementForMetavariableMatcher();

package/src/matcher/statementForMetavariable/premise.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import StatementForMetavariableMatcher from "../../matcher/statementForMetavariable";
+
+class PremiseStatementForMetavariableMatcher extends StatementForMetavariableMatcher {
+  static createSubstitutions = true;
+}
+
+export const premiseStatementForMetavariableMatcher = new PremiseStatementForMetavariableMatcher();

package/src/matcher/statementForMetavariable.js

@@ -0,0 +1,99 @@
+"use strict";
+
+import Matcher from "../matcher";
+import StatementForMetavariableSubstitution from "../substitution/statementForMetavariable";
+
+import { first } from "../utilities/array";
+import { metavariableNameFromMetavariableNode } from "../utilities/query";
+import { METAVARIABLE_RULE_NAME, METASTATEMENT_RULE_NAME } from "../ruleNames";
+
+export default class StatementForMetavariableMatcher extends Matcher {
+  matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
+    let nonTerminalNodeMatches = false;
+
+    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
+          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(),
+          nonTerminalNodeARuleNameMetastatementRuleName = (nonTerminalNodeARuleName === METASTATEMENT_RULE_NAME),
+          nonTerminalNodeBRuleNameStatementRuleName = (nonTerminalNodeBRuleName === STATEMENT_RULE_NAME);
+
+    if (nonTerminalNodeARuleNameMetastatementRuleName && nonTerminalNodeBRuleNameStatementRuleName) {
+      const metastatementNodeA = nonTerminalNodeA,  ///
+            statementNodeB = nonTerminalNodeB,  ///
+            statementNodeMatches = this.matchStatementNode(metastatementNodeA, statementNodeB, substitutions);
+
+      if (statementNodeMatches) {
+        nonTerminalNodeMatches = true;  ///
+      } else {
+        nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+      }
+    } else if (nonTerminalNodeBRuleName === nonTerminalNodeARuleName) {
+      nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+    }
+
+    return nonTerminalNodeMatches;
+  }
+
+  matchStatementNode(metastatementNodeA, statementNodeB, substitutions) {
+    let statementNodeMatches = false;
+
+    const nonTerminalNodeA = metastatementNodeA,  ///
+          nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
+          nonTerminalNodeAChildNodesLength = nonTerminalNodeAChildNodes.length;
+
+    if (nonTerminalNodeAChildNodesLength === 1) {
+      const firstNonTerminalNodeAChildNode = first(nonTerminalNodeAChildNodes),
+        cChildNodeA = firstNonTerminalNodeAChildNode,  ///
+        cChildNodeANonTerminalNode = cChildNodeA.isNonTerminalNode();
+
+      if (cChildNodeANonTerminalNode) {
+        const nonTerminalNodeA = cChildNodeA,  ///
+              nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
+              nonTerminalNodeARuleNameMetavariableRuleName = (nonTerminalNodeARuleName === METAVARIABLE_RULE_NAME);
+
+        if (nonTerminalNodeARuleNameMetavariableRuleName) {
+          const metavariableNodeA = nonTerminalNodeA,  ///
+                metaVariableNodeMatches = this.matchMetavariableNode(metavariableNodeA, statementNodeB, substitutions);
+
+          statementNodeMatches = metaVariableNodeMatches; ///
+        }
+      }
+    }
+
+    return statementNodeMatches;
+  }
+
+  matchMetavariableNode(metavariableNodeA, statementNodeB, substitutions) {
+    let metavariableNodeMatches;
+
+    const metavariableNameA = metavariableNameFromMetavariableNode(metavariableNodeA),
+          substitution = substitutions.find((substitution) => {
+            const metavariableName = substitution.getMetavariableName();
+
+            if (metavariableName === metavariableNameA) {
+              return true;
+            }
+          }) || null;
+
+    if (substitution !== null) {
+      const statementNode = statementNodeB, ///
+            substitutionNodesMatch = substitution.matchStatementNode(statementNode);
+
+      metavariableNodeMatches = substitutionNodesMatch;  ///
+    } else {
+      const { createSubstitutions } = this.constructor;
+
+      if (createSubstitutions) {
+        const metavariableName = metavariableNameA, ///
+              statementNode = statementNodeB, ///
+              statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNameAndStatementNode(metavariableName, statementNode),
+              substitution = statementForMetavariableSubstitution;  ///
+
+        substitutions.push(substitution);
+      }
+
+      metavariableNodeMatches = true;
+    }
+
+    return metavariableNodeMatches;
+  }
+}

package/src/matcher/statementForVariable/consequence.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import StatementForVariableMatcher from "../../matcher/statementForVariable";
+
+class ConsequenceStatementForVariableMatcher extends StatementForVariableMatcher {
+  static createSubstitutions = false;
+}
+
+export const consequenceStatementForVariableMatcher = new ConsequenceStatementForVariableMatcher();

package/src/matcher/statementForVariable/supposition.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import StatementForVariableMatcher from "../../matcher/statementForVariable";
+
+class SuppositionStatementForVariableMatcher extends StatementForVariableMatcher {
+  static createSubstitutions = true;
+}
+
+export const suppositionStatementForVariableMatcher = new SuppositionStatementForVariableMatcher();

package/src/matcher/statementForVariable.js

@@ -0,0 +1,99 @@
+"use strict";
+
+import Matcher from "../matcher";
+import StatementForVariableSubstitution from "../substitution/statementForVariable";
+
+import { first } from "../utilities/array";
+import { variableNameFromVariableNode } from "../utilities/query";
+import { VARIABLE_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleNames";
+
+export default class StatementForVariableMatcher extends Matcher {
+  matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
+    let nonTerminalNodeMatches = false;
+
+    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
+          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(),
+          nonTerminalNodeARuleNameMetastatementRuleName = (nonTerminalNodeARuleName === STATEMENT_RULE_NAME),
+          nonTerminalNodeBRuleNameMetastatementRuleName = (nonTerminalNodeBRuleName === STATEMENT_RULE_NAME);
+
+    if (nonTerminalNodeARuleNameMetastatementRuleName && nonTerminalNodeBRuleNameMetastatementRuleName) {
+      const statementNodeA = nonTerminalNodeA,  ///
+            statementNodeB = nonTerminalNodeB,  ///
+            statementNodeMatches = this.matchStatementNode(statementNodeA, statementNodeB, substitutions);
+
+      if (statementNodeMatches) {
+        nonTerminalNodeMatches = true;  ///
+      } else {
+        nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+      }
+    } else if (nonTerminalNodeBRuleName === nonTerminalNodeARuleName) {
+      nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+    }
+
+    return nonTerminalNodeMatches;
+  }
+
+  matchStatementNode(statementNodeA, statementNodeB, substitutions) {
+    let statementNodeMatches = false;
+
+    const nonTerminalNodeA = statementNodeA,  ///
+          nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
+          nonTerminalNodeAChildNodesLength = nonTerminalNodeAChildNodes.length;
+
+    if (nonTerminalNodeAChildNodesLength === 1) {
+      const firstNonTerminalNodeAChildNode = first(nonTerminalNodeAChildNodes),
+            childNodeA = firstNonTerminalNodeAChildNode,  ///
+            childNodeANonTerminalNode = childNodeA.isNonTerminalNode();
+
+      if (childNodeANonTerminalNode) {
+        const nonTerminalNodeA = childNodeA,  ///
+              nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
+              nonTerminalNodeARuleNameVariableRuleName = (nonTerminalNodeARuleName === VARIABLE_RULE_NAME);
+
+        if (nonTerminalNodeARuleNameVariableRuleName) {
+          const variableNodeA = nonTerminalNodeA,  ///
+                variableMatches = this.matchVariableNode(variableNodeA, statementNodeB, substitutions);
+
+          statementNodeMatches = variableMatches; ///
+        }
+      }
+    }
+
+    return statementNodeMatches;
+  }
+
+  matchVariableNode(variableNodeB, statementNodeB, substitutions) {
+    let variableMatches;
+
+    const variableNameA = variableNameFromVariableNode(variableNodeB),
+          substitution = substitutions.find((substitution) => {
+            const variableName = substitution.getVariableName();
+
+            if (variableName === variableNameA) {
+              return true;
+            }
+          }) || null;
+
+    if (substitution !== null) {
+      const statementNode = statementNodeB, ///
+            substitutionNodesMatch = substitution.matchStatementNode(statementNode);
+
+      variableMatches = substitutionNodesMatch;  ///
+    } else {
+      const { createSubstitutions } = this.constructor;
+
+      if (createSubstitutions) {
+        const variableName = variableNameA, ///
+              statementNode = statementNodeB, ///
+              statementForVariableSubstitution = StatementForVariableSubstitution.fromVariableNameAndStatementNode(variableName, statementNode),
+              substitution = statementForVariableSubstitution;  ///
+
+        substitutions.push(substitution);
+      }
+
+      variableMatches = true;
+    }
+
+    return variableMatches;
+  }
+}

package/src/matcher.js

@@ -1,9 +1,76 @@
 "use strict";
 
-import matcherMixins from "./mixins/matcher";
+export default class Matcher {
+  matchNode(nodeA, nodeB, ...remainingArguments) {
+    let nodeMatches = false;
 
-export default class Matcher {}
+    const nodeATerminalNode = nodeA.isTerminalNode(),
+          nodeBTerminalNode = nodeB.isTerminalNode();
 
-Object.assign(Matcher.prototype, matcherMixins);
+    if (nodeATerminalNode === nodeBTerminalNode) {
+      if (nodeATerminalNode) {
+        const terminalNodeA = nodeA,  ///
+              terminalNodeB = nodeB,  ///
+              terminalNodeMatches = this.matchTerminalNode(terminalNodeA, terminalNodeB, ...remainingArguments);
+
+        nodeMatches = terminalNodeMatches;  ///
+      } else {
+        const nonTerminalNodeA = nodeA,  ///
+              nonTerminalNodeB = nodeB, ///
+              nonTerminalNodeMatches = this.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments);
+
+        nodeMatches = nonTerminalNodeMatches; ///
+      }
+    }
+
+    return nodeMatches;
+  }
+
+  matchNodes(nodesA, nodesB, ...remainingArguments) {
+    let nodesMatch = false;
+
+    const nodesALength = nodesA.length,
+          nodesBLength = nodesB.length;
+
+    if (nodesALength === nodesBLength) {
+      nodesMatch = nodesA.every((nodeA, index) => {
+        const nodeB = nodesB[index],
+              nodeMatches = this.matchNode(nodeA, nodeB, ...remainingArguments);
+
+        if (nodeMatches) {
+          return true;
+        }
+      })
+    }
+
+    return nodesMatch;
+  }
+
+  matchTerminalNode(terminalNodeA, terminalNodeB, ...remainingArguments) {
+    const matches = terminalNodeA.match(terminalNodeB),
+          terminalNodeMatches = matches;  ///
+
+    return terminalNodeMatches;
+  }
+
+  matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments) {
+    let nonTerminalNodeMatches = false;
+
+    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(), ///
+          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(); ///
+
+    if (nonTerminalNodeARuleName === nonTerminalNodeBRuleName) {
+      const nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
+            nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
+            nodesA = nonTerminalNodeAChildNodes, ///
+            nodesB = nonTerminalNodeBChildNodes, ///
+            nodesMatch = this.matchNodes(nodesA, nodesB, ...remainingArguments);
+
+      nonTerminalNodeMatches = nodesMatch; ///
+    }
+
+    return nonTerminalNodeMatches;
+  }
+}
 
 export const matcher = new Matcher();

package/src/premise.js

@@ -1,17 +1,17 @@
 "use strict";
 
 import { nodeAsString } from "./utilities/string";
-import { premiseMatcher } from "./matcher/premise";
-import { premiseMetaMatcher } from "./metaMatcher/premise";
 import { nodeQuery, nodesQuery } from "./utilities/query";
+import { premiseStatementForMetavariableMatcher } from "./matcher/statementForMetavariable/premise";
 import { metastatementNodeFromMetastatementString } from "./utilities/string";
+import { premiseMetastatementForMetavariableMatcher } from "./matcher/metastatementForMetavariable/premise";
 
-const metastatementNodesQuery = nodesQuery("/ruleSubproofAssertion/metastatement"),
-      ruleSubproofAssertionNodeQuery = nodeQuery("/metastatement/ruleSubproofAssertion!"),
-      premiseMetastatementNodesQuery = nodesQuery("/ruleSubproof/premise/unqualifiedMetastatement!/metastatement!"),
-      subDerivationStatementNodeQuery = nodeQuery("/subproof/subDerivation/qualifiedStatement|unqualifiedStatement[-1]/statement!"),
-      suppositionStatementStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement!/statement!"),
-      ruleSubDerivationMetastatementNodeQuery = nodeQuery("/ruleSubproof/ruleSubDerivation/qualifiedMetastatement|unqualifiedMetastatement[-1]/metastatement!");
+const ruleSubproofAssertionNodeQuery = nodeQuery("/metastatement/ruleSubproofAssertion!"),
+      ruleSubproofPremiseMetastatementQuery = nodesQuery("/ruleSubproof/premise/unqualifiedMetastatement!/metastatement!"),
+      subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement!/statement!"),
+      subproofSubDerivationLastStatementNodeQuery = nodeQuery("/subproof/subDerivation/qualifiedStatement|unqualifiedStatement[-1]/statement!"),
+      ruleSubproofAssertionMetastatementNodesQuery = nodesQuery("/ruleSubproofAssertion/metastatement"),
+      ruleSubproofSubDerivationLastMetastatementQuery = nodeQuery("/ruleSubproof/ruleSubDerivation/qualifiedMetastatement|unqualifiedMetastatement[-1]/metastatement!");
 
 export default class Premise {
   constructor(metastatementNode) {
@@ -28,22 +28,22 @@ export default class Premise {
     const subproofAssertionNode = ruleSubproofAssertionNodeQuery(this.metastatementNode);
 
     if (subproofAssertionNode !== null) {
-      const subDerivationStatementNode = subDerivationStatementNodeQuery(subproofNode),
-            suppositionStatementStatementNodes = suppositionStatementStatementNodesQuery(subproofNode),
-            ruleSubproofAssertionMetastatementNodes = metastatementNodesQuery(subproofAssertionNode),
-            statementNodes = [
-              ...suppositionStatementStatementNodes,
-              subDerivationStatementNode
+      const subproofSuppositionStatementNodes = subproofSuppositionStatementNodesQuery(subproofNode),
+            subproofSubDerivationLastStatementNode = subproofSubDerivationLastStatementNodeQuery(subproofNode),
+            subproofStatementNodes = [
+              ...subproofSuppositionStatementNodes,
+              subproofSubDerivationLastStatementNode
             ],
-            statementNodesLength = statementNodes.length,
-            ruleSubproofAssertionMetastatementNodesLength = ruleSubproofAssertionMetastatementNodes.length;
+            ruleSubproofAssertionMetaSubproofStatementNodes = ruleSubproofAssertionMetaSubproofStatementNodesQuery(subproofAssertionNode),
+            subproofStatementNodesLength = subproofStatementNodes.length,
+            ruleSubproofAssertionMetaSubproofStatementNodesLength = ruleSubproofAssertionMetaSubproofStatementNodes.length;
 
-      if (statementNodesLength === ruleSubproofAssertionMetastatementNodesLength) {
-        subproofNodeMatches = ruleSubproofAssertionMetastatementNodes.every((ruleSubproofAssertionMetastatementNode, index) => {
-          const statementNode = statementNodes[index],
-                nonTerminalNode = statementNode, ///
-                premiseNonTerminalNode = ruleSubproofAssertionMetastatementNode,  ///
-                nonTerminalNodeMatches = premiseMatcher.matchNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, substitutions);
+      if (subproofStatementNodesLength === ruleSubproofAssertionMetaSubproofStatementNodesLength) {
+        subproofNodeMatches = ruleSubproofAssertionMetaSubproofStatementNodes.every((ruleSubproofAssertionMetastatementNode, index) => {
+          const subproofStatementNode = subproofStatementNodes[index],
+                nonTerminalNodeA = ruleSubproofAssertionMetastatementNode,  ///
+                nonTerminalNodeB = subproofStatementNode, ///
+                nonTerminalNodeMatches = premiseStatementForMetavariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
 
           if (nonTerminalNodeMatches) {
             return true;
@@ -56,36 +56,36 @@ export default class Premise {
   }
 
   matchStatementNode(statementNode, substitutions) {
-    const nonTerminalNode = statementNode,  ///
-          premiseNonTerminalNode = this.metastatementNode,  ///
-          nonTerminalNodeMatches = premiseMatcher.matchNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, substitutions),
+    const nonTerminalNodeA = this.metastatementNode,  ///
+          nonTerminalNodeB = statementNode,  ///
+          nonTerminalNodeMatches = premiseStatementForMetavariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
           statementNodeMatches = nonTerminalNodeMatches; ///
 
     return statementNodeMatches;
   }
 
-  matchRuleSubproofNode(ruleSubproofNode, metaSubstitutions) {
+  matchRuleSubproofNode(ruleSubproofNode, substitutions) {
     let ruleSubproofNodeMatches = false;
 
     const ruleSubproofAssertionNode = ruleSubproofAssertionNodeQuery(this.metastatementNode);
 
     if (ruleSubproofAssertionNode !== null) {
-      const premiseMetastatementNodes = premiseMetastatementNodesQuery(ruleSubproofNode),
-            ruleSubDerivationMetastatementNode = ruleSubDerivationMetastatementNodeQuery(ruleSubproofNode),
-            ruleSubproofAssertionMetastatementNodes = metastatementNodesQuery(ruleSubproofAssertionNode),
-            metastatementNodes = [
-              ...premiseMetastatementNodes,
-              ruleSubDerivationMetastatementNode
+      const ruleSubproofPremiseMetastatement = ruleSubproofPremiseMetastatementQuery(ruleSubproofNode),
+            ruleSubproofSubDerivationLastMetastatement = ruleSubproofSubDerivationLastMetastatementQuery(ruleSubproofNode),
+            ruleSubproofMetastatementNodes = [
+              ...ruleSubproofPremiseMetastatement,
+              ruleSubproofSubDerivationLastMetastatement
             ],
-            metastatementNodesLength = metastatementNodes.length,
+            ruleSubproofMetastatementNodesLength = ruleSubproofMetastatementNodes.length,
+            ruleSubproofAssertionMetastatementNodes = ruleSubproofAssertionMetastatementNodesQuery(ruleSubproofAssertionNode),
             ruleSubproofAssertionMetastatementNodesLength = ruleSubproofAssertionMetastatementNodes.length;
 
-      if (metastatementNodesLength === ruleSubproofAssertionMetastatementNodesLength) {
+      if (ruleSubproofMetastatementNodesLength === ruleSubproofAssertionMetastatementNodesLength) {
         ruleSubproofNodeMatches = ruleSubproofAssertionMetastatementNodes.every((ruleSubproofAssertionMetastatementNode, index) => {
-                                    const metastatementNode = metastatementNodes[index],
-                                          nonTerminalNode = metastatementNode, ///
-                                          premiseNonTerminalNode = ruleSubproofAssertionMetastatementNode,  ///
-                                          nonTerminalNodeMatches = premiseMetaMatcher.matchNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions);
+                                    const ruleSubproofMetastatementNode = ruleSubproofMetastatementNodes[index],
+                                          nonTerminalNodeA = ruleSubproofAssertionMetastatementNode,  ///
+                                          nonTerminalNodeB = ruleSubproofMetastatementNode, ///
+                                          nonTerminalNodeMatches = premiseMetastatementForMetavariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
 
                                     if (nonTerminalNodeMatches) {
                                       return true;
@@ -97,10 +97,10 @@ export default class Premise {
     return ruleSubproofNodeMatches;
   }
 
-  matchMetastatementNode(metastatementNode, metaSubstitutions) {
-    const nonTerminalNode = metastatementNode,  ///
-          premiseNonTerminalNode = this.metastatementNode,  ///
-          nonTerminalNodeMatches = premiseMetaMatcher.matchNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions),
+  matchMetastatementNode(metastatementNode, substitutions) {
+    const nonTerminalNodeA = this.metastatementNode,  ///
+          nonTerminalNodeB = metastatementNode,  ///
+          nonTerminalNodeMatches = premiseMetastatementForMetavariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
           metastatementNodeMatches = nonTerminalNodeMatches; ///
 
     return metastatementNodeMatches;

package/src/rule.js

@@ -80,8 +80,8 @@ export default class Rule {
     const premisesLength = this.premises.length;
 
     if (premisesLength === 0) {
-      const metaSubstitutions = [],
-            conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, metaSubstitutions);
+      const substitutions = [],
+            conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, substitutions);
 
       metastatementNatches = conclusionMatches; ///
     } else {
@@ -90,11 +90,11 @@ export default class Rule {
       metastatementNatches = someSubArray(metaproofSteps, premisesLength, (metaproofSteps) => {
         let premisesMatchConclusion = false;
 
-        const metaSubstitutions = [],
-              premisesMatch = metaMatchPremises(this.premises, metaproofSteps, metaSubstitutions);
+        const substitutions = [],
+              premisesMatch = metaMatchPremises(this.premises, metaproofSteps, substitutions);
 
         if (premisesMatch) {
-          const conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, metaSubstitutions);
+          const conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, substitutions);
 
           premisesMatchConclusion = conclusionMatches;  ///
         }
@@ -225,13 +225,13 @@ function matchConclusion(conclusion, statementNode, substitutions) {
   return conclusionMatches;
 }
 
-function metaMatchPremise(premise, metaproofSteps, metaSubstitutions) {
+function metaMatchPremise(premise, metaproofSteps, substitutions) {
   const metaproofStep = prune(metaproofSteps, (metaproofStep) => {
     const ruleSubproofNode = metaproofStep.getRuleSubproofNode(),
           metastatementNode = metaproofStep.getMetastatementNode()
 
     if (ruleSubproofNode !== null) {
-      const ruleSubProofNodeMatches = premise.matchRuleSubproofNode(ruleSubproofNode, metaSubstitutions);
+      const ruleSubProofNodeMatches = premise.matchRuleSubproofNode(ruleSubproofNode, substitutions);
 
       if (!ruleSubProofNodeMatches) {  ///
         return true;
@@ -239,7 +239,7 @@ function metaMatchPremise(premise, metaproofSteps, metaSubstitutions) {
     }
 
     if (metastatementNode !== null) {
-      const metastatementNodeMatches = premise.matchMetastatementNode(metastatementNode, metaSubstitutions);
+      const metastatementNodeMatches = premise.matchMetastatementNode(metastatementNode, substitutions);
 
       if (!metastatementNodeMatches) {  ///
         return true;
@@ -252,9 +252,9 @@ function metaMatchPremise(premise, metaproofSteps, metaSubstitutions) {
   return premiseMatches;
 }
 
-function metaMatchPremises(premise, metaproofSteps, metaSubstitutions) {
+function metaMatchPremises(premise, metaproofSteps, substitutions) {
   const premisesMatch = premise.every((premise) => {
-    const premiseMatches = metaMatchPremise(premise, metaproofSteps, metaSubstitutions);
+    const premiseMatches = metaMatchPremise(premise, metaproofSteps, substitutions);
 
     if (premiseMatches) {
       return true;
@@ -264,8 +264,8 @@ function metaMatchPremises(premise, metaproofSteps, metaSubstitutions) {
   return premisesMatch;
 }
 
-function metaMatchConclusion(conclusion, metastatementNode, metaSubstitutions) {
-  const metastatementNodeMatches = conclusion.matchMetastatementNode(metastatementNode, metaSubstitutions),
+function metaMatchConclusion(conclusion, metastatementNode, substitutions) {
+  const metastatementNodeMatches = conclusion.matchMetastatementNode(metastatementNode, substitutions),
         conclusionMatches = metastatementNodeMatches; ///
 
   return conclusionMatches;