occam-verify-cli 0.0.506 → 0.0.508

package/src/premise.js

@@ -1,21 +1,17 @@
 "use strict";
 
-import Substitution from "./substitution";
-import MetaSubstitution from "./metaSubstitution";
-
-import { first } from "./utilities/array";
 import { nodeAsString } from "./utilities/string";
 import { nodeQuery, nodesQuery } from "./utilities/query";
-import { metavariableNameFromMetavariableNode } from "./utilities/query";
+import { premiseStatementForMetavariableMatcher } from "./matcher/statementForMetavariable/premise";
 import { metastatementNodeFromMetastatementString } from "./utilities/string";
-import { STATEMENT_RULE_NAME, METAVARIABLE_RULE_NAME, METASTATEMENT_RULE_NAME } from "./ruleNames";
+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) {
@@ -32,24 +28,24 @@ 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;
-
-      if (statementNodesLength === ruleSubproofAssertionMetastatementNodesLength) {
-        subproofNodeMatches = ruleSubproofAssertionMetastatementNodes.every((ruleSubproofAssertionMetastatementNode, index) => {
-          const statementNode = statementNodes[index],
-                nonTerminalNode = statementNode, ///
-                premiseNonTerminalNode = ruleSubproofAssertionMetastatementNode,  ///
-                premiseNonTerminalNodeMatches = matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, substitutions);
-
-          if (premiseNonTerminalNodeMatches) {
+            ruleSubproofAssertionMetaSubproofStatementNodes = ruleSubproofAssertionMetaSubproofStatementNodesQuery(subproofAssertionNode),
+            subproofStatementNodesLength = subproofStatementNodes.length,
+            ruleSubproofAssertionMetaSubproofStatementNodesLength = ruleSubproofAssertionMetaSubproofStatementNodes.length;
+
+      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;
           }
         });
@@ -60,38 +56,38 @@ export default class Premise {
   }
 
   matchStatementNode(statementNode, substitutions) {
-    const nonTerminalNode = statementNode,  ///
-          premiseNonTerminalNode = this.metastatementNode,  ///
-          premiseNonTerminalNodeMatches = matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, substitutions),
-          statementNodeMatches = premiseNonTerminalNodeMatches; ///
+    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,  ///
-                                          premiseNonTerminalNodeMatches = metaMatchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions);
+                                    const ruleSubproofMetastatementNode = ruleSubproofMetastatementNodes[index],
+                                          nonTerminalNodeA = ruleSubproofAssertionMetastatementNode,  ///
+                                          nonTerminalNodeB = ruleSubproofMetastatementNode, ///
+                                          nonTerminalNodeMatches = premiseMetastatementForMetavariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
 
-                                    if (premiseNonTerminalNodeMatches) {
+                                    if (nonTerminalNodeMatches) {
                                       return true;
                                     }
                                   });
@@ -101,11 +97,11 @@ export default class Premise {
     return ruleSubproofNodeMatches;
   }
 
-  matchMetastatementNode(metastatementNode, metaSubstitutions) {
-    const nonTerminalNode = metastatementNode,  ///
-          premiseNonTerminalNode = this.metastatementNode,  ///
-          premiseNonTerminalNodeMatches = metaMatchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions),
-          metastatementNodeMatches = premiseNonTerminalNodeMatches; ///
+  matchMetastatementNode(metastatementNode, substitutions) {
+    const nonTerminalNodeA = this.metastatementNode,  ///
+          nonTerminalNodeB = metastatementNode,  ///
+          nonTerminalNodeMatches = premiseMetastatementForMetavariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
+          metastatementNodeMatches = nonTerminalNodeMatches; ///
 
     return metastatementNodeMatches;
   }
@@ -135,287 +131,3 @@ export default class Premise {
     return premise;
   }
 }
-
-function matchPremiseNode(premiseNode, node, substitutions) {
-  let premiseNodeMatches = false;
-
-  const nodeTerminalNode = node.isTerminalNode(),
-    ruleNodeTerminalNode = premiseNode.isTerminalNode();
-
-  if (nodeTerminalNode === ruleNodeTerminalNode) {
-    if (nodeTerminalNode) {
-      const terminalNode = node,  ///
-            premiseTerminalNode = premiseNode,  ///
-            premiseTerminalNodeMatches = matchPremiseTerminalNode(premiseTerminalNode, terminalNode, substitutions);
-
-      premiseNodeMatches = premiseTerminalNodeMatches;  ///
-    } else {
-      const nonTerminalNode = node, ///
-            premiseNonTerminalNode = premiseNode,  ///
-            premiseNonTerminalNodeMatches = matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, substitutions);
-
-      premiseNodeMatches = premiseNonTerminalNodeMatches; ///
-    }
-  }
-
-  return premiseNodeMatches;
-}
-
-function matchPremiseNodes(premiseNodes, nodes, substitutions) {
-  let premiseNodesMatches = false;
-
-  const nodesLength = nodes.length,
-        premiseNodesLength = premiseNodes.length;
-
-  if (nodesLength === premiseNodesLength) {
-    premiseNodesMatches = nodes.every((node, index) => {
-      const premiseNode = premiseNodes[index],
-            premiseNodeMatches = matchPremiseNode(premiseNode, node, substitutions);
-
-      if (premiseNodeMatches) {
-        return true;
-      }
-    });
-  }
-
-  return premiseNodesMatches;
-}
-
-function matchPremiseTerminalNode(premiseTerminalNode, terminalNode, substitutions) {
-  const matches = premiseTerminalNode.match(terminalNode),
-        premiseTerminalNodeMatches = matches;
-
-  return premiseTerminalNodeMatches;
-}
-
-function matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, substitutions) {
-  let premiseNonTerminalNodeMatches = false;
-
-  const ruleName = nonTerminalNode.getRuleName(),
-        childNodes = nonTerminalNode.getChildNodes(),
-        premiseNonTerminalNodeRuleName = premiseNonTerminalNode.getRuleName(),
-        premiseNonTerminalNodeChildNodes = premiseNonTerminalNode.getChildNodes(),
-        nodes = childNodes, ///
-        premiseNodes = premiseNonTerminalNodeChildNodes, ///
-        ruleNameStatementRuleName = (ruleName === STATEMENT_RULE_NAME),
-        premiseNonTerminalNodeRuleNameMetastatementRuleName = (premiseNonTerminalNodeRuleName === METASTATEMENT_RULE_NAME);
-
-  if (ruleNameStatementRuleName && premiseNonTerminalNodeRuleNameMetastatementRuleName) {
-    const statementNode = nonTerminalNode,  ///
-          premiseMetastatementNode = premiseNonTerminalNode,  ///
-          premiseMetastatementNodeMatches = matchPremiseMetastatementNode(premiseMetastatementNode, statementNode, substitutions);
-
-    if (premiseMetastatementNodeMatches) {
-      premiseNonTerminalNodeMatches = true;
-    } else {
-      const premiseNonTerminalNodeChildNodesMatches = matchPremiseNodes(premiseNodes, nodes, substitutions);
-
-      premiseNonTerminalNodeMatches = premiseNonTerminalNodeChildNodesMatches; ///
-    }
-  } else if (ruleName === premiseNonTerminalNodeRuleName) {
-    const premiseNonTerminalNodeChildNodesMatches = matchPremiseNodes(premiseNodes, nodes, substitutions);
-
-    premiseNonTerminalNodeMatches = premiseNonTerminalNodeChildNodesMatches; ///
-  }
-
-  return premiseNonTerminalNodeMatches;
-}
-
-function matchPremiseMetavariableNode(premiseMetavariableNode, statementNode, substitutions) {
-  let premiseMetavariableNodeMatches;
-
-  const premiseMetavariableName = metavariableNameFromMetavariableNode(premiseMetavariableNode),
-        substitution = substitutions.find((substitution) => {
-          const metavariableName = substitution.getMetavariableName();
-
-          if (metavariableName === premiseMetavariableName) {
-            return true;
-          }
-        }) || null;
-
-  if (substitution !== null) {
-    const substitutionNodesMatch = substitution.matchStatementNode(statementNode);
-
-    premiseMetavariableNodeMatches = substitutionNodesMatch;  ///
-  } else {
-    const metavariableName = premiseMetavariableName, ///
-          substitution = Substitution.fromMetavariableNameAndStatementNode(metavariableName, statementNode);
-
-    substitutions.push(substitution);
-
-    premiseMetavariableNodeMatches = true;
-  }
-
-  return premiseMetavariableNodeMatches;
-}
-
-function matchPremiseMetastatementNode(premiseMetastatementNode, statementNode, substitutions) {
-  let premiseMetastatementNodeMatches = false;
-
-  const premiseNonTerminalNode = premiseMetastatementNode,  ///
-        premiseNonTerminalNodeChildNodes = premiseNonTerminalNode.getChildNodes(),
-        premiseNonTerminalNodeChildNodesLength = premiseNonTerminalNodeChildNodes.length;
-
-  if (premiseNonTerminalNodeChildNodesLength === 1) {
-    const firstPremiseChildNode = first(premiseNonTerminalNodeChildNodes),
-          premiseChildNode = firstPremiseChildNode,  ///
-          premiseChildNodeNonTerminalNode = premiseChildNode.isNonTerminalNode();
-
-    if (premiseChildNodeNonTerminalNode) {
-      const premiseNonTerminalChildNode = premiseChildNode,  ///
-            premiseNonTerminalChildNodeRuleName = premiseNonTerminalChildNode.getRuleName(),
-            premiseNonTerminalChildNodeRuleNameMetavariableRuleName = (premiseNonTerminalChildNodeRuleName === METAVARIABLE_RULE_NAME);
-
-      if (premiseNonTerminalChildNodeRuleNameMetavariableRuleName) {
-        const premiseMetavariableNode = premiseNonTerminalChildNode,  ///
-              premiseMetaVariableNodeMatches = matchPremiseMetavariableNode(premiseMetavariableNode, statementNode, substitutions);
-
-        premiseMetastatementNodeMatches = premiseMetaVariableNodeMatches; ///
-      }
-    }
-  }
-
-  return premiseMetastatementNodeMatches;
-}
-
-function metaMatchPremiseNode(premiseNode, node, metaSubstitutions) {
-  let premiseNodeMatches = false;
-
-  const nodeTerminalNode = node.isTerminalNode(),
-        ruleNodeTerminalNode = premiseNode.isTerminalNode();
-
-  if (nodeTerminalNode === ruleNodeTerminalNode) {
-    if (nodeTerminalNode) {
-      const terminalNode = node,  ///
-            premiseTerminalNode = premiseNode,  ///
-            premiseTerminalNodeMatches = metaMatchPremiseTerminalNode(premiseTerminalNode, terminalNode, metaSubstitutions);
-
-      premiseNodeMatches = premiseTerminalNodeMatches;  ///
-    } else {
-      const nonTerminalNode = node, ///
-            premiseNonTerminalNode = premiseNode,  ///
-            premiseNonTerminalNodeMatches = metaMatchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions);
-
-      premiseNodeMatches = premiseNonTerminalNodeMatches; ///
-    }
-  }
-
-  return premiseNodeMatches;
-}
-
-function metaMatchPremiseNodes(premiseNodes, nodes, metaSubstitutions) {
-  let premiseNodesMatches = false;
-
-  const nodesLength = nodes.length,
-        premiseNodesLength = premiseNodes.length;
-
-  if (nodesLength === premiseNodesLength) {
-    premiseNodesMatches = nodes.every((node, index) => {
-      const premiseNode = premiseNodes[index],
-            premiseNodeMatches = metaMatchPremiseNode(premiseNode, node, metaSubstitutions);
-
-      if (premiseNodeMatches) {
-        return true;
-      }
-    });
-  }
-
-  return premiseNodesMatches;
-}
-
-function metaMatchPremiseTerminalNode(premiseTerminalNode, terminalNode, metaSubstitutions) {
-  const matches = premiseTerminalNode.match(terminalNode),
-        premiseTerminalNodeMatches = matches;
-
-  return premiseTerminalNodeMatches;
-}
-
-function metaMatchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions) {
-  let premiseNonTerminalNodeMatches = false;
-
-  const ruleName = nonTerminalNode.getRuleName(),
-        childNodes = nonTerminalNode.getChildNodes(),
-        premiseNonTerminalNodeRuleName = premiseNonTerminalNode.getRuleName(),
-        premiseNonTerminalNodeChildNodes = premiseNonTerminalNode.getChildNodes(),
-        nodes = childNodes, ///
-        premiseNodes = premiseNonTerminalNodeChildNodes, ///
-        ruleNameMetastatementRuleName = (ruleName === METASTATEMENT_RULE_NAME),
-        premiseNonTerminalNodeRuleNameMetastatementRuleName = (premiseNonTerminalNodeRuleName === METASTATEMENT_RULE_NAME);
-
-  if (ruleNameMetastatementRuleName && premiseNonTerminalNodeRuleNameMetastatementRuleName) {
-    const metastatementNode = nonTerminalNode,  ///
-          premiseMetastatementNode = premiseNonTerminalNode,  ///
-          premiseMetastatementNodeMatches = metaMatchPremiseMetastatementNode(premiseMetastatementNode, metastatementNode, metaSubstitutions);
-
-    if (premiseMetastatementNodeMatches) {
-      premiseNonTerminalNodeMatches = true;
-    } else {
-      const premiseNonTerminalNodeChildNodesMatches = metaMatchPremiseNodes(premiseNodes, nodes, metaSubstitutions);
-
-      premiseNonTerminalNodeMatches = premiseNonTerminalNodeChildNodesMatches; ///
-    }
-  } else if (ruleName === premiseNonTerminalNodeRuleName) {
-    const premiseNonTerminalNodeChildNodesMatches = metaMatchPremiseNodes(premiseNodes, nodes, metaSubstitutions);
-
-    premiseNonTerminalNodeMatches = premiseNonTerminalNodeChildNodesMatches; ///
-  }
-
-  return premiseNonTerminalNodeMatches;
-}
-
-function metaMatchPremiseMetavariableNode(premiseMetavariableNode, metastatementNode, metaSubstitutions) {
-  let premiseMetavariableNodeMatches;
-
-  const premiseMetavariableName = metavariableNameFromMetavariableNode(premiseMetavariableNode),
-        metaSubstitution = metaSubstitutions.find((metaSubstitution) => {
-          const metavariableName = metaSubstitution.getMetavariableName();
-
-          if (metavariableName === premiseMetavariableName) {
-            return true;
-          }
-        }) || null;
-
-  if (metaSubstitution !== null) {
-    const metaSubstitutionNodesMatch = metaSubstitution.matchMetastatementNode(metastatementNode);
-
-    premiseMetavariableNodeMatches = metaSubstitutionNodesMatch;  ///
-  } else {
-    const metavariableName = premiseMetavariableName, ///
-          metaSubstitution = MetaSubstitution.fromMetavariableNameAndMetastatementNode(metavariableName, metastatementNode);
-
-    metaSubstitutions.push(metaSubstitution);
-
-    premiseMetavariableNodeMatches = true;
-  }
-
-  return premiseMetavariableNodeMatches;
-}
-
-function metaMatchPremiseMetastatementNode(premiseMetastatementNode, metastatementNode, metaSubstitutions) {
-  let premiseMetastatementNodeMatches = false;
-
-  const premiseNonTerminalNode = premiseMetastatementNode,  ///
-        premiseNonTerminalNodeChildNodes = premiseNonTerminalNode.getChildNodes(),
-        premiseNonTerminalNodeChildNodesLength = premiseNonTerminalNodeChildNodes.length;
-
-  if (premiseNonTerminalNodeChildNodesLength === 1) {
-    const firstPremiseChildNode = first(premiseNonTerminalNodeChildNodes),
-          premiseChildNode = firstPremiseChildNode,  ///
-          premiseChildNodeNonTerminalNode = premiseChildNode.isNonTerminalNode();
-
-    if (premiseChildNodeNonTerminalNode) {
-      const premiseNonTerminalChildNode = premiseChildNode,  ///
-            premiseNonTerminalChildNodeRuleName = premiseNonTerminalChildNode.getRuleName(),
-            premiseNonTerminalChildNodeRuleNameMetavariableRuleName = (premiseNonTerminalChildNodeRuleName === METAVARIABLE_RULE_NAME);
-
-      if (premiseNonTerminalChildNodeRuleNameMetavariableRuleName) {
-        const premiseMetavariableNode = premiseNonTerminalChildNode,  ///
-              premiseMetaVariableNodeMatches = metaMatchPremiseMetavariableNode(premiseMetavariableNode, metastatementNode, metaSubstitutions);
-
-        premiseMetastatementNodeMatches = premiseMetaVariableNodeMatches; ///
-      }
-    }
-  }
-
-  return premiseMetastatementNodeMatches;
-}

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;

package/src/ruleNames.js

@@ -5,6 +5,7 @@ export const TYPE_RULE_NAME = "type";
 export const LABEL_RULE_NAME = "label";
 export const ARGUMENT_RULE_NAME = "argument";
 export const SUBPROOF_RULE_NAME = "subproof";
+export const VARIABLE_RULE_NAME = "variable";
 export const STATEMENT_RULE_NAME = "statement";
 export const METAVARIABLE_RULE_NAME = "metavariable";
 export const METASTATEMENT_RULE_NAME = "metastatement";

package/src/step/metaproof.js

@@ -2,7 +2,7 @@
 
 import { first, second } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
-import { matchBracketedNonTerminalNode } from "../utilities/node";
+import { matchBracketedNonTerminalNode } from "../utilities/substitution";
 
 const metastatementNodesQuery = nodesQuery("/ruleSubproofAssertion/metastatement"),
       ruleSubproofAssertionNodeQuery = nodeQuery("/metastatement/ruleSubproofAssertion"),

package/src/{metaSubstitution.js → substitution/metastatementForMetavariable.js}

@@ -1,9 +1,10 @@
 "use strict";
 
-import { METASTATEMENT_RULE_NAME } from "./ruleNames";
-import { matchNode, bracketedNonTerminalChildNodeFromChildNodes } from "./utilities/node";
+import { matcher } from "../matcher";
+import { METASTATEMENT_RULE_NAME } from "../ruleNames";
+import { bracketedNonTerminalChildNodeFromChildNodes } from "../utilities/substitution";
 
-export default class MetaSubstitution {
+export default class MetastatementForMetavariableSubstitution {
   constructor(metavariableName, metastatementNode) {
     this.metavariableName = metavariableName;
     this.metastatementNode = metastatementNode;
@@ -22,7 +23,7 @@ export default class MetaSubstitution {
 
     const nodeA = this.metastatementNode,  ///
           nodeB = metastatementNode,
-          nodeMatches = matchNode(nodeA, nodeB);
+          nodeMatches = matcher.matchNode(nodeA, nodeB);
 
     matchesMetastatementNode = nodeMatches;  ///
 
@@ -36,7 +37,7 @@ export default class MetaSubstitution {
       if (metastatementNode !== null) {
         const nodeA = this.metastatementNode,  ///
               nodeB = metastatementNode,
-              nodeMatches = matchNode(nodeA, nodeB);
+              nodeMatches = matcher.matchNode(nodeA, nodeB);
 
         matchesMetastatementNode = nodeMatches;  ///
       }
@@ -46,7 +47,7 @@ export default class MetaSubstitution {
   }
 
   static fromMetavariableNameAndMetastatementNode(metavariableName, metastatementNode) {
-    let metaSubstitution = new MetaSubstitution(metavariableName, metastatementNode);
+    let metastatementForMetavariableSubstitution = new MetastatementForMetavariableSubstitution(metavariableName, metastatementNode);
 
     const nonTerminalNode = metastatementNode,  ///
           childNodes = nonTerminalNode.getChildNodes(),
@@ -55,9 +56,9 @@ export default class MetaSubstitution {
     metastatementNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
 
     if (metastatementNode !== null) {
-      metaSubstitution = new MetaSubstitution(metavariableName, metastatementNode);
+      metastatementForMetavariableSubstitution = new MetastatementForMetavariableSubstitution(metavariableName, metastatementNode);
     }
 
-    return metaSubstitution;
+    return metastatementForMetavariableSubstitution;
   }
 }

package/src/{substitution.js → substitution/statementForMetavariable.js}

@@ -1,9 +1,10 @@
 "use strict";
 
-import { STATEMENT_RULE_NAME } from "./ruleNames";
-import { matchNode, bracketedNonTerminalChildNodeFromChildNodes } from "./utilities/node";
+import { matcher } from "../matcher";
+import { STATEMENT_RULE_NAME } from "../ruleNames";
+import { bracketedNonTerminalChildNodeFromChildNodes } from "../utilities/substitution";
 
-export default class Substitution {
+export default class StatementForMetavariableSubstitution {
   constructor(metavariableName, statementNode) {
     this.metavariableName = metavariableName;
     this.statementNode = statementNode;
@@ -22,7 +23,7 @@ export default class Substitution {
 
     const nodeA = this.statementNode,  ///
           nodeB = statementNode,
-          nodeMatches = matchNode(nodeA, nodeB);
+          nodeMatches = matcher.matchNode(nodeA, nodeB);
 
     matchesStatementNode = nodeMatches;  ///
 
@@ -46,7 +47,7 @@ export default class Substitution {
   }
 
   static fromMetavariableNameAndStatementNode(metavariableName, statementNode) {
-    let substitution = new Substitution(metavariableName, statementNode);
+    let statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableName, statementNode);
 
     const nonTerminalNode = statementNode,  ///
           childNodes = nonTerminalNode.getChildNodes(),
@@ -55,9 +56,9 @@ export default class Substitution {
     statementNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
 
     if (statementNode !== null) {
-      substitution = new Substitution(metavariableName, statementNode);
+      statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableName, statementNode);
     }
 
-    return substitution;
+    return statementForMetavariableSubstitution;
   }
 }