occam-verify-cli 0.0.505 → 0.0.507

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 { premiseMatcher } from "./matcher/premise";
+import { premiseMetaMatcher } from "./metaMatcher/premise";
 import { nodeQuery, nodesQuery } from "./utilities/query";
-import { metavariableNameFromMetavariableNode } from "./utilities/query";
 import { metastatementNodeFromMetastatementString } from "./utilities/string";
-import { STATEMENT_RULE_NAME, METASTATEMENT_RULE_NAME, METAVARIABLE_RULE_NAME } from "./ruleNames";
 
 const metastatementNodesQuery = nodesQuery("/ruleSubproofAssertion/metastatement"),
       ruleSubproofAssertionNodeQuery = nodeQuery("/metastatement/ruleSubproofAssertion!"),
-      unqualifiedStatementStatementNodesQuery = nodesQuery("/subproof/antecedent/unqualifiedStatement!/statement!"),
-      unqualifiedMetastatementMetastatementNodesQuery = nodesQuery("/ruleSubproof/metaAntecedent/unqualifiedMetastatement!/metastatement!"),
-      qualifiedOrUnqualifiedStatementStatementNodeQuery = nodeQuery("/subproof/subDerivation/qualifiedStatement|unqualifiedStatement[-1]/statement!"),
-      qualifiedOrUnqualifiedMetastatementMetastatementNodeQuery = nodeQuery("/ruleSubproof/metaSubDerivation/qualifiedMetastatement|unqualifiedMetastatement[-1]/metastatement!");
+      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!");
 
 export default class Premise {
   constructor(metastatementNode) {
@@ -32,12 +28,12 @@ export default class Premise {
     const subproofAssertionNode = ruleSubproofAssertionNodeQuery(this.metastatementNode);
 
     if (subproofAssertionNode !== null) {
-      const ruleSubproofAssertionMetastatementNodes = metastatementNodesQuery(subproofAssertionNode),
-            unqualifiedStatementStatementNodes = unqualifiedStatementStatementNodesQuery(subproofNode),
-            qualifiedOrUnqualifiedStatementStatementNode = qualifiedOrUnqualifiedStatementStatementNodeQuery(subproofNode),
+      const subDerivationStatementNode = subDerivationStatementNodeQuery(subproofNode),
+            suppositionStatementStatementNodes = suppositionStatementStatementNodesQuery(subproofNode),
+            ruleSubproofAssertionMetastatementNodes = metastatementNodesQuery(subproofAssertionNode),
             statementNodes = [
-              ...unqualifiedStatementStatementNodes,
-              qualifiedOrUnqualifiedStatementStatementNode
+              ...suppositionStatementStatementNodes,
+              subDerivationStatementNode
             ],
             statementNodesLength = statementNodes.length,
             ruleSubproofAssertionMetastatementNodesLength = ruleSubproofAssertionMetastatementNodes.length;
@@ -47,9 +43,9 @@ export default class Premise {
           const statementNode = statementNodes[index],
                 nonTerminalNode = statementNode, ///
                 premiseNonTerminalNode = ruleSubproofAssertionMetastatementNode,  ///
-                premiseNonTerminalNodeMatches = matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, substitutions);
+                nonTerminalNodeMatches = premiseMatcher.matchNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, substitutions);
 
-          if (premiseNonTerminalNodeMatches) {
+          if (nonTerminalNodeMatches) {
             return true;
           }
         });
@@ -62,8 +58,8 @@ export default class Premise {
   matchStatementNode(statementNode, substitutions) {
     const nonTerminalNode = statementNode,  ///
           premiseNonTerminalNode = this.metastatementNode,  ///
-          premiseNonTerminalNodeMatches = matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, substitutions),
-          statementNodeMatches = premiseNonTerminalNodeMatches; ///
+          nonTerminalNodeMatches = premiseMatcher.matchNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, substitutions),
+          statementNodeMatches = nonTerminalNodeMatches; ///
 
     return statementNodeMatches;
   }
@@ -74,12 +70,12 @@ export default class Premise {
     const ruleSubproofAssertionNode = ruleSubproofAssertionNodeQuery(this.metastatementNode);
 
     if (ruleSubproofAssertionNode !== null) {
-      const ruleSubproofAssertionMetastatementNodes = metastatementNodesQuery(ruleSubproofAssertionNode),
-            unqualifiedMetastatementMetastatementNodes = unqualifiedMetastatementMetastatementNodesQuery(ruleSubproofNode),
-            qualifiedOrUnqualifiedMetastatementMetastatementNode = qualifiedOrUnqualifiedMetastatementMetastatementNodeQuery(ruleSubproofNode),
+      const premiseMetastatementNodes = premiseMetastatementNodesQuery(ruleSubproofNode),
+            ruleSubDerivationMetastatementNode = ruleSubDerivationMetastatementNodeQuery(ruleSubproofNode),
+            ruleSubproofAssertionMetastatementNodes = metastatementNodesQuery(ruleSubproofAssertionNode),
             metastatementNodes = [
-              ...unqualifiedMetastatementMetastatementNodes,
-              qualifiedOrUnqualifiedMetastatementMetastatementNode
+              ...premiseMetastatementNodes,
+              ruleSubDerivationMetastatementNode
             ],
             metastatementNodesLength = metastatementNodes.length,
             ruleSubproofAssertionMetastatementNodesLength = ruleSubproofAssertionMetastatementNodes.length;
@@ -89,9 +85,9 @@ export default class Premise {
                                     const metastatementNode = metastatementNodes[index],
                                           nonTerminalNode = metastatementNode, ///
                                           premiseNonTerminalNode = ruleSubproofAssertionMetastatementNode,  ///
-                                          premiseNonTerminalNodeMatches = metaMatchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions);
+                                          nonTerminalNodeMatches = premiseMetaMatcher.matchNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions);
 
-                                    if (premiseNonTerminalNodeMatches) {
+                                    if (nonTerminalNodeMatches) {
                                       return true;
                                     }
                                   });
@@ -104,8 +100,8 @@ export default class Premise {
   matchMetastatementNode(metastatementNode, metaSubstitutions) {
     const nonTerminalNode = metastatementNode,  ///
           premiseNonTerminalNode = this.metastatementNode,  ///
-          premiseNonTerminalNodeMatches = metaMatchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions),
-          metastatementNodeMatches = premiseNonTerminalNodeMatches; ///
+          nonTerminalNodeMatches = premiseMetaMatcher.matchNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions),
+          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/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"),
@@ -85,7 +85,7 @@ export default class MetaproofStep {
 
   static fromRuleSubproofNode(ruleSubproofNode) {
     const metastatementNode = null,
-          metaProofStep = new MetaproofStep(ruleSubproofNode, ruleSubproofNode, metastatementNode);
+          metaProofStep = new MetaproofStep(ruleSubproofNode, metastatementNode);
 
     return metaProofStep;
   }

package/src/substitution.js

@@ -1,7 +1,8 @@
 "use strict";
 
+import { matcher } from "./matcher";
 import { STATEMENT_RULE_NAME } from "./ruleNames";
-import { matchNode, bracketedNonTerminalChildNodeFromChildNodes } from "./utilities/node";
+import { bracketedNonTerminalChildNodeFromChildNodes } from "./utilities/substitution";
 
 export default class Substitution {
   constructor(metavariableName, 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;  ///
 

package/src/supposition.js

@@ -1,13 +1,9 @@
 "use strict";
 
-import Substitution from "./substitution";
-
-import { first } from "./utilities/array";
 import { nodeAsString } from "./utilities/string";
+import { suppositionMatcher } from "./matcher/supposition";
 import { nodeQuery, nodesQuery } from "./utilities/query";
-import { variableNameFromVariableNode } from "./utilities/query";
 import { statementNodeFromStatementString } from "./utilities/string";
-import { VARIABLE_RULE_NAME, STATEMENT_RULE_NAME } from "./ruleNames";
 
 const statementNodesQuery = nodesQuery("/subproofAssertion/statement"),
       subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
@@ -41,15 +37,15 @@ export default class Supposition {
 
       if (statementNodesLength === subproofAssertionStatementNodesLength) {
         subproofNodeMatches = subproofAssertionStatementNodes.every((subproofAssertionStatementNode, index) => {
-                                    const statementNode = statementNodes[index],
-                                          nonTerminalNode = statementNode, ///
-                                          suppositionNonTerminalNode = subproofAssertionStatementNode,  ///
-                                          suppositionNonTerminalNodeMatches = matchSuppositionNonTerminalNode(suppositionNonTerminalNode, nonTerminalNode, substitutions);
-
-                                    if (suppositionNonTerminalNodeMatches) {
-                                      return true;
-                                    }
-                                  });
+                                const statementNode = statementNodes[index],
+                                      nonTerminalNode = statementNode, ///
+                                      suppositionNonTerminalNode = subproofAssertionStatementNode,  ///
+                                      nonTerminalNodeMatches = suppositionMatcher.matchNonTerminalNode(suppositionNonTerminalNode, nonTerminalNode, substitutions);
+
+                                if (nonTerminalNodeMatches) {
+                                  return true;
+                                }
+                              });
       }
     }
 
@@ -59,8 +55,8 @@ export default class Supposition {
   matchStatementNode(statementNode, substitutions) {
     const nonTerminalNode = statementNode,  ///
           suppositionNonTerminalNode = this.statementNode,  ///
-          suppositionNonTerminalNodeMatches = matchSuppositionNonTerminalNode(suppositionNonTerminalNode, nonTerminalNode, substitutions),
-          statementNodeMatches = suppositionNonTerminalNodeMatches; ///
+          nonTerminalNodeMatches = suppositionMatcher.matchNonTerminalNode(suppositionNonTerminalNode, nonTerminalNode, substitutions),
+          statementNodeMatches = nonTerminalNodeMatches; ///
 
     return statementNodeMatches;
   }
@@ -90,146 +86,3 @@ export default class Supposition {
     return supposition;
   }
 }
-
-function matchSuppositionNode(suppositionNode, node, substitutions) {
-  let suppositionNodeMatches = false;
-
-  const nodeTerminalNode = node.isTerminalNode(),
-        ruleNodeTerminalNode = suppositionNode.isTerminalNode();
-
-  if (nodeTerminalNode === ruleNodeTerminalNode) {
-    if (nodeTerminalNode) {
-      const terminalNode = node,  ///
-            suppositionTerminalNode = suppositionNode,  ///
-            suppositionTerminalNodeMatches = matchSuppositionTerminalNode(suppositionTerminalNode, terminalNode, substitutions);
-
-      suppositionNodeMatches = suppositionTerminalNodeMatches;  ///
-    } else {
-      const nonTerminalNode = node, ///
-            suppositionNonTerminalNode = suppositionNode,  ///
-            suppositionNonTerminalNodeMatches = matchSuppositionNonTerminalNode(suppositionNonTerminalNode, nonTerminalNode, substitutions);
-
-      suppositionNodeMatches = suppositionNonTerminalNodeMatches; ///
-    }
-  }
-
-  return suppositionNodeMatches;
-}
-
-function matchSuppositionNodes(suppositionNodes, nodes, substitutions) {
-  let suppositionNodesMatches = false;
-
-  const nodesLength = nodes.length,
-        suppositionNodesLength = suppositionNodes.length;
-
-  if (nodesLength === suppositionNodesLength) {
-    suppositionNodesMatches = nodes.every((node, index) => {
-      const suppositionNode = suppositionNodes[index],
-            suppositionNodeMatches = matchSuppositionNode(suppositionNode, node, substitutions);
-
-      if (suppositionNodeMatches) {
-        return true;
-      }
-    });
-  }
-
-  return suppositionNodesMatches;
-}
-
-function matchSuppositionVariable(suppositionVariableNode, nodes, substitutions) {
-  let suppositionVariableMatches;
-
-  const suppositionVariableName = variableNameFromVariableNode(suppositionVariableNode),
-        substitution = substitutions.find((substitution) => {
-          const variableName = substitution.getVariableName();
-
-          if (variableName === suppositionVariableName) {
-            return true;
-          }
-        }) || null;
-
-  if (substitution !== null) {
-    const substitutionNodesMatch = substitution.matchNodes(nodes);
-
-    suppositionVariableMatches = substitutionNodesMatch;  ///
-  } else {
-    const variableName = suppositionVariableName, ///
-          substitution = Substitution.fromVariableNameAndNodes(variableName, nodes);
-
-    substitutions.push(substitution);
-
-    suppositionVariableMatches = true;
-  }
-
-  return suppositionVariableMatches;
-}
-
-function matchSuppositionTerminalNode(suppositionTerminalNode, terminalNode, substitutions) {
-  const matches = suppositionTerminalNode.match(terminalNode),
-        suppositionTerminalNodeMatches = matches;
-
-  return suppositionTerminalNodeMatches;
-}
-
-function matchSuppositionNonTerminalNode(suppositionNonTerminalNode, nonTerminalNode, substitutions) {
-  let suppositionNonTerminalNodeMatches = false;
-
-  const ruleName = nonTerminalNode.getRuleName(),
-        suppositionRuleName = suppositionNonTerminalNode.getRuleName(); ///
-
-  if (ruleName === suppositionRuleName) {
-    const childNodes = nonTerminalNode.getChildNodes(),
-          suppositionChildNodes = suppositionNonTerminalNode.getChildNodes(),
-          nodes = childNodes, ///
-          suppositionNodes = suppositionChildNodes, ///
-          suppositionChildNodesMatches = matchSuppositionNodes(suppositionNodes, nodes, substitutions);
-
-    suppositionNonTerminalNodeMatches = suppositionChildNodesMatches; ///
-
-    if (!suppositionNonTerminalNodeMatches) {
-      const ruleNameStatementRuleName = (ruleName === STATEMENT_RULE_NAME);
-
-      if (ruleNameStatementRuleName) {
-        const statementNode = nonTerminalNode,  ///
-              suppositionStatementNode = suppositionNonTerminalNode,  ///
-              suppositionStatementNodeMatches = matchSuppositionStatementNode(suppositionStatementNode, statementNode, substitutions);
-
-        suppositionNonTerminalNodeMatches = suppositionStatementNodeMatches; ///
-      }
-    }
-  }
-
-  return suppositionNonTerminalNodeMatches;
-}
-
-function matchSuppositionStatementNode(suppositionStatementNode, statementNode, substitutions) {
-  let suppositionStatementNodeMatches = false;
-
-  const suppositionNonTerminalNode = suppositionStatementNode,  ///
-        suppositionChildNodes = suppositionNonTerminalNode.getChildNodes(),
-        suppositionChildNodesLength = suppositionChildNodes.length;
-
-  if (suppositionChildNodesLength === 1) {
-    const firstSuppositionChildNode = first(suppositionChildNodes),
-          suppositionChildNode = firstSuppositionChildNode,  ///
-          suppositionChildNodeNonTerminalNode = suppositionChildNode.isNonTerminalNode();
-
-    if (suppositionChildNodeNonTerminalNode) {
-      const suppositionNonTerminalChildNode = suppositionChildNode,  ///
-            suppositionNonTerminalChildNodeRuleName = suppositionNonTerminalChildNode.getRuleName(),
-            suppositionNonTerminalChildNodeRuleNameVariableRuleName = (suppositionNonTerminalChildNodeRuleName === VARIABLE_RULE_NAME);
-
-      if (suppositionNonTerminalChildNodeRuleNameVariableRuleName) {
-        const suppositionVariableNode = suppositionNonTerminalChildNode,  ///
-              nonTerminalNode = statementNode,  ///
-              childNodes = nonTerminalNode.getChildNodes(),
-              nodes = childNodes, ///
-              suppositionVariableMatches = matchSuppositionVariable(suppositionVariableNode, nodes, substitutions);
-
-        suppositionStatementNodeMatches = suppositionVariableMatches; ///
-      }
-    }
-  }
-
-  return suppositionStatementNodeMatches;
-}

package/src/theorem.js

@@ -9,5 +9,5 @@ export default class Theorem extends AxiomLemmaTheorem {
 
   static fromJSON(json, releaseContext) { return AxiomLemmaTheorem.fromJSON(Theorem, json, releaseContext); }
 
-  static fromLabelsSuppositionsAndConsequence(labels, antecedents, consequence) { return AxiomLemmaTheorem.fromLabelsSuppositionsAndConsequence(Theorem, labels, antecedents, consequence); }
+  static fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence) { return AxiomLemmaTheorem.fromLabelsSuppositionsAndConsequence(Theorem, labels, suppositions, consequence); }
 }