occam-verify-cli 0.0.892 → 0.0.894

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.892",
+  "version": "0.0.894",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",
@@ -12,9 +12,9 @@
   "dependencies": {
     "argumentative": "^2.0.28",
     "necessary": "^14.0.1",
-    "occam-custom-grammars": "^5.0.801",
-    "occam-entities": "^1.0.142",
-    "occam-file-system": "^6.0.183",
+    "occam-custom-grammars": "^5.0.803",
+    "occam-entities": "^1.0.144",
+    "occam-file-system": "^6.0.185",
     "occam-grammar-utilities": "^8.0.207",
     "occam-query": "^3.1.174"
   },

package/src/axiomLemmaTheoremConjecture.js

@@ -5,7 +5,7 @@ import Consequent from "./consequent";
 import Supposition from "./supposition";
 import LocalContext from "./context/local";
 
-import { prune } from "./utilities/array";
+import { extract } from "./utilities/array";
 import { someSubArray } from "./utilities/array";
 
 export default class AxiomLemmaTheoremConjecture {
@@ -32,10 +32,11 @@ export default class AxiomLemmaTheoremConjecture {
     return this.localContext;
   }
 
-  matchStatement(statementNode, statementLocalContext) {
+  matchStatement(statementNode, localContext) {
     let statementNatches;
 
-    const suppositionsLength = this.suppositions.length;
+    const suppositionsLength = this.suppositions.length,
+          statementLocalContext = localContext; ///
 
     if (suppositionsLength === 0) {
       const substitutions = [],
@@ -147,13 +148,13 @@ export default class AxiomLemmaTheoremConjecture {
 }
 
 function matchSupposition(supposition, proofSteps, substitutions, localContext, statementLocalContext) {
-  const proofStep = prune(proofSteps, (proofStep) => {
+  const proofStep = extract(proofSteps, (proofStep) => {
     const statementNode = proofStep.getStatementNode();
 
     if (statementNode !== null) {
       const statementMatches = supposition.matchStatementNode(statementNode, substitutions, localContext, statementLocalContext);
 
-      if (!statementMatches) {  ///
+      if (statementMatches) {
         return true;
       }
     }

package/src/conclusion.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import LocalMetaContext from "./context/localMeta";
 import metaLevelNodesVerifier from "./verifier/nodes/metaLevel";
 import intrinsicLevelAgainstMetaLevelNodesVerifier from "./verifier/nodes/intrinsicLevelAgainstMetaLevel";
 
@@ -30,12 +31,13 @@ export default class Conclusion {
     return statementNodeMatches;
   }
 
-  matchMetastatementNode(metastatementNode, substitutions, localContext, metastatementLocalMetaContext) {
+  matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = metastatementNode,  ///
-          localContextA = localContext, ///
-          localMetaContextB = metastatementLocalMetaContext,  ///
-          nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localMetaContextB, () => {
+          fileContextA = fileContext, ///
+          localMetaContextA = LocalMetaContext.fromFileContext(fileContextA),
+          localMetaContextB = localMetaContext,  ///
+          nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;

package/src/metaConsequent.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import LocalMetaContext from "./context/localMeta";
 import metaLevelNodesVerifier from "./verifier/nodes/metaLevel";
 
 import { nodeAsString } from "./utilities/string";
@@ -14,12 +15,13 @@ export default class MetaConsequent {
     return this.metastatementNode;
   }
 
-  matchMetastatementNode(metastatementNode, substitutions, localContext, metastatementLocalContext) {
+  matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = metastatementNode,  ///
-          localContextA = localContext, ///
-          localContextB = metastatementLocalContext, ///
-          nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+          fileContextA = fileContext, ///
+          localMetaContextA = LocalMetaContext.fromFileContext(fileContextA),
+          localMetaContextB = localMetaContext, ///
+          nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;

package/src/metaLemmaMetatheorem.js

@@ -5,7 +5,7 @@ import MetaConsequent from "./metaConsequent";
 import MetaSupposition from "./metaSupposition";
 import MetastatementForMetavariableSubstitution from "./substitution/metastatementForMetavariable";
 
-import { prune } from "./utilities/array";
+import { extract } from "./utilities/array";
 import { someSubArray } from "./utilities/array";
 
 export default class MetaLemmaMetatheorem {
@@ -37,27 +37,27 @@ export default class MetaLemmaMetatheorem {
     return this.fileContext;
   }
 
-  matchMetastatement(metastatementNode, metastatementLocalContext) {
+  matchMetastatement(metastatementNode, localMetaContext) {
     let metastatementNatches;
 
     const metaSuppositionsLength = this.metaSuppositions.length;
 
     if (metaSuppositionsLength === 0) {
       const substitutions = [],
-            metaConsequentMatches = matchMetaConsequent(this.metaConsequent, metastatementNode, substitutions, this.fileContext, metastatementLocalContext);
+            metaConsequentMatches = matchMetaConsequent(this.metaConsequent, metastatementNode, substitutions, this.fileContext, localMetaContext);
 
       metastatementNatches = metaConsequentMatches; ///
     } else {
-      const metaproofSteps = metastatementLocalContext.getProofSteps();
+      const metaproofSteps = localMetaContext.getProofSteps();
 
       metastatementNatches = someSubArray(metaproofSteps, metaSuppositionsLength, (metaproofSteps) => {
         let metaSuppositionsMatchMetaConsequent = false;
 
         const substitutions = [],
-              metaSuppositionsMatch = matchMetaSuppositions(this.metaSuppositions, metaproofSteps, substitutions, this.fileContext, metastatementLocalContext);
+              metaSuppositionsMatch = matchMetaSuppositions(this.metaSuppositions, metaproofSteps, substitutions, this.fileContext, localMetaContext);
 
         if (metaSuppositionsMatch) {
-          const metaConsequentMatches = matchMetaConsequent(this.metaConsequent, metastatementNode, substitutions, this.fileContext, metastatementLocalContext);
+          const metaConsequentMatches = matchMetaConsequent(this.metaConsequent, metastatementNode, substitutions, this.fileContext, localMetaContext);
 
           metaSuppositionsMatchMetaConsequent = metaConsequentMatches;  ///
         }
@@ -162,23 +162,23 @@ export default class MetaLemmaMetatheorem {
   static fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(Class, labels, metaSuppositions, metaConsequent, substitutions, fileContext) { return new Class(labels, metaSuppositions, metaConsequent, substitutions, fileContext); }
 }
 
-function matchMetaSupposition(metaSupposition, metaproofSteps, substitutions, fileContext, metastatementLocalContext) {
-  const metaproofStep = prune(metaproofSteps, (metaproofStep) => {
+function matchMetaSupposition(metaSupposition, metaproofSteps, substitutions, fileContext, localMetaContext) {
+  const metaproofStep = extract(metaproofSteps, (metaproofStep) => {
     const metaSubproofNode = metaproofStep.getMetaSubproofNode(),
           metastatementNode = metaproofStep.getMetastatementNode();
 
     if (metaSubproofNode !== null) {
-      const metaSubProofMatches = metaSupposition.matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, metastatementLocalContext);
+      const metaSubProofMatches = metaSupposition.matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext);
 
-      if (!metaSubProofMatches) {  ///
+      if (metaSubProofMatches) {
         return true;
       }
     }
 
     if (metastatementNode !== null) {
-      const metastatementMatches = metaSupposition.matchMetastatementNode(metastatementNode, substitutions, fileContext, metastatementLocalContext);
+      const metastatementMatches = metaSupposition.matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext);
 
-      if (!metastatementMatches) {  ///
+      if (metastatementMatches) {
         return true;
       }
     }
@@ -189,9 +189,9 @@ function matchMetaSupposition(metaSupposition, metaproofSteps, substitutions, fi
   return metaSuppositionMatches;
 }
 
-function matchMetaSuppositions(metaSuppositions, metaproofSteps, substitutions, fileContext, metastatementLocalContext) {
+function matchMetaSuppositions(metaSuppositions, metaproofSteps, substitutions, fileContext, localMetaContext) {
   const metaSuppositionsMatch = metaSuppositions.every((metaSupposition) => {
-    const metaSuppositionMatches = matchMetaSupposition(metaSupposition, metaproofSteps, substitutions, fileContext, metastatementLocalContext);
+    const metaSuppositionMatches = matchMetaSupposition(metaSupposition, metaproofSteps, substitutions, fileContext, localMetaContext);
 
     if (metaSuppositionMatches) {
       return true;
@@ -201,8 +201,8 @@ function matchMetaSuppositions(metaSuppositions, metaproofSteps, substitutions,
   return metaSuppositionsMatch;
 }
 
-function matchMetaConsequent(metaConsequent, metastatementNode, substitutions, fileContext, metastatementLocalContext) {
-  const nonTerminalNodeMatches = metaConsequent.matchMetastatementNode(metastatementNode, substitutions, fileContext, metastatementLocalContext),
+function matchMetaConsequent(metaConsequent, metastatementNode, substitutions, fileContext, localMetaContext) {
+  const nonTerminalNodeMatches = metaConsequent.matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext),
         metaConsequentMatches = nonTerminalNodeMatches; ///
 
   return metaConsequentMatches;

package/src/metaSupposition.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import LocalMetaContext from "./context/localMeta";
 import metaLevelNodesVerifier from "./verifier/nodes/metaLevel";
 
 import { match } from "./utilities/array";
@@ -7,10 +8,10 @@ import { nodeAsString } from "./utilities/string";
 import { nodeQuery, nodesQuery } from "./utilities/query";
 import { 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) {
@@ -21,50 +22,48 @@ export default class MetaSupposition {
     return this.metastatementNode;
   }
 
-  matchMetaSubproofNode(metaSubproofNode, substitutions, localContext, metastatementLocalContext) {
+  matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext) {
     let metaSubproofNodeMatches = false;
 
-    const metaSubproofAssertionNode = metaSubproofAssertionNodeQuery(this.metastatementNode);
+    const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
 
-    if (metaSubproofAssertionNode !== null) {
+    if (subproofAssertionNode !== null) {
       const metaSubproofMetaSuppositionMetastatementNodes = metaSubproofMetaSuppositionMetastatementNodesQuery(metaSubproofNode),
-            metaSubproofSubDerivationLastMetastatementNode = metaSubproofSubDerivationLastMetastatementNodeQuery(metaSubproofNode),
+            metaSubproofLastMetaProofStepMetastatementNode = metaSubproofLastMetaProofStepMetastatementNodeQuery(metaSubproofNode),
             metaSubproofMetastatementNodes = [
               ...metaSubproofMetaSuppositionMetastatementNodes,
-              metaSubproofSubDerivationLastMetastatementNode
+              metaSubproofLastMetaProofStepMetastatementNode
             ],
-            metaSubproofAssertionMetastatementNodes = metaSubproofAssertionMetastatementNodesQuery(metaSubproofAssertionNode),
-            metaSubproofMetastatementNodesLength = metaSubproofMetastatementNodes.length,
-            metaSubproofAssertionMetastatementNodesLength = metaSubproofAssertionMetastatementNodes.length;
-
-      if (metaSubproofMetastatementNodesLength === metaSubproofAssertionMetastatementNodesLength) {
-        metaSubproofNodeMatches = match(metaSubproofAssertionMetastatementNodes, metaSubproofMetastatementNodes, (metaSubproofAssertionMetastatementNode, metaSubproofMetastatementNode) => {
-          const nonTerminalNodeA = metaSubproofAssertionMetastatementNode,  ///
-                nonTerminalNodeB = metaSubproofMetastatementNode, ///
-                localContextA = localContext, ///
-                localContextB = metastatementLocalContext,  ///
-                nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
-                  const verifiedAhead = true;
-
-                  return verifiedAhead;
-                });
-
-          if (nonTerminalNodeVerified) {
-            return true;
-          }
-        });
-      }
+            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, localContext, metastatementLocalContext) {
+  matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = metastatementNode,  ///
-          localContextA = localContext, ///
-          localContextB = metastatementLocalContext,  ///
-          nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+          fileContextA = fileContext, ///
+          localMetaContextA = LocalMetaContext.fromFileContext(fileContextA),
+          localMetaContextB = localMetaContext,  ///
+          nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;

package/src/premise.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import LocalContext from "./context/local";
+import LocalMetaContext from "./context/localMeta";
 import metaLevelNodesVerifier from "./verifier/nodes/metaLevel";
 import intrinsicLevelAgainstMetaLevelNodesVerifier from "./verifier/nodes/intrinsicLevelAgainstMetaLevel";
 
@@ -10,9 +11,13 @@ import { nodeQuery, nodesQuery } from "./utilities/query";
 import { metastatementNodeFromMetastatementString } from "./utilities/node";
 
 const subproofAssertionNodeQuery = nodeQuery("/metastatement/subproofAssertion!"),
-      ruleSubproofPremiseMetastatementQuery = nodesQuery("/ruleSubproof/premise/unqualifiedMetastatement!/metastatement!"),
+      subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement!/statement!"),
+      subproofLastProofStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/lastProofStep/unqualifiedStatement|qualifiedStatement/statement!"),
       subproofAssertionMetastatementNodesQuery = nodesQuery("/subproofAssertion/metastatement"),
-      ruleSubproofSubDerivationLastMetastatementQuery = nodeQuery("/ruleSubproof/ruleSubDerivation/qualifiedMetastatement|unqualifiedMetastatement[-1]/metastatement!");
+      ruleSubproofPremiseMetastatementNodesQuery = nodesQuery("/ruleSubproof/premise/unqualifiedMetastatement!/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) {
@@ -23,12 +28,12 @@ export default class Premise {
     return this.metastatementNode;
   }
 
-  matchStatementNode(statementNode, substitutions, fileContext, statementLocalContext) {
+  matchStatementNode(statementNode, substitutions, fileContext, localContext) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = statementNode,  ///
           fileContextA = fileContext, ///
           localContextA = LocalContext.fromFileContext(fileContextA),
-          localContextB = statementLocalContext,  ///
+          localContextB = localContext,  ///
           nonTerminalNodeVerified = intrinsicLevelAgainstMetaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
             const verifiedAhead = true;
 
@@ -39,52 +44,118 @@ export default class Premise {
     return statementNodeMatches;
   }
 
-  matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, metastatementLocalMetaContext) {
+  matchSubproofNode(subproofNode, substitutions, fileContext, localContext) {
+    let subproofNodeMatches = false;
+
+    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 (subproofAssertionNode !== null) {
-      const ruleSubproofPremiseMetastatement = ruleSubproofPremiseMetastatementQuery(ruleSubproofNode),
-            ruleSubproofSubDerivationLastMetastatement = ruleSubproofSubDerivationLastMetastatementQuery(ruleSubproofNode),
+      const ruleSubproofPremiseMetastatementNodes = ruleSubproofPremiseMetastatementNodesQuery(ruleSubproofNode),
+            ruleSubproofLastRuleProofStepMetastatementNode = ruleSubproofLastRuleProofStepMetastatementNodeQuery(ruleSubproofNode),
             ruleSubproofMetastatementNodes = [
-              ...ruleSubproofPremiseMetastatement,
-              ruleSubproofSubDerivationLastMetastatement
+              ...ruleSubproofPremiseMetastatementNodes,
+              ruleSubproofLastRuleProofStepMetastatementNode
             ],
-            ruleSubproofMetastatementNodesLength = ruleSubproofMetastatementNodes.length,
-            subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode),
-            subproofAssertionMetastatementNodesLength = subproofAssertionMetastatementNodes.length;
-
-      if (ruleSubproofMetastatementNodesLength === subproofAssertionMetastatementNodesLength) {
-        ruleSubproofNodeMatches = match(subproofAssertionMetastatementNodes, ruleSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
-          const nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
-                nonTerminalNodeB = ruleSubproofMetastatementNode, ///
-                fileContextA = fileContext, ///
-                localContextA = LocalContext.fromFileContext(fileContextA),
-                localMetaContextB = metastatementLocalMetaContext,  ///
-                nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localMetaContextB, () => {
-                  const verifiedAhead = true;
-
-                  return verifiedAhead;
-                });
-
-          if (nonTerminalNodeVerified) {
-            return true;
-          }
-        });
-      }
+            subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
+
+      ruleSubproofNodeMatches = match(subproofAssertionMetastatementNodes, ruleSubproofMetastatementNodes, (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 ruleSubproofNodeMatches;
   }
 
-  matchMetastatementNode(metastatementNode, substitutions, fileContext, metastatementLocalMetaContext) {
+  matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext) {
+    let metaSubproofNodeMatches = false;
+
+    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, ///
-          localContextA = LocalContext.fromFileContext(fileContextA),
-          localMetaContextB = metastatementLocalMetaContext,  ///
-          nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localMetaContextB, () => {
+          localMetaContextA = LocalMetaContext.fromFileContext(fileContextA),
+          localMetaContextB = localMetaContext,  ///
+          nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;