occam-verify-cli 0.0.478 → 0.0.479

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,224 @@ 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(),
+        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 nodes = childNodes, ///
+            premiseNodes = premiseNonTerminalNodeChildNodes, ///
+            premiseNonTerminalNodeChildNodesMatches = matchPremiseNodes(premiseNodes, nodes, substitutions);
+
+      premiseNonTerminalNodeMatches = premiseNonTerminalNodeChildNodesMatches; ///
+    }
+  } else if (ruleName === premiseNonTerminalNodeRuleName) {
+    const nodes = childNodes, ///
+          premiseNodes = premiseNonTerminalNodeChildNodes, ///
+          premiseNonTerminalNodeChildNodesMatches = matchPremiseNodes(premiseNodes, nodes, substitutions);
+
+    premiseNonTerminalNodeMatches = premiseNonTerminalNodeChildNodesMatches; ///
+  }
+
+  return premiseNonTerminalNodeMatches;
+}
+
+function matchPremiseMetavariableNode(premiseMetavariableNode, nodes, 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.matchNodes(nodes);
 
-    premiseMetavariableMatches = metaSubstitutionNodesMatch;  ///
+    premiseMetavariableNodeMatches = substitutionNodesMatch;  ///
   } else {
     const metavariableName = premiseMetavariableName, ///
-          metaSubstitution = MetaSubstitution.fromMetavariableNameAndNodes(metavariableName, nodes);
+          substitution = Substitution.fromMetavariableNameAndNodes(metavariableName, nodes);
 
-    metaSubstitutions.push(metaSubstitution);
+    substitutions.push(substitution);
 
-    premiseMetavariableMatches = true;
+    premiseMetavariableNodeMatches = true;
   }
 
-  return premiseMetavariableMatches;
+  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,  ///
+              nonTerminalNode = statementNode,  ///
+              childNodes = nonTerminalNode.getChildNodes(),
+              nodes = childNodes, ///
+              premiseMetaVariableNodeMatches = matchPremiseMetavariableNode(premiseMetavariableNode, nodes, substitutions);
+
+        premiseMetastatementNodeMatches = premiseMetaVariableNodeMatches; ///
+      }
+    }
+  }
+
+  return premiseMetastatementNodeMatches;
 }
 
-function matchPremiseTerminalNode(premiseTerminalNode, terminalNode, metaSubstitutions) {
+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 matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions) {
+function metaMatchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions) {
   let premiseNonTerminalNodeMatches = false;
 
   const ruleName = nonTerminalNode.getRuleName(),
-        premiseRuleName = premiseNonTerminalNode.getRuleName(); ///
+        premiseNonTerminalNodeRuleName = premiseNonTerminalNode.getRuleName(),
+        ruleNameMetastatementRuleName = (ruleName === METASTATEMENT_RULE_NAME),
+        premiseNonTerminalNodeRuleNameMetastatementRuleName = (premiseNonTerminalNodeRuleName === METASTATEMENT_RULE_NAME);
+
+  if (ruleNameMetastatementRuleName && premiseNonTerminalNodeRuleNameMetastatementRuleName) {
+    const metastatementNode = nonTerminalNode,  ///
+          premiseMetastatementNode = premiseNonTerminalNode,  ///
+          premiseMetastatementNodeMatches = metaMatchPremiseMetastatementNode(premiseMetastatementNode, metastatementNode, metaSubstitutions);
 
-  if (ruleName === premiseRuleName) {
+    premiseNonTerminalNodeMatches = premiseMetastatementNodeMatches; ///
+  } else if (ruleName === premiseNonTerminalNodeRuleName) {
     const childNodes = nonTerminalNode.getChildNodes(),
-          premiseChildNodes = premiseNonTerminalNode.getChildNodes(),
+          premiseNonTerminalNodeChildNodes = premiseNonTerminalNode.getChildNodes(), ///
           nodes = childNodes, ///
-          premiseNodes = premiseChildNodes, ///
-          premiseChildNodesMatches = matchPremiseNodes(premiseNodes, nodes, metaSubstitutions);
+          premiseNodes = premiseNonTerminalNodeChildNodes, ///
+          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, nodes, 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.matchNodes(nodes);
+
+    premiseMetavariableNodeMatches = metaSubstitutionNodesMatch;  ///
+  } else {
+    const metavariableName = premiseMetavariableName, ///
+          metaSubstitution = MetaSubstitution.fromMetavariableNameAndNodes(metavariableName, nodes);
+
+    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();
 
@@ -224,9 +412,9 @@ function matchPremiseMetastatementNode(premiseMetastatementNode, metastatementNo
               nonTerminalNode = metastatementNode,  ///
               childNodes = nonTerminalNode.getChildNodes(),
               nodes = childNodes, ///
-              premiseMetaVariableMatches = matchPremiseMetavariable(premiseMetavariableNode, nodes, metaSubstitutions);
+              premiseMetaVariableNodeMatches = metaMatchPremiseMetavariableNode(premiseMetavariableNode, nodes, metaSubstitutions);
 
-        premiseMetastatementNodeMatches = premiseMetaVariableMatches; ///
+        premiseMetastatementNodeMatches = premiseMetaVariableNodeMatches; ///
       }
     }
   }

package/src/rule.js

@@ -40,6 +40,40 @@ export default class Rule {
     return matchesLabelName;
   }
 
+  matchStatement(statementNode, proofContext) {
+    let statementNatches;
+
+    const premisesLength = this.premises.length;
+
+    if (premisesLength === 0) {
+      const substitutions = [],
+            conclusionMatches = matchConclusion(this.conclusion, statementNode, substitutions);
+
+      statementNatches = conclusionMatches; ///
+    } else {
+      const proofSteps = proofContext.getProofSteps();
+
+      statementNatches = someSubArray(proofSteps, premisesLength, (proofSteps) => {
+        let premisesMatchConclusion = false;
+
+        const substitutions = [],
+              premisesMatch = matchPremises(this.premises, proofSteps, substitutions);
+
+        if (premisesMatch) {
+          const conclusionMatches = matchConclusion(this.conclusion, statementNode, substitutions);
+
+          premisesMatchConclusion = conclusionMatches;  ///
+        }
+
+        if (premisesMatchConclusion) {
+          return true;
+        }
+      });
+    }
+
+    return statementNatches;
+  }
+
   matchMetastatement(metastatementNode, metaproofContext) {
     let metastatementNatches;
 
@@ -47,7 +81,7 @@ export default class Rule {
 
     if (premisesLength === 0) {
       const metaSubstitutions = [],
-            conclusionMatches = matchConclusion(this.conclusion, metastatementNode, metaSubstitutions);
+            conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, metaSubstitutions);
 
       metastatementNatches = conclusionMatches; ///
     } else {
@@ -57,10 +91,10 @@ export default class Rule {
         let premisesMatchConclusion = false;
 
         const metaSubstitutions = [],
-              premisesMatches = matchPremises(this.premises, metaproofSteps, metaSubstitutions);
+              premisesMatch = metaMatchPremises(this.premises, metaproofSteps, metaSubstitutions);
 
-        if (premisesMatches) {
-          const conclusionMatches = matchConclusion(this.conclusion, metastatementNode, metaSubstitutions);
+        if (premisesMatch) {
+          const conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, metaSubstitutions);
 
           premisesMatchConclusion = conclusionMatches;  ///
         }
@@ -145,23 +179,69 @@ export default class Rule {
   }
 }
 
-function matchPremise(premise, metaproofSteps, metaSubstitutions) {
+function matchPremise(premise, proofSteps, substitutions) {
+  const proofStep = prune(proofSteps, (proofStep) => {
+    const subproofNode = proofStep.getSubproofNode(),
+          statementNode = proofStep.getStatementNode()
+
+    if (subproofNode !== null) {
+      const subProofNodeMatches = premise.matchSubproofNode(subproofNode, substitutions);
+
+      if (!subProofNodeMatches) {  ///
+        return true;
+      }
+    }
+
+    if (statementNode !== null) {
+      const statementNodeMatches = premise.matchStatementNode(statementNode, substitutions);
+
+      if (!statementNodeMatches) {  ///
+        return true;
+      }
+    }
+  }) || null;
+
+  const premiseMatches = (proofStep !== null);
+
+  return premiseMatches;
+}
+
+function matchPremises(premise, proofSteps, substitutions) {
+  const premisesMatch = premise.every((premise) => {
+    const premiseMatches = matchPremise(premise, proofSteps, substitutions);
+
+    if (premiseMatches) {
+      return true;
+    }
+  });
+
+  return premisesMatch;
+}
+
+function matchConclusion(conclusion, statementNode, substitutions) {
+  const statementNodeMatches = conclusion.matchStatementNode(statementNode, substitutions),
+        conclusionMatches = statementNodeMatches; ///
+
+  return conclusionMatches;
+}
+
+function metaMatchPremise(premise, metaproofSteps, metaSubstitutions) {
   const metaproofStep = prune(metaproofSteps, (metaproofStep) => {
     const metaSubproofNode = metaproofStep.getMetaSubproofNode(),
           metastatementNode = metaproofStep.getMetastatementNode()
 
     if (metaSubproofNode !== null) {
-      const metaSubProofMatches = premise.matchMetaSubproofNode(metaSubproofNode, metaSubstitutions);
+      const metaSubProofNodeMatches = premise.matchMetaSubproofNode(metaSubproofNode, metaSubstitutions);
 
-      if (!metaSubProofMatches) {  ///
+      if (!metaSubProofNodeMatches) {  ///
         return true;
       }
     }
 
     if (metastatementNode !== null) {
-      const metastatementMatches = premise.matchMetastatementNode(metastatementNode, metaSubstitutions);
+      const metastatementNodeMatches = premise.matchMetastatementNode(metastatementNode, metaSubstitutions);
 
-      if (!metastatementMatches) {  ///
+      if (!metastatementNodeMatches) {  ///
         return true;
       }
     }
@@ -172,21 +252,21 @@ function matchPremise(premise, metaproofSteps, metaSubstitutions) {
   return premiseMatches;
 }
 
-function matchPremises(premise, metaproofSteps, metaSubstitutions) {
-  const premisesMatches = premise.every((premise) => {
-    const premiseMatches = matchPremise(premise, metaproofSteps, metaSubstitutions);
+function metaMatchPremises(premise, metaproofSteps, metaSubstitutions) {
+  const premisesMatch = premise.every((premise) => {
+    const premiseMatches = metaMatchPremise(premise, metaproofSteps, metaSubstitutions);
 
     if (premiseMatches) {
       return true;
     }
   });
 
-  return premisesMatches;
+  return premisesMatch;
 }
 
-function matchConclusion(conclusion, metastatementNode, metaSubstitutions) {
-  const nonTerminalNodeMatches = conclusion.matchMetastatementNode(metastatementNode, metaSubstitutions),
-        conclusionMatches = nonTerminalNodeMatches; ///
+function metaMatchConclusion(conclusion, metastatementNode, metaSubstitutions) {
+  const metastatementNodeMatches = conclusion.matchMetastatementNode(metastatementNode, metaSubstitutions),
+        conclusionMatches = metastatementNodeMatches; ///
 
   return conclusionMatches;
 }

package/src/ruleNames.js

@@ -4,12 +4,13 @@ export const TERM_RULE_NAME = "term";
 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 STATEMENT_RULE_NAME = "statement";
 export const METAVARIABLE_RULE_NAME = "metavariable";
 export const METASTATEMENT_RULE_NAME = "metastatement";
 export const META_SUBPROOF_RULE_NAME = "metaSubproof";
+export const QUALIFIED_STATEMENT_RULE_NAME = "qualifiedStatement";
 export const UNQUALIFIED_STATEMENT_RULE_NAME = "unqualifiedStatement";
 export const CONDITIONAL_INDICATIVE_RULE_NAME = "conditionalIndicative";
-export const COMBINATOR_DECLARATION_RULE_NAME = "combinatorDeclaration";
-export const CONSTRUCTOR_DECLARATION_RULE_NAME = "constructorDeclaration";
 export const QUALIFIED_METASTATEMENT_RULE_NAME = "qualifiedMetastatement";
 export const UNQUALIFIED_METASTATEMENT_RULE_NAME = "unqualifiedMetastatement";

package/src/substitution.js

@@ -3,13 +3,13 @@
 import { matchNodes, bracketedChildNodeFromChildNodes } from "./utilities/node";
 
 export default class Substitution {
-  constructor(variableName, nodes) {
-    this.variableName = variableName;
+  constructor(metavariableName, nodes) {
+    this.metavariableName = metavariableName;
     this.nodes = nodes;
   }
 
-  getVariableName() {
-    return this.variableName;
+  getMetavariableName() {
+    return this.metavariableName;
   }
 
   getNodes() {
@@ -21,9 +21,9 @@ export default class Substitution {
 
     const nodesA = this.nodes,  ///
           nodesB = nodes,
-          metaSubstitutionNodesMatch = matchNodes(nodesA, nodesB);
+          nodesMatch = matchNodes(nodesA, nodesB);
 
-    matches = metaSubstitutionNodesMatch;  ///
+    matches = nodesMatch;  ///
 
     if (!matches) {
       const childNodes = nodes, ///
@@ -42,7 +42,7 @@ export default class Substitution {
     return matches;
   }
 
-  static fromMetavariableNameAndNodes(variableName, nodes) {
+  static fromMetavariableNameAndNodes(metavariableName, nodes) {
     const bracketedChildNode = bracketedChildNodeFromChildNodes(nodes);
 
     if (bracketedChildNode !== null) {
@@ -52,7 +52,7 @@ export default class Substitution {
       nodes = childNodes; ///
     }
 
-    const metaSubstitution = new Substitution(variableName, nodes);
+    const metaSubstitution = new Substitution(metavariableName, nodes);
 
     return metaSubstitution;
   }