occam-verify-cli 0.0.892 → 0.0.894

package/src/rule.js

@@ -4,7 +4,7 @@ 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";
 
 export default class Rule {
@@ -31,27 +31,27 @@ export default class Rule {
     return this.fileContext;
   }
 
-  matchStatement(statementNode, statementLocalContext) {
+  matchStatement(statementNode, localContext) {
     let statementNatches;
 
     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;  ///
         }
@@ -65,27 +65,27 @@ export default class Rule {
     return statementNatches;
   }
 
-  matchMetastatement(metastatementNode, metastatementLocalMetaContext) {
+  matchMetastatement(metastatementNode, localMetaContext) {
     let metastatementNatches;
 
     const premisesLength = this.premises.length;
 
     if (premisesLength === 0) {
       const substitutions = [],
-            conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, substitutions, this.fileContext, metastatementLocalMetaContext);
+            conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, substitutions, this.fileContext, localMetaContext);
 
       metastatementNatches = conclusionMatches; ///
     } else {
-      const metaproofSteps = metastatementLocalMetaContext.getMetaproofSteps();
+      const metaproofSteps = localMetaContext.getMetaproofSteps();
 
       metastatementNatches = someSubArray(metaproofSteps, premisesLength, (metaproofSteps) => {
         let premisesMatchConclusion = false;
 
         const substitutions = [],
-              premisesMatch = metaMatchPremises(this.premises, metaproofSteps, substitutions, this.fileContext, metastatementLocalMetaContext);
+              premisesMatch = metaMatchPremises(this.premises, metaproofSteps, substitutions, this.fileContext, localMetaContext);
 
         if (premisesMatch) {
-          const conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, substitutions, this.fileContext, metastatementLocalMetaContext);
+          const conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, substitutions, this.fileContext, localMetaContext);
 
           premisesMatchConclusion = conclusionMatches;  ///
         }
@@ -180,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;
       }
     }
@@ -198,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;
@@ -210,30 +219,39 @@ 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, metastatementLocalMetaContext) {
-  const metaproofStep = prune(metaproofSteps, (metaproofStep) => {
+function metaMatchPremise(premise, metaproofSteps, substitutions, fileContext, localMetaContext) {
+  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, metastatementLocalMetaContext);
+      const ruleSubProofNodeMatches = premise.matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, localMetaContext);
+
+      if (ruleSubProofNodeMatches) {
+        return true;
+      }
+    }
+
+    if (metaSubproofNode !== null) {
+      const metaSubProofNodeMatches = premise.matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext);
 
-      if (!ruleSubProofNodeMatches) {  ///
+      if (metaSubProofNodeMatches) {
         return true;
       }
     }
 
     if (metastatementNode !== null) {
-      const metastatementNodeMatches = premise.matchMetastatementNode(metastatementNode, substitutions, fileContext, metastatementLocalMetaContext);
+      const metastatementNodeMatches = premise.matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext);
 
-      if (!metastatementNodeMatches) {  ///
+      if (metastatementNodeMatches) {
         return true;
       }
     }
@@ -244,9 +262,9 @@ function metaMatchPremise(premise, metaproofSteps, substitutions, fileContext, m
   return premiseMatches;
 }
 
-function metaMatchPremises(premise, metaproofSteps, substitutions, fileContext, metastatementLocalMetaContext) {
+function metaMatchPremises(premise, metaproofSteps, substitutions, fileContext, localMetaContext) {
   const premisesMatch = premise.every((premise) => {
-    const premiseMatches = metaMatchPremise(premise, metaproofSteps, substitutions, fileContext, metastatementLocalMetaContext);
+    const premiseMatches = metaMatchPremise(premise, metaproofSteps, substitutions, fileContext, localMetaContext);
 
     if (premiseMatches) {
       return true;
@@ -256,8 +274,8 @@ function metaMatchPremises(premise, metaproofSteps, substitutions, fileContext,
   return premisesMatch;
 }
 
-function metaMatchConclusion(conclusion, metastatementNode, substitutions, fileContext, metastatementLocalMetaContext) {
-  const metastatementNodeMatches = conclusion.matchMetastatementNode(metastatementNode, substitutions, fileContext, metastatementLocalMetaContext),
+function metaMatchConclusion(conclusion, metastatementNode, substitutions, fileContext, localMetaContext) {
+  const metastatementNodeMatches = conclusion.matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext),
         conclusionMatches = metastatementNodeMatches; ///
 
   return conclusionMatches;

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;

package/src/verifier/nodes/metaLevel.js

@@ -10,21 +10,21 @@ const metastatementNodeQuery = nodeQuery("/metastatement!"),
       metastatementMetavariableNodeQuery = nodeQuery("/metastatement/metavariable!");
 
 class MetaLevelNodesVerifier extends NodesVerifier {
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localMetaContextB, verifyAhead) {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead) {
     let nonTerminalNodeVerified;
 
     const nodeQueryMaps = [
       {
         nodeQueryA: metastatementMetavariableNodeQuery,
         nodeQueryB: metastatementNodeQuery,
-        verifyNodes: (nodeA, nodeB, substitutions, localContextA, localMetaContextB, verifyAhead) => {
+        verifyNodes: (nodeA, nodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const metastatementNodeB = nodeB, ///
                 metastatementMetavariableNodeA = nodeA, ///
                 metastatementMetavariableNodeVerifiedAgainstMetastatementNode =
 
-                  this.verifyMetastatementMetavariableNodeAgainstMetastatementNode(metastatementMetavariableNodeA, metastatementNodeB, substitutions, localContextA, localMetaContextB, verifyAhead);
+                  this.verifyMetastatementMetavariableNodeAgainstMetastatementNode(metastatementMetavariableNodeA, metastatementNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead);
 
           nonTerminalNodeVerified = metastatementMetavariableNodeVerifiedAgainstMetastatementNode;  ///
 
@@ -33,16 +33,16 @@ class MetaLevelNodesVerifier extends NodesVerifier {
       }
     ];
 
-    const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localMetaContextB, verifyAhead);
+    const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead);
 
     nonTerminalNodeVerified = nodesVerified ?
                                 true :
-                                  super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localMetaContextB, verifyAhead);
+                                  super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead);
 
     return nonTerminalNodeVerified;
   }
 
-  verifyMetastatementMetavariableNodeAgainstMetastatementNode(metastatementMetavariableNodeA, metastatementNodeB, substitutions, localContextA, localMetaContextB, verifyAhead) {
+  verifyMetastatementMetavariableNodeAgainstMetastatementNode(metastatementMetavariableNodeA, metastatementNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead) {
     let metastatementMetavariableNodeVerifiedAgainstMetastatementNode;
 
     const metavariableNode = metastatementMetavariableNodeA, ///

package/src/verify/derivation.js

@@ -1,151 +1,23 @@
 "use strict";
 
-import ProofStep from "../step/proof";
-import LocalContext from "../context/local";
-import verifySuppositions from "../verify/suppositions";
-import verifyQualifiedStatement from "../verify/statement/qualified";
-import verifyUnqualifiedStatement from "../verify/statement/unqualified";
+import verifyProofStep from "../verify/proofStep";
 
-import { assignAssignment } from "../utilities/assignments";
-import { nodeQuery, nodesQuery } from "../utilities/query";
-import { SUBPROOF_RULE_NAME, QUALIFIED_STATEMENT_RULE_NAME, UNQUALIFIED_STATEMENT_RULE_NAME } from "../ruleNames";
+import { nodesQuery } from "../utilities/query";
 
-const childNodesQuery = nodesQuery("/derivation|subDerivation/*"),
-      statementNodeQuery = nodeQuery("/qualifiedStatement|unqualifiedStatement/statement!"),
-      suppositionNodesQuery = nodesQuery("/subproof/supposition"),
-      subDerivationNodeQuery = nodeQuery("/subproof/subDerivation");
+const proofStepNodesQuery = nodesQuery("/derivation/proofStep|lastProofStep");
 
-export default function verifyDerivation(derivationNode, localContext) {
-  let derivationVerified;
+export default function verifyDerivation(ruleDerivationNode, localMetaContext) {
+  let ruleDerivationVerified;
 
-  const childNodes = childNodesQuery(derivationNode);
+  const proofStepNodes = proofStepNodesQuery(ruleDerivationNode);
 
-  derivationVerified = childNodes.every((childNode) => {
-    const childVerified = verifyChild(childNode, localContext);
+  ruleDerivationVerified = proofStepNodes.every((proofStepNode) => {
+    const proofStepVerified = verifyProofStep(proofStepNode, localMetaContext);
 
-    if (childVerified) {
+    if (proofStepVerified) {
       return true;
     }
   });
 
-  return derivationVerified;
-}
-
-function verifySubDerivation(subDerivationNode, localContext) {
-  let subDerivationVerified;
-
-  const childNodes = childNodesQuery(subDerivationNode);
-
-  subDerivationVerified = childNodes.every((childNode) => {
-    const childVerified = verifyChild(childNode, localContext);
-
-    if (childVerified) {
-      return true;
-    }
-  });
-
-  return subDerivationVerified;
-}
-
-function verifySubproof(subproofNode, localContext) {
-  let subproofVerified = false;
-
-  localContext = LocalContext.fromLocalContext(localContext); ///
-
-  const suppositions = [],
-        suppositionNodes = suppositionNodesQuery(subproofNode),
-        suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
-
-  if (suppositionsVerified) {
-    const subDerivationNode = subDerivationNodeQuery(subproofNode),
-          subDerivationVerified = verifySubDerivation(subDerivationNode, localContext);
-
-    if (subDerivationVerified) {
-      subproofVerified = true;
-    }
-  }
-
-  return subproofVerified;
-}
-
-function verifyChild(childNode, localContext) {
-  let childVerified = false;
-
-  const childNodeRuleName = childNode.getRuleName();
-
-  switch (childNodeRuleName) {
-    case SUBPROOF_RULE_NAME: {
-      let subproofVerified;
-
-      const subproofNode = childNode;  ///
-
-      subproofVerified = verifySubproof(subproofNode, localContext);
-
-      if (subproofVerified) {
-        const proofStep = ProofStep.fromSubproofNode(subproofNode);
-
-        localContext.addProofStep(proofStep);
-
-        childVerified = true;
-      }
-
-      break;
-    }
-
-    case QUALIFIED_STATEMENT_RULE_NAME: {
-      let qualifiedStatementVerified;
-
-      const derived = true,
-            assignments = [],
-            qualifiedStatementNode = childNode;  ///
-
-      qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, assignments, derived, localContext);
-
-      if (qualifiedStatementVerified) {
-        const assignmentAssigned = assignAssignment(assignments, localContext);
-
-        qualifiedStatementVerified = assignmentAssigned; ///
-      }
-
-      if (qualifiedStatementVerified) {
-        const statementNode = statementNodeQuery(qualifiedStatementNode),
-              proofStep = ProofStep.fromStatementNode(statementNode);
-
-        localContext.addProofStep(proofStep);
-
-        childVerified = true; ///
-      }
-
-      break;
-    }
-
-    case UNQUALIFIED_STATEMENT_RULE_NAME: {
-      let unqualifiedStatementVerified;
-
-      const derived = true,
-            assignments = [],
-            unqualifiedStatementNode = childNode;  ///
-
-      unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
-
-      if (unqualifiedStatementVerified) {
-        const assignmentAssigned = assignAssignment(assignments, localContext);
-
-        unqualifiedStatementVerified = assignmentAssigned;  ///
-      }
-
-      if (unqualifiedStatementVerified) {
-        const statementNode = statementNodeQuery(unqualifiedStatementNode),
-              proofStep = ProofStep.fromStatementNode(statementNode);
-
-        localContext.addProofStep(proofStep);
-
-        childVerified = true;
-      }
-
-      break;
-    }
-  }
-
-  return childVerified;
+  return ruleDerivationVerified;
 }

package/src/verify/metaDerivation.js

@@ -1,151 +1,23 @@
 "use strict";
 
-import MetaproofStep from "../step/metaproof";
-import LocalMetaContext from "../context/localMeta";
-import verifyMetaSuppositions from "../verify/metaSuppositions";
-import verifyQualifiedMetastatement from "../verify/metastatement/qualified";
-import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
+import verifyMetaProofStep from "../verify/metaProofStep";
 
-import { assignAssignment } from "../utilities/assignments";
-import { nodeQuery, nodesQuery } from "../utilities/query";
-import { META_SUBPROOF_RULE_NAME, QUALIFIED_METASTATEMENT_RULE_NAME, UNQUALIFIED_METASTATEMENT_RULE_NAME } from "../ruleNames";
+import { nodesQuery } from "../utilities/query";
 
-const childNodesQuery = nodesQuery("/metaDerivation|metaSubDerivation/*"),
-      metastatementNodeQuery = nodeQuery("/qualifiedMetastatement|unqualifiedMetastatement/metastatement!"),
-      metaSuppositionNodesQuery = nodesQuery("/metaSubproof/metaSupposition"),
-      metaSubDerivationNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation");
+const metaProofStepNodesQuery = nodesQuery("/metaDerivation/metaProofStep|lastMetaProofStep");
 
 export default function verifyMetaDerivation(metaDerivationNode, substitutions, localMetaContext) {
   let metaDerivationVerified;
 
-  const childNodes = childNodesQuery(metaDerivationNode);
+  const metaProofStepNodes = metaProofStepNodesQuery(metaDerivationNode);
 
-  metaDerivationVerified = childNodes.every((childNode) => {
-    const childVerified = verifyChild(childNode, substitutions, localMetaContext);
+  metaDerivationVerified = metaProofStepNodes.every((metaProofStepNode) => {
+    const metaProofStepVerified = verifyMetaProofStep(metaProofStepNode, substitutions, localMetaContext);
 
-    if (childVerified) {
+    if (metaProofStepVerified) {
       return true;
     }
   });
 
   return metaDerivationVerified;
 }
-
-function verifyMetaSubDerivation(metaSubDerivationNode, substitutions, localMetaContext) {
-  let metaSubDerivationVerified;
-
-  const childNodes = childNodesQuery(metaSubDerivationNode);
-
-  metaSubDerivationVerified = childNodes.every((childNode) => {
-    const childVerified = verifyChild(childNode, substitutions, localMetaContext);
-
-    if (childVerified) {
-      return true;
-    }
-  });
-
-  return metaSubDerivationVerified;
-}
-
-function verifyMetaSubproof(metaSubproofNode, substitutions, localMetaContext) {
-  let metaSubproofVerified = false;
-
-  localMetaContext = LocalMetaContext.fromLocalMetaContext(localMetaContext); ///
-
-  const metaSuppositions = [],
-        metaSuppositionNodes = metaSuppositionNodesQuery(metaSubproofNode),
-        metaSuppositionsVerified = verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, substitutions, localMetaContext);
-
-  if (metaSuppositionsVerified) {
-    const metaSubDerivationNode = metaSubDerivationNodeQuery(metaSubproofNode),
-          metaSubDerivationVerified = verifyMetaSubDerivation(metaSubDerivationNode, substitutions, localMetaContext);
-
-    if (metaSubDerivationVerified) {
-      metaSubproofVerified = true;
-    }
-  }
-
-  return metaSubproofVerified;
-}
-
-function verifyChild(childNode, substitutions, localMetaContext) {
-  let childVerified = false;
-
-  const childNodeRuleName = childNode.getRuleName();
-
-  switch (childNodeRuleName) {
-    case META_SUBPROOF_RULE_NAME: {
-      let metaSubproofVerified;
-
-      const metaSubproofNode = childNode;  ///
-
-      metaSubproofVerified = verifyMetaSubproof(metaSubproofNode, substitutions, localMetaContext);
-
-      if (metaSubproofVerified) {
-        const metaproofStep = MetaproofStep.fromMetaSubproofNode(metaSubproofNode);
-
-        localMetaContext.addMetaproofStep(metaproofStep);
-
-        childVerified = true;
-      }
-
-      break;
-    }
-
-    case QUALIFIED_METASTATEMENT_RULE_NAME: {
-      let qualifiedMetastatementVerified;
-
-      const derived = true,
-            assignments = [],
-            qualifiedMetastatementNode = childNode;  ///
-
-      qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, substitutions, assignments, derived, localMetaContext);
-
-      if (qualifiedMetastatementVerified) {
-        const assignmentAssigned = assignAssignment(assignments, localMetaContext);
-
-        qualifiedMetastatementVerified = assignmentAssigned; ///
-      }
-
-      if (qualifiedMetastatementVerified) {
-        const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
-              metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
-
-        localMetaContext.addMetaproofStep(metaproofStep);
-
-        childVerified = true; ///
-      }
-
-      break;
-    }
-
-    case UNQUALIFIED_METASTATEMENT_RULE_NAME: {
-      let unqualifiedMetastatementVerified;
-
-      const derived = true,
-            assignments = [],
-            unqualifiedMetastatementNode = childNode;  ///
-
-      unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
-
-      if (unqualifiedMetastatementVerified) {
-        const assignmentAssigned = assignAssignment(assignments, localMetaContext);
-
-        unqualifiedMetastatementVerified = assignmentAssigned;  ///
-      }
-
-      if (unqualifiedMetastatementVerified) {
-        const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
-              metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
-
-        localMetaContext.addMetaproofStep(metaproofStep);
-
-        childVerified = true;
-      }
-
-      break;
-    }
-  }
-
-  return childVerified;
-}