occam-verify-cli 0.0.478 → 0.0.480

package/src/equality.js

@@ -2,10 +2,11 @@
 
 import { nodeQuery } from "./utilities/query";
 import { TERM_RULE_NAME } from "./ruleNames";
+import { EQUALS_CHARACTER } from "./constants";
 
-const equalityNodeQuery = nodeQuery("/statement/equality!"),
-      leftTermNodeQuery = nodeQuery("/equality/term[0]"),
-      rightTermNodeQuery = nodeQuery("/equality/term[1]");
+const specialNodeQuery = nodeQuery("/statement/@special!"),
+      leftTermNodeQuery = nodeQuery("/statement/term[0]"),
+      rightTermNodeQuery = nodeQuery("/statement/term[1]");
 
 export default class Equality {
   constructor(leftTermNode, rightTermNode) {
@@ -85,23 +86,20 @@ export default class Equality {
     const statementNode = proofStep.getStatementNode();
 
     if (statementNode !== null) {
-      const equalityNode = equalityNodeQuery(statementNode);
+      const specialNode = specialNodeQuery(statementNode);
 
-      if (equalityNode !== null) {
-        const leftTermNode = leftTermNodeQuery(equalityNode),
-              rightTermNode = rightTermNodeQuery(equalityNode);
+      if (specialNode !== null) {
+        const terminalNode = specialNode, ///
+              terminalNodeContent = terminalNode.getContent();
 
-        equality = new Equality(leftTermNode, rightTermNode);
-      }
-    }
+        if (terminalNodeContent === EQUALS_CHARACTER) {
+          const leftTermNode = leftTermNodeQuery(statementNode),
+                rightTermNode = rightTermNodeQuery(statementNode);
 
-    return equality;
-  }
-
-  static fromEqualityNode(equalityNode) {
-    const leftTermNode = leftTermNodeQuery(equalityNode),
-          rightTermNode = rightTermNodeQuery(equalityNode),
           equality = new Equality(leftTermNode, rightTermNode);
+        }
+      }
+    }
 
     return equality;
   }

package/src/metaSubstitution.js

@@ -1,58 +1,62 @@
 "use strict";
 
-import { matchNodes, bracketedChildNodeFromChildNodes } from "./utilities/node";
+import { METASTATEMENT_RULE_NAME } from "./ruleNames";
+import { matchNode, bracketedNonTerminalChildNodeFromChildNodes } from "./utilities/node";
 
 export default class MetaSubstitution {
-  constructor(metavariableName, nodes) {
+  constructor(metavariableName, metastatementNode) {
     this.metavariableName = metavariableName;
-    this.nodes = nodes;
+    this.metastatementNode = metastatementNode;
   }
 
   getMetavariableName() {
     return this.metavariableName;
   }
 
-  getNodes() {
-    return this.nodes;
+  getMetastatementNode() {
+    return this.metastatementNode;
   }
 
-  matchNodes(nodes) {
-    let matches;
+  matchMetastatementNode(metastatementNode) {
+    let matchesMetastatementNode;
 
-    const nodesA = this.nodes,  ///
-          nodesB = nodes,
-          metaSubstitutionNodesMatch = matchNodes(nodesA, nodesB);
+    const nodeA = this.metastatementNode,  ///
+          nodeB = metastatementNode,
+          nodeMatches = matchNode(nodeA, nodeB);
 
-    matches = metaSubstitutionNodesMatch;  ///
+    matchesMetastatementNode = nodeMatches;  ///
 
-    if (!matches) {
-      const childNodes = nodes, ///
-            bracketedChildNode = bracketedChildNodeFromChildNodes(childNodes);
+    if (!matchesMetastatementNode) {
+      const nonTerminalNode = metastatementNode,  ///
+            childNodes = nonTerminalNode.getChildNodes(), ///
+            ruleName = METASTATEMENT_RULE_NAME;
 
-      if (bracketedChildNode !== null) {
-        const nonTerminalNode = bracketedChildNode,  ///
-              childNodes = nonTerminalNode.getChildNodes(),
-              nodesB = childNodes, ///
-              nodesMatch = matchNodes(nodesA, nodesB);
+      metastatementNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
 
-        matches = nodesMatch; ///
+      if (metastatementNode !== null) {
+        const nodeA = this.metastatementNode,  ///
+              nodeB = metastatementNode,
+              nodeMatches = matchNode(nodeA, nodeB);
+
+        matchesMetastatementNode = nodeMatches;  ///
       }
     }
 
-    return matches;
+    return matchesMetastatementNode;
   }
 
-  static fromMetavariableNameAndNodes(metavariableName, nodes) {
-    const bracketedChildNode = bracketedChildNodeFromChildNodes(nodes);
+  static fromMetavariableNameAndMetastatementNode(metavariableName, metastatementNode) {
+    let metaSubstitution = new MetaSubstitution(metavariableName, metastatementNode);
 
-    if (bracketedChildNode !== null) {
-      const nonTerminalNode = bracketedChildNode,  ///
-            childNodes = nonTerminalNode.getChildNodes();
+    const nonTerminalNode = metastatementNode,  ///
+          childNodes = nonTerminalNode.getChildNodes(),
+          ruleName = METASTATEMENT_RULE_NAME;
 
-      nodes = childNodes; ///
-    }
+    metastatementNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
 
-    const metaSubstitution = new MetaSubstitution(metavariableName, nodes);
+    if (metastatementNode !== null) {
+      metaSubstitution = new MetaSubstitution(metavariableName, metastatementNode);
+    }
 
     return metaSubstitution;
   }

package/src/premise.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import Substitution from "./substitution";
 import MetaSubstitution from "./metaSubstitution";
 
 import { first } from "./utilities/array";
@@ -7,11 +8,13 @@ import { nodeAsString } from "./utilities/string";
 import { nodeQuery, nodesQuery } from "./utilities/query";
 import { metavariableNameFromMetavariableNode } from "./utilities/query";
 import { metastatementNodeFromMetastatementString } from "./utilities/string";
-import { METAVARIABLE_RULE_NAME, METASTATEMENT_RULE_NAME } from "./ruleNames";
+import { STATEMENT_RULE_NAME, METASTATEMENT_RULE_NAME, METAVARIABLE_RULE_NAME } from "./ruleNames";
 
 const metastatementNodesQuery = nodesQuery("/metaSubproofAssertion/metastatement"),
       metaSubproofAssertionNodeQuery = nodeQuery("/metastatement/metaSubproofAssertion!"),
+      unqualifiedStatementStatementNodesQuery = nodesQuery("/subproof/unqualifiedStatement/statement!"),
       unqualifiedMetastatementMetastatementNodesQuery = nodesQuery("/metaSubproof/unqualifiedMetastatement/metastatement!"),
+      qualifiedOrUnqualifiedStatementStatementNodeQuery = nodeQuery("/subproof/derivation|abridgedDerivation/qualifiedStatement|unqualifiedStatement[-1]/statement!"),
       qualifiedOrUnqualifiedMetastatementMetastatementNodeQuery = nodeQuery("/metaSubproof/metaDerivation|abridgedMetaDerivation/qualifiedMetastatement|unqualifiedMetastatement[-1]/metastatement!");
 
 export default class Premise {
@@ -23,6 +26,48 @@ export default class Premise {
     return this.metastatementNode;
   }
 
+  matchSubproofNode(subproofNode, substitutions) {
+    let subproofNodeMatches = false;
+
+    const subproofAssertionNode = metaSubproofAssertionNodeQuery(this.metastatementNode);
+
+    if (subproofAssertionNode !== null) {
+      const metaSubproofAssertionMetastatementNodes = metastatementNodesQuery(subproofAssertionNode),
+            unqualifiedStatementStatementNodes = unqualifiedStatementStatementNodesQuery(subproofNode),
+            qualifiedOrUnqualifiedStatementStatementNode = qualifiedOrUnqualifiedStatementStatementNodeQuery(subproofNode),
+            statementNodes = [
+              ...unqualifiedStatementStatementNodes,
+              qualifiedOrUnqualifiedStatementStatementNode
+            ],
+            statementNodesLength = statementNodes.length,
+            metaSubproofAssertionMetastatementNodesLength = metaSubproofAssertionMetastatementNodes.length;
+
+      if (statementNodesLength === metaSubproofAssertionMetastatementNodesLength) {
+        subproofNodeMatches = metaSubproofAssertionMetastatementNodes.every((metaSubproofAssertionMetastatementNode, index) => {
+          const statementNode = statementNodes[index],
+                nonTerminalNode = statementNode, ///
+                premiseNonTerminalNode = metaSubproofAssertionMetastatementNode,  ///
+                premiseNonTerminalNodeMatches = matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, substitutions);
+
+          if (premiseNonTerminalNodeMatches) {
+            return true;
+          }
+        });
+      }
+    }
+
+    return subproofNodeMatches;
+  }
+
+  matchStatementNode(statementNode, substitutions) {
+    const nonTerminalNode = statementNode,  ///
+          premiseNonTerminalNode = this.metastatementNode,  ///
+          premiseNonTerminalNodeMatches = matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, substitutions),
+          statementNodeMatches = premiseNonTerminalNodeMatches; ///
+
+    return statementNodeMatches;
+  }
+
   matchMetaSubproofNode(metaSubproofNode, metaSubstitutions) {
     let metaSubproofNodeMatches = false;
 
@@ -44,7 +89,7 @@ export default class Premise {
                                     const metastatementNode = metastatementNodes[index],
                                           nonTerminalNode = metastatementNode, ///
                                           premiseNonTerminalNode = metaSubproofAssertionMetastatementNode,  ///
-                                          premiseNonTerminalNodeMatches = matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions);
+                                          premiseNonTerminalNodeMatches = metaMatchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions);
 
                                     if (premiseNonTerminalNodeMatches) {
                                       return true;
@@ -59,7 +104,7 @@ export default class Premise {
   matchMetastatementNode(metastatementNode, metaSubstitutions) {
     const nonTerminalNode = metastatementNode,  ///
           premiseNonTerminalNode = this.metastatementNode,  ///
-          premiseNonTerminalNodeMatches = matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions),
+          premiseNonTerminalNodeMatches = metaMatchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions),
           metastatementNodeMatches = premiseNonTerminalNodeMatches; ///
 
     return metastatementNodeMatches;
@@ -91,23 +136,23 @@ export default class Premise {
   }
 }
 
-function matchPremiseNode(premiseNode, node, metaSubstitutions) {
+function matchPremiseNode(premiseNode, node, substitutions) {
   let premiseNodeMatches = false;
 
   const nodeTerminalNode = node.isTerminalNode(),
-        ruleNodeTerminalNode = premiseNode.isTerminalNode();
+    ruleNodeTerminalNode = premiseNode.isTerminalNode();
 
   if (nodeTerminalNode === ruleNodeTerminalNode) {
     if (nodeTerminalNode) {
       const terminalNode = node,  ///
             premiseTerminalNode = premiseNode,  ///
-            premiseTerminalNodeMatches = matchPremiseTerminalNode(premiseTerminalNode, terminalNode, metaSubstitutions);
+            premiseTerminalNodeMatches = matchPremiseTerminalNode(premiseTerminalNode, terminalNode, substitutions);
 
       premiseNodeMatches = premiseTerminalNodeMatches;  ///
     } else {
       const nonTerminalNode = node, ///
             premiseNonTerminalNode = premiseNode,  ///
-            premiseNonTerminalNodeMatches = matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions);
+            premiseNonTerminalNodeMatches = matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, substitutions);
 
       premiseNodeMatches = premiseNonTerminalNodeMatches; ///
     }
@@ -116,7 +161,7 @@ function matchPremiseNode(premiseNode, node, metaSubstitutions) {
   return premiseNodeMatches;
 }
 
-function matchPremiseNodes(premiseNodes, nodes, metaSubstitutions) {
+function matchPremiseNodes(premiseNodes, nodes, substitutions) {
   let premiseNodesMatches = false;
 
   const nodesLength = nodes.length,
@@ -125,7 +170,7 @@ function matchPremiseNodes(premiseNodes, nodes, metaSubstitutions) {
   if (nodesLength === premiseNodesLength) {
     premiseNodesMatches = nodes.every((node, index) => {
       const premiseNode = premiseNodes[index],
-            premiseNodeMatches = matchPremiseNode(premiseNode, node, metaSubstitutions);
+            premiseNodeMatches = matchPremiseNode(premiseNode, node, substitutions);
 
       if (premiseNodeMatches) {
         return true;
@@ -136,81 +181,225 @@ function matchPremiseNodes(premiseNodes, nodes, metaSubstitutions) {
   return premiseNodesMatches;
 }
 
-function matchPremiseMetavariable(premiseMetavariableNode, nodes, metaSubstitutions) {
-  let premiseMetavariableMatches;
+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),
-        metaSubstitution = metaSubstitutions.find((metaSubstitution) => {
-          const metavariableName = metaSubstitution.getMetavariableName();
+        substitution = substitutions.find((substitution) => {
+          const metavariableName = substitution.getMetavariableName();
 
           if (metavariableName === premiseMetavariableName) {
             return true;
           }
         }) || null;
 
-  if (metaSubstitution !== null) {
-    const metaSubstitutionNodesMatch = metaSubstitution.matchNodes(nodes);
+  if (substitution !== null) {
+    const substitutionNodesMatch = substitution.matchStatementNode(statementNode);
 
-    premiseMetavariableMatches = metaSubstitutionNodesMatch;  ///
+    premiseMetavariableNodeMatches = substitutionNodesMatch;  ///
   } else {
     const metavariableName = premiseMetavariableName, ///
-          metaSubstitution = MetaSubstitution.fromMetavariableNameAndNodes(metavariableName, nodes);
+          substitution = Substitution.fromMetavariableNameAndStatementNode(metavariableName, statementNode);
 
-    metaSubstitutions.push(metaSubstitution);
+    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; ///
+      }
+    }
+  }
 
-    premiseMetavariableMatches = true;
+  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 premiseMetavariableMatches;
+  return premiseNodeMatches;
 }
 
-function matchPremiseTerminalNode(premiseTerminalNode, terminalNode, metaSubstitutions) {
+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 matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions) {
+function metaMatchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions) {
   let premiseNonTerminalNodeMatches = false;
 
   const ruleName = nonTerminalNode.getRuleName(),
-        premiseRuleName = premiseNonTerminalNode.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);
 
-  if (ruleName === premiseRuleName) {
-    const childNodes = nonTerminalNode.getChildNodes(),
-          premiseChildNodes = premiseNonTerminalNode.getChildNodes(),
-          nodes = childNodes, ///
-          premiseNodes = premiseChildNodes, ///
-          premiseChildNodesMatches = matchPremiseNodes(premiseNodes, nodes, metaSubstitutions);
+      premiseNonTerminalNodeMatches = premiseNonTerminalNodeChildNodesMatches; ///
+    }
+  } else if (ruleName === premiseNonTerminalNodeRuleName) {
+    const premiseNonTerminalNodeChildNodesMatches = metaMatchPremiseNodes(premiseNodes, nodes, metaSubstitutions);
 
-    premiseNonTerminalNodeMatches = premiseChildNodesMatches; ///
+    premiseNonTerminalNodeMatches = premiseNonTerminalNodeChildNodesMatches; ///
+  }
 
-    if (!premiseNonTerminalNodeMatches) {
-      const ruleNameMetastatementRuleName = (ruleName === METASTATEMENT_RULE_NAME);
+  return premiseNonTerminalNodeMatches;
+}
 
-      if (ruleNameMetastatementRuleName) {
-        const metastatementNode = nonTerminalNode,  ///
-              premiseMetastatementNode = premiseNonTerminalNode,  ///
-              premiseMetastatementNodeMatches = matchPremiseMetastatementNode(premiseMetastatementNode, metastatementNode, metaSubstitutions);
+function metaMatchPremiseMetavariableNode(premiseMetavariableNode, metastatementNode, metaSubstitutions) {
+  let premiseMetavariableNodeMatches;
 
-        premiseNonTerminalNodeMatches = premiseMetastatementNodeMatches; ///
-      }
-    }
+  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 premiseNonTerminalNodeMatches;
+  return premiseMetavariableNodeMatches;
 }
 
-function matchPremiseMetastatementNode(premiseMetastatementNode, metastatementNode, metaSubstitutions) {
+function metaMatchPremiseMetastatementNode(premiseMetastatementNode, metastatementNode, metaSubstitutions) {
   let premiseMetastatementNodeMatches = false;
 
   const premiseNonTerminalNode = premiseMetastatementNode,  ///
-        premiseChildNodes = premiseNonTerminalNode.getChildNodes(),
-        premiseChildNodesLength = premiseChildNodes.length;
+        premiseNonTerminalNodeChildNodes = premiseNonTerminalNode.getChildNodes(),
+        premiseNonTerminalNodeChildNodesLength = premiseNonTerminalNodeChildNodes.length;
 
-  if (premiseChildNodesLength === 1) {
-    const firstPremiseChildNode = first(premiseChildNodes),
+  if (premiseNonTerminalNodeChildNodesLength === 1) {
+    const firstPremiseChildNode = first(premiseNonTerminalNodeChildNodes),
           premiseChildNode = firstPremiseChildNode,  ///
           premiseChildNodeNonTerminalNode = premiseChildNode.isNonTerminalNode();
 
@@ -221,12 +410,9 @@ function matchPremiseMetastatementNode(premiseMetastatementNode, metastatementNo
 
       if (premiseNonTerminalChildNodeRuleNameMetavariableRuleName) {
         const premiseMetavariableNode = premiseNonTerminalChildNode,  ///
-              nonTerminalNode = metastatementNode,  ///
-              childNodes = nonTerminalNode.getChildNodes(),
-              nodes = childNodes, ///
-              premiseMetaVariableMatches = matchPremiseMetavariable(premiseMetavariableNode, nodes, metaSubstitutions);
+              premiseMetaVariableNodeMatches = metaMatchPremiseMetavariableNode(premiseMetavariableNode, metastatementNode, metaSubstitutions);
 
-        premiseMetastatementNodeMatches = premiseMetaVariableMatches; ///
+        premiseMetastatementNodeMatches = premiseMetaVariableNodeMatches; ///
       }
     }
   }