occam-verify-cli 0.0.893 → 0.0.895

package/src/metaSupposition.js

@@ -6,42 +6,45 @@ import metaLevelNodesVerifier from "./verifier/nodes/metaLevel";
 import { match } from "./utilities/array";
 import { nodeAsString } from "./utilities/string";
 import { nodeQuery, nodesQuery } from "./utilities/query";
-import { metastatementNodeFromMetastatementString } from "./utilities/node";
+import { statementNodeFromStatementString, metastatementNodeFromMetastatementString } from "./utilities/node";
 
-const metaSubproofAssertionNodeQuery = nodeQuery("/metastatement/metaSubproofAssertion!"),
-      metaSubproofAssertionMetastatementNodesQuery = nodesQuery("/metaSubproofAssertion/metastatement"),
+const subproofAssertionNodeQuery = nodeQuery("/metastatement/subproofAssertion!"),
+      subproofAssertionMetastatementNodesQuery = nodesQuery("/subproofAssertion/metastatement"),
       metaSubproofMetaSuppositionMetastatementNodesQuery = nodesQuery("/metaSubproof/metaSupposition/unqualifiedMetastatement/metastatement!"),
-      metaSubproofSubDerivationLastMetastatementNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation/qualifiedMetastatement|unqualifiedMetastatement[-1]/metastatement!");
+      metaSubproofLastMetaProofStepMetastatementNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation/lastMetaProofStep/unqualifiedMetastatement|qualifiedMetastatement/metastatement!");
 
 export default class MetaSupposition {
-  constructor(metastatementNode) {
+  constructor(metastatementNode, statementNode) {
     this.metastatementNode = metastatementNode;
+    this.statementNode = statementNode;
   }
 
   getMetastatementNode() {
     return this.metastatementNode;
   }
 
+  getStatementNode() {
+    return this.statementNode;
+  }
+
   matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext) {
     let metaSubproofNodeMatches = false;
 
-    const metaSubproofAssertionNode = metaSubproofAssertionNodeQuery(this.metastatementNode);
-
-    if (metaSubproofAssertionNode !== null) {
-      const metaSubproofMetaSuppositionMetastatementNodes = metaSubproofMetaSuppositionMetastatementNodesQuery(metaSubproofNode),
-            metaSubproofSubDerivationLastMetastatementNode = metaSubproofSubDerivationLastMetastatementNodeQuery(metaSubproofNode),
-            metaSubproofMetastatementNodes = [
-              ...metaSubproofMetaSuppositionMetastatementNodes,
-              metaSubproofSubDerivationLastMetastatementNode
-            ],
-            metaSubproofAssertionMetastatementNodes = metaSubproofAssertionMetastatementNodesQuery(metaSubproofAssertionNode),
-            metaSubproofMetastatementNodesLength = metaSubproofMetastatementNodes.length,
-            metaSubproofAssertionMetastatementNodesLength = metaSubproofAssertionMetastatementNodes.length;
-
-      if (metaSubproofMetastatementNodesLength === metaSubproofAssertionMetastatementNodesLength) {
-        metaSubproofNodeMatches = match(metaSubproofAssertionMetastatementNodes, metaSubproofMetastatementNodes, (metaSubproofAssertionMetastatementNode, metaSubproofMetastatementNode) => {
-          const nonTerminalNodeA = metaSubproofAssertionMetastatementNode,  ///
-                nonTerminalNodeB = metaSubproofMetastatementNode, ///
+    if (this.metastatementNode !== null) {
+      const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
+
+      if (subproofAssertionNode !== null) {
+        const metaSubproofMetaSuppositionMetastatementNodes = metaSubproofMetaSuppositionMetastatementNodesQuery(metaSubproofNode),
+              metaSubproofLastMetaProofStepMetastatementNode = metaSubproofLastMetaProofStepMetastatementNodeQuery(metaSubproofNode),
+              metaSubproofMetastatementNodes = [
+                ...metaSubproofMetaSuppositionMetastatementNodes,
+                metaSubproofLastMetaProofStepMetastatementNode
+              ],
+              subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
+
+        metaSubproofNodeMatches = match(subproofAssertionMetastatementNodes, metaSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
+          const nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
+                nonTerminalNodeB = ruleSubproofMetastatementNode, ///
                 fileContextA = fileContext, ///
                 localMetaContextA = LocalMetaContext.fromFileContext(fileContextA),
                 localMetaContextB = localMetaContext,  ///
@@ -62,44 +65,62 @@ export default class MetaSupposition {
   }
 
   matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext) {
-    const nonTerminalNodeA = this.metastatementNode,  ///
-          nonTerminalNodeB = metastatementNode,  ///
-          fileContextA = fileContext, ///
-          localMetaContextA = LocalMetaContext.fromFileContext(fileContextA),
-          localMetaContextB = localMetaContext,  ///
-          nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, () => {
-            const verifiedAhead = true;
-
-            return verifiedAhead;
-          }),
-          metastatementNodeMatches = nonTerminalNodeVerified; ///
+    let metastatementNodeMatches = false;
+
+    if (this.metastatementNode !== null) {
+      const nonTerminalNodeA = this.metastatementNode,  ///
+            nonTerminalNodeB = metastatementNode,  ///
+            fileContextA = fileContext, ///
+            localMetaContextA = LocalMetaContext.fromFileContext(fileContextA),
+            localMetaContextB = localMetaContext,  ///
+            nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, () => {
+              const verifiedAhead = true;
+
+              return verifiedAhead;
+            });
+
+      metastatementNodeMatches = nonTerminalNodeVerified; ///
+    }
 
     return metastatementNodeMatches;
   }
 
   toJSON(tokens) {
     const metastatementString = nodeAsString(this.metastatementNode, tokens),
+          statementString = nodeAsString(this.statementNode, tokens),
           metastatement = metastatementString, ///
+          statement = statementString, ///
           json = {
-            metastatement
+            metastatement,
+            statement
           };
 
     return json;
   }
 
   static fromMetastatementNode(metastatementNode) {
-    const metaSupposition = new MetaSupposition(metastatementNode);
+    const statementNode = null,
+          metaSupposition = new MetaSupposition(metastatementNode, statementNode);
+
+    return metaSupposition;
+  }
+
+  static fromStatementNode(statementNode) {
+    const metastatementNode = null,
+          metaSupposition = new MetaSupposition(metastatementNode, statementNode);
 
     return metaSupposition;
   }
 
   static fromJSONAndFileContext(json, fileContext) {
-    const { metastatement } = json,
+    const { metastatement, statement } = json,
           metastatementString = metastatement,  ///
+          statementString = statement,  ///
           lexer = fileContext.getLexer(),
           parser = fileContext.getParser(),
           metastatementNode = metastatementNodeFromMetastatementString(metastatementString, lexer, parser),
-          metaSupposition = new MetaSupposition(metastatementNode);
+          statementNode = statementNodeFromStatementString(statementString, lexer, parser),
+          metaSupposition = new MetaSupposition(metastatementNode, statementNode);
 
     return metaSupposition;
   }

package/src/premise.js

@@ -8,55 +8,104 @@ import intrinsicLevelAgainstMetaLevelNodesVerifier from "./verifier/nodes/intrin
 import { match } from "./utilities/array";
 import { nodeAsString } from "./utilities/string";
 import { nodeQuery, nodesQuery } from "./utilities/query";
-import { metastatementNodeFromMetastatementString } from "./utilities/node";
+import { statementNodeFromStatementString, metastatementNodeFromMetastatementString } from "./utilities/node";
 
 const subproofAssertionNodeQuery = nodeQuery("/metastatement/subproofAssertion!"),
+      subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement!/statement!"),
+      subproofLastProofStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/lastProofStep/unqualifiedStatement|qualifiedStatement/statement!"),
       subproofAssertionMetastatementNodesQuery = nodesQuery("/subproofAssertion/metastatement"),
       ruleSubproofPremiseMetastatementNodesQuery = nodesQuery("/ruleSubproof/premise/unqualifiedMetastatement!/metastatement!"),
-      ruleSubproofLastRuleProofStepMetastatementNodeQuery = nodeQuery("/ruleSubproof/ruleSubDerivation/lastRuleProofStep/unqualifiedMetastatement|qualifiedMetastatement/metastatement!");
+      metaSubproofMetaSuppositionMetastatementNodesQuery = nodesQuery("/metaSubproof/metaSupposition/unqualifiedMetastatement!/metastatement!"),
+      ruleSubproofLastRuleProofStepMetastatementNodeQuery = nodeQuery("/ruleSubproof/ruleSubDerivation/lastRuleProofStep/unqualifiedMetastatement|qualifiedMetastatement/metastatement!"),
+      metaSubproofLastMetaProofStepMetastatementNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation/lastMetaProofStep/unqualifiedMetastatement|qualifiedMetastatement/metastatement!");
 
 export default class Premise {
-  constructor(metastatementNode) {
+  constructor(metastatementNode, statementNode) {
     this.metastatementNode = metastatementNode;
+    this.statementnode = statementNode;
   }
 
   getMetastatementNode() {
     return this.metastatementNode;
   }
 
-  matchStatementNode(statementNode, substitutions, fileContext, statementLocalContext) {
-    const nonTerminalNodeA = this.metastatementNode,  ///
-          nonTerminalNodeB = statementNode,  ///
-          fileContextA = fileContext, ///
-          localContextA = LocalContext.fromFileContext(fileContextA),
-          localContextB = statementLocalContext,  ///
-          nonTerminalNodeVerified = intrinsicLevelAgainstMetaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
-            const verifiedAhead = true;
+  getStatementNode() {
+    return this.statementnode;
+  }
+
+  matchStatementNode(statementNode, substitutions, fileContext, localContext) {
+    let statementNodeMatches = false;
 
-            return verifiedAhead;
-          }),
-          statementNodeMatches = nonTerminalNodeVerified; ///
+    if (this.metastatementNode !== null) {
+      const nonTerminalNodeA = this.metastatementNode,  ///
+            nonTerminalNodeB = statementNode,  ///
+            fileContextA = fileContext, ///
+            localContextA = LocalContext.fromFileContext(fileContextA),
+            localContextB = localContext,  ///
+            nonTerminalNodeVerified = intrinsicLevelAgainstMetaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+              const verifiedAhead = true;
+
+              return verifiedAhead;
+            });
+
+      statementNodeMatches = nonTerminalNodeVerified; ///
+    }
 
     return statementNodeMatches;
   }
 
+  matchSubproofNode(subproofNode, substitutions, fileContext, localContext) {
+    let subproofNodeMatches = false;
+
+    if (this.metastatementNode !== null) {
+      const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
+
+      if (subproofAssertionNode !== null) {
+        const subproofSuppositionStatementNodes = subproofSuppositionStatementNodesQuery(subproofNode),
+              subproofLastProofStepStatementNode = subproofLastProofStepStatementNodeQuery(subproofNode),
+              subproofStatementNodes = [
+                ...subproofSuppositionStatementNodes,
+                subproofLastProofStepStatementNode
+              ],
+              subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
+
+        subproofNodeMatches = match(subproofAssertionMetastatementNodes, subproofStatementNodes, (subproofAssertionMetastatementNode, subproofStatementNode) => {
+          const nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
+                nonTerminalNodeB = subproofStatementNode, ///
+                fileContextA = fileContext, ///
+                localContextA = LocalMetaContext.fromFileContext(fileContextA),
+                localContextB = localContext,  ///
+                nonTerminalNodeVerified = intrinsicLevelAgainstMetaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+                  const verifiedAhead = true;
+
+                  return verifiedAhead;
+                });
+
+          if (nonTerminalNodeVerified) {
+            return true;
+          }
+        });
+      }
+    }
+
+    return subproofNodeMatches;
+  }
+
   matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, localMetaContext) {
     let ruleSubproofNodeMatches = false;
 
-    const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
+    if (this.metastatementNode !== null) {
+      const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
 
-    if (subproofAssertionNode !== null) {
-      const ruleSubproofPremiseMetastatementNodes = ruleSubproofPremiseMetastatementNodesQuery(ruleSubproofNode),
-            ruleSubproofLastRuleProofStepMetastatementNode = ruleSubproofLastRuleProofStepMetastatementNodeQuery(ruleSubproofNode),
-            ruleSubproofMetastatementNodes = [
-              ...ruleSubproofPremiseMetastatementNodes,
-              ruleSubproofLastRuleProofStepMetastatementNode
-            ],
-            ruleSubproofMetastatementNodesLength = ruleSubproofMetastatementNodes.length,
-            subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode),
-            subproofAssertionMetastatementNodesLength = subproofAssertionMetastatementNodes.length;
+      if (subproofAssertionNode !== null) {
+        const ruleSubproofPremiseMetastatementNodes = ruleSubproofPremiseMetastatementNodesQuery(ruleSubproofNode),
+              ruleSubproofLastRuleProofStepMetastatementNode = ruleSubproofLastRuleProofStepMetastatementNodeQuery(ruleSubproofNode),
+              ruleSubproofMetastatementNodes = [
+                ...ruleSubproofPremiseMetastatementNodes,
+                ruleSubproofLastRuleProofStepMetastatementNode
+              ],
+              subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
 
-      if (ruleSubproofMetastatementNodesLength === subproofAssertionMetastatementNodesLength) {
         ruleSubproofNodeMatches = match(subproofAssertionMetastatementNodes, ruleSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
           const nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = ruleSubproofMetastatementNode, ///
@@ -79,45 +128,100 @@ export default class Premise {
     return ruleSubproofNodeMatches;
   }
 
+  matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext) {
+    let metaSubproofNodeMatches = false;
+
+    if (this.metastatementNode !== null) {
+      const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
+
+      if (subproofAssertionNode !== null) {
+        const metaSubproofMetaSuppositionMetastatementNodes = metaSubproofMetaSuppositionMetastatementNodesQuery(metaSubproofNode),
+              metaSubproofLastMetaProofStepMetastatementNode = metaSubproofLastMetaProofStepMetastatementNodeQuery(metaSubproofNode),
+              metaSubproofMetastatementNodes = [
+                ...metaSubproofMetaSuppositionMetastatementNodes,
+                metaSubproofLastMetaProofStepMetastatementNode
+              ],
+              subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
+
+        metaSubproofNodeMatches = match(subproofAssertionMetastatementNodes, metaSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
+          const nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
+                nonTerminalNodeB = ruleSubproofMetastatementNode, ///
+                fileContextA = fileContext, ///
+                localMetaContextA = LocalMetaContext.fromFileContext(fileContextA),
+                localMetaContextB = localMetaContext,  ///
+                nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, () => {
+                  const verifiedAhead = true;
+
+                  return verifiedAhead;
+                });
+
+          if (nonTerminalNodeVerified) {
+            return true;
+          }
+        });
+      }
+    }
+
+    return metaSubproofNodeMatches;
+  }
+
   matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext) {
-    const nonTerminalNodeA = this.metastatementNode,  ///
-          nonTerminalNodeB = metastatementNode,  ///
-          fileContextA = fileContext, ///
-          localMetaContextA = LocalMetaContext.fromFileContext(fileContextA),
-          localMetaContextB = localMetaContext,  ///
-          nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, () => {
-            const verifiedAhead = true;
-
-            return verifiedAhead;
-          }),
-          metastatementNodeMatches = nonTerminalNodeVerified; ///
+    let metastatementNodeMatches = false;
+
+    if (this.metastatementNode !== null) {
+      const nonTerminalNodeA = this.metastatementNode,  ///
+            nonTerminalNodeB = metastatementNode,  ///
+            fileContextA = fileContext, ///
+            localMetaContextA = LocalMetaContext.fromFileContext(fileContextA),
+            localMetaContextB = localMetaContext,  ///
+            nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, () => {
+              const verifiedAhead = true;
+
+              return verifiedAhead;
+            });
+
+      metastatementNodeMatches = nonTerminalNodeVerified; ///
+    }
 
     return metastatementNodeMatches;
   }
 
   toJSON(tokens) {
     const metastatementString = nodeAsString(this.metastatementNode, tokens),
+          statementString = nodeAsString(this.statementnode, tokens),
           metastatement = metastatementString, ///
+          statement = metastatement,  ///
           json = {
-            metastatement
+            metastatement,
+            statement
           };
 
     return json;
   }
 
   static fromJSONAndFileContext(json, fileContext) {
-    const { metastatement } = json,
+    const { metastatement, statement } = json,
           metastatementString = metastatement,  ///
+          statementString = statement, ///
           lexer = fileContext.getLexer(),
           parser = fileContext.getParser(),
           metastatementNode = metastatementNodeFromMetastatementString(metastatementString, lexer, parser),
-          premise = new Premise(metastatementNode);
+          statementNode = statementNodeFromStatementString(statementString, lexer, parser),
+          premise = new Premise(metastatementNode, statementNode);
 
     return premise;
   }
 
   static fromMetastatementNode(metastatementNode) {
-    const premise = new Premise(metastatementNode);
+    const statementNode = null,
+          premise = new Premise(metastatementNode, statementNode);
+
+    return premise;
+  }
+
+  static fromStatementNode(statementNode) {
+    const metastatementNode = null,
+          premise = new Premise(metastatementNode, statementNode);
 
     return premise;
   }

package/src/rule.js

@@ -4,9 +4,8 @@ import Label from "./label";
 import Premise from "./premise";
 import Conclusion from "./conclusion";
 
-import { prune } from "./utilities/array";
+import { extract } from "./utilities/array";
 import { someSubArray } from "./utilities/array";
-import local from "./context/local";
 
 export default class Rule {
   constructor(labels, premises, conclusion, fileContext) {
@@ -35,25 +34,24 @@ export default class Rule {
   matchStatement(statementNode, localContext) {
     let statementNatches;
 
-    const premisesLength = this.premises.length,
-          statementLocalContext = localContext; ///
+    const premisesLength = this.premises.length;
 
     if (premisesLength === 0) {
       const substitutions = [],
-            conclusionMatches = matchConclusion(this.conclusion, statementNode, substitutions, this.fileContext, statementLocalContext);
+            conclusionMatches = matchConclusion(this.conclusion, statementNode, substitutions, this.fileContext, localContext);
 
       statementNatches = conclusionMatches; ///
     } else {
-      const proofSteps = statementLocalContext.getProofSteps();
+      const proofSteps = localContext.getProofSteps();
 
       statementNatches = someSubArray(proofSteps, premisesLength, (proofSteps) => {
         let premisesMatchConclusion = false;
 
         const substitutions = [],
-              premisesMatch = matchPremises(this.premises, proofSteps, substitutions, this.fileContext, statementLocalContext);
+              premisesMatch = matchPremises(this.premises, proofSteps, substitutions, this.fileContext, localContext);
 
         if (premisesMatch) {
-          const conclusionMatches = matchConclusion(this.conclusion, statementNode, substitutions, this.fileContext, statementLocalContext);
+          const conclusionMatches = matchConclusion(this.conclusion, statementNode, substitutions, this.fileContext, localContext);
 
           premisesMatchConclusion = conclusionMatches;  ///
         }
@@ -182,14 +180,23 @@ export default class Rule {
   }
 }
 
-function matchPremise(premise, proofSteps, substitutions, fileContext, statementLocalContext) {
-  const proofStep = prune(proofSteps, (proofStep) => {
-    const statementNode = proofStep.getStatementNode()
+function matchPremise(premise, proofSteps, substitutions, fileContext, localContext) {
+  const proofStep = extract(proofSteps, (proofStep) => {
+    const subproofNode = proofStep.getSubproofNode(),
+          statementNode = proofStep.getStatementNode();
+
+    if (subproofNode !== null) {
+      const subproofNodeMatches = premise.matchSubproofNode(subproofNode, substitutions, fileContext, localContext);
+
+      if (subproofNodeMatches) {
+        return true;
+      }
+    }
 
     if (statementNode !== null) {
-      const statementNodeMatches = premise.matchStatementNode(statementNode, substitutions, fileContext, statementLocalContext);
+      const statementNodeMatches = premise.matchStatementNode(statementNode, substitutions, fileContext, localContext);
 
-      if (!statementNodeMatches) {  ///
+      if (statementNodeMatches) {
         return true;
       }
     }
@@ -200,9 +207,9 @@ function matchPremise(premise, proofSteps, substitutions, fileContext, statement
   return premiseMatches;
 }
 
-function matchPremises(premise, proofSteps, substitutions, fileContext, statementLocalContext) {
+function matchPremises(premise, proofSteps, substitutions, fileContext, localContext) {
   const premisesMatch = premise.every((premise) => {
-    const premiseMatches = matchPremise(premise, proofSteps, substitutions, fileContext, statementLocalContext);
+    const premiseMatches = matchPremise(premise, proofSteps, substitutions, fileContext, localContext);
 
     if (premiseMatches) {
       return true;
@@ -212,22 +219,31 @@ function matchPremises(premise, proofSteps, substitutions, fileContext, statemen
   return premisesMatch;
 }
 
-function matchConclusion(conclusion, statementNode, substitutions, fileContext, statementLocalContext) {
-  const statementNodeMatches = conclusion.matchStatementNode(statementNode, substitutions, fileContext, statementLocalContext),
+function matchConclusion(conclusion, statementNode, substitutions, fileContext, localContext) {
+  const statementNodeMatches = conclusion.matchStatementNode(statementNode, substitutions, fileContext, localContext),
         conclusionMatches = statementNodeMatches; ///
 
   return conclusionMatches;
 }
 
 function metaMatchPremise(premise, metaproofSteps, substitutions, fileContext, localMetaContext) {
-  const metaproofStep = prune(metaproofSteps, (metaproofStep) => {
+  const metaproofStep = extract(metaproofSteps, (metaproofStep) => {
     const ruleSubproofNode = metaproofStep.getRuleSubproofNode(),
+          metaSubproofNode = metaproofStep.getMetaSubproofNode(),
           metastatementNode = metaproofStep.getMetastatementNode()
 
     if (ruleSubproofNode !== null) {
       const ruleSubProofNodeMatches = premise.matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, localMetaContext);
 
-      if (!ruleSubProofNodeMatches) {  ///
+      if (ruleSubProofNodeMatches) {
+        return true;
+      }
+    }
+
+    if (metaSubproofNode !== null) {
+      const metaSubProofNodeMatches = premise.matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext);
+
+      if (metaSubProofNodeMatches) {
         return true;
       }
     }
@@ -235,7 +251,7 @@ function metaMatchPremise(premise, metaproofSteps, substitutions, fileContext, l
     if (metastatementNode !== null) {
       const metastatementNodeMatches = premise.matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext);
 
-      if (!metastatementNodeMatches) {  ///
+      if (metastatementNodeMatches) {
         return true;
       }
     }

package/src/step/metaproof.js

@@ -9,12 +9,17 @@ const metastatementNodesQuery = nodesQuery("/subproofAssertion/metastatement"),
       qualifiedOrUnqualifiedMetastatementMetastatementNodesQuery = nodesQuery("/ruleSubproof/qualifiedMetastatement|unqualifiedMetastatement/metastatement!");
 
 export default class MetaproofStep {
-  constructor(ruleSubproofNode, metaSubproofNode, metastatementNode) {
+  constructor(statementNode, ruleSubproofNode, metaSubproofNode, metastatementNode) {
+    this.statementNode = statementNode;
     this.ruleSubproofNode = ruleSubproofNode;
     this.metaSubproofNode = metaSubproofNode;
     this.metastatementNode = metastatementNode;
   }
 
+  getStatementNode() {
+    return this.statementNode;
+  }
+
   getRuleSubproofNode() {
     return this.ruleSubproofNode;
   }
@@ -90,27 +95,39 @@ export default class MetaproofStep {
     return ruleSubproofAssertionMatches;
   }
 
+  static fromStatementNode(statementNode) {
+    const ruleSubproofNode = null,
+          metaSubproofNode = null,
+          metastatementNode = null,
+          metaProofStep = new MetaproofStep(statementNode, ruleSubproofNode, metaSubproofNode, metastatementNode);
+
+    return metaProofStep;
+  }
+
   static fromRuleSubproofNode(ruleSubproofNode) {
-    const metaSubproofNode = null,
+    const statementNode = null,
+          metaSubproofNode = null,
           metastatementNode = null,
-          metaProofStep = new MetaproofStep(ruleSubproofNode, metaSubproofNode, metastatementNode);
+          metaProofStep = new MetaproofStep(statementNode, ruleSubproofNode, metaSubproofNode, metastatementNode);
 
     return metaProofStep;
   }
 
   static fromMetaSubproofNode(metaSubproofNode) {
-    const ruleSubproofNode = null,
+    const statementNode = null,
+          ruleSubproofNode = null,
           metastatementNode = null,
-          metaProofStep = new MetaproofStep(ruleSubproofNode, metaSubproofNode, metastatementNode);
+          metaProofStep = new MetaproofStep(statementNode, ruleSubproofNode, metaSubproofNode, metastatementNode);
 
     return metaProofStep;
 
   }
 
   static fromMetastatementNode(metastatementNode) {
-    const ruleSubproofNode = null,
+    const statementNode = null,
+          ruleSubproofNode = null,
           metaSubproofNode = null,
-          metaProofStep = new MetaproofStep(ruleSubproofNode, metaSubproofNode, metastatementNode);
+          metaProofStep = new MetaproofStep(statementNode, ruleSubproofNode, metaSubproofNode, metastatementNode);
 
     return metaProofStep;
   }

package/src/utilities/array.js

@@ -6,7 +6,7 @@ import permutationsMatrix from "../permutationsMatrix";
 
 import { MAXIMUM_INDEXES_LENGTH, MAXIMUM_PERMUTATION_LENGTH } from "../constants";
 
-export const { first, second, last, push, prune, match, filter, compress, separate } = arrayUtilities;
+export const { first, second, last, push, prune, extract, match, filter, compress, separate } = arrayUtilities;
 
 export function someSubArray(array, subArrayLength, callback) {
   let found = false;