occam-verify-cli 0.0.892 → 0.0.894

package/src/verify/metaProofStep.js

@@ -0,0 +1,98 @@
+"use strict";
+
+import MetaproofStep from "../step/metaproof";
+import verifyMetaSubproof from "../verify/metaSubproof";
+import verifyMetaSubDerivation from "../verify/metaSubDerivation";
+import verifyQualifiedStatement from "../verify/statement/qualified";
+import verifyUnqualifiedStatement from "../verify/statement/unqualified";
+import verifyQualifiedMetastatement from "../verify/metastatement/qualified";
+import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
+
+import { nodeQuery } from "../utilities/query";
+import { assignAssignment } from "../utilities/assignments";
+
+const metaSubproofNodeQuery = nodeQuery("/metaProofStep|lastMetaProofStep/metaSubproof!"),
+      metastatementNodeQuery = nodeQuery("/qualifiedMetastatement|unqualifiedMetastatement/metastatement!"),
+      qualifiedStatementNodeQuery = nodeQuery("/metaProofStep|lastMetaProofStep/qualifiedStatement!"),
+      unqualifiedStatementNodeQuery = nodeQuery("/metaProofStep|lastMetaProofStep/unqualifiedStatement!"),
+      qualifiedMetastatementNodeQuery = nodeQuery("/metaProofStep|lastMetaProofStep/qualifiedMetastatement!"),
+      unqualifiedMetastatementNodeQuery = nodeQuery("/metaProofStep|lastMetaProofStep/unqualifiedMetastatement!");
+
+export default function verifyMetaProofStep(metaProofStepNode, substitutions, localMetaContext) {
+  let metaProofStepVerified = false;
+
+  const metaSubproofNode = metaSubproofNodeQuery(metaProofStepNode),
+        qualifiedStatementNode = qualifiedStatementNodeQuery(metaProofStepNode),
+        unqualifiedStatementNode = unqualifiedStatementNodeQuery(metaProofStepNode),
+        qualifiedMetastatementNode = qualifiedMetastatementNodeQuery(metaProofStepNode),
+        unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(metaProofStepNode);
+
+  if (false) {
+    ///
+  } else if (metaSubproofNode !== null) {
+    let metaSubproofVerified;
+
+    metaSubproofVerified = verifyMetaSubproof(metaSubproofNode, substitutions, localMetaContext);
+
+    if (metaSubproofVerified) {
+      const metaproofStep = MetaproofStep.fromMetaSubproofNode(metaSubproofNode);
+
+      localMetaContext.addMetaproofStep(metaproofStep);
+
+      metaProofStepVerified = true;
+    }
+  } else if (qualifiedStatementNode !== null) {
+    debugger
+  } else if (unqualifiedStatementNode !== null) {
+    debugger
+  } else if (qualifiedMetastatementNode !== null) {
+    let qualifiedMetastatementVerified;
+
+    const assignments = [];
+
+    qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, substitutions, assignments, localMetaContext);
+
+    if (qualifiedMetastatementVerified) {
+      const assignmentAssigned = assignAssignment(assignments, localMetaContext);
+
+      qualifiedMetastatementVerified = assignmentAssigned; ///
+    }
+
+    if (qualifiedMetastatementVerified) {
+      const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
+            metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
+
+      localMetaContext.addMetaproofStep(metaproofStep);
+
+      metaProofStepVerified = qualifiedMetastatementVerified; ///
+    }
+  } else if (unqualifiedMetastatementNode !== null) {
+    let unqualifiedMetastatementVerified;
+
+    const derived = true,
+          assignments = [];
+
+    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);
+
+      metaProofStepVerified = true;
+    }
+  }
+
+  return metaProofStepVerified;
+}
+
+Object.assign(verifyMetaSubDerivation, {
+  verifyMetaProofStep
+});

package/src/verify/metaSubDerivation.js

@@ -0,0 +1,22 @@
+"use strict";
+
+import { nodesQuery } from "../utilities/query";
+
+const metaProofStepNodesQuery = nodesQuery("/metaSubDerivation/metaProofStep|lastMetaProofStep");
+
+export default function verifyMetaSubDerivation(metaSubDerivationNode, substitutions, localMetaContext) {
+  let metaSubDerivationVerified;
+
+  const metaProofStepNodes = metaProofStepNodesQuery(metaSubDerivationNode);
+
+  metaSubDerivationVerified = metaProofStepNodes.every((metaProofStepNode) => {
+    const { verifyMetaProofStep } = verifyMetaSubDerivation,
+          metaProofStepVerified = verifyMetaProofStep(metaProofStepNode, substitutions, localMetaContext);
+
+    if (metaProofStepVerified) {
+      return true;
+    }
+  });
+
+  return metaSubDerivationVerified;
+}

package/src/verify/metaSubproof.js

@@ -0,0 +1,32 @@
+"use strict";
+
+import LocalMetaContext from "../context/localMeta";
+import verifyMetaSuppositions from "../verify/metaSuppositions";
+import verifyMetaSubDerivation from "../verify/metaSubDerivation";
+
+import { nodeQuery, nodesQuery } from "../utilities/query";
+
+const suppositionNodesQuery = nodesQuery("/metaSubproof/supposition"),
+      metaSubDerivationNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation");
+
+export default function verifyMetaSubproof(metaSubproofNode, substitutions, localMetaContext) {
+  let metaSubproofVerified = false;
+
+  localMetaContext = LocalMetaContext.fromLocalMetaContext(localMetaContext); ///
+
+  const metaSuppositions = [],
+        suppositionNodes = suppositionNodesQuery(metaSubproofNode),
+        metaSuppositionsVerified = verifyMetaSuppositions(suppositionNodes, metaSuppositions, localMetaContext);
+
+  if (metaSuppositionsVerified) {
+    const metaSubDerivationNode = metaSubDerivationNodeQuery(metaSubproofNode),
+          metaSubDerivationVerified = verifyMetaSubDerivation(metaSubDerivationNode, substitutions, localMetaContext);
+
+    if (metaSubDerivationVerified) {
+      metaSubproofVerified = true;
+    }
+  }
+
+  return metaSubproofVerified;
+}
+

package/src/verify/metaproof.js

@@ -1,28 +1,28 @@
 "use strict";
 
+import LocalMetaContext from "../context/localMeta";
 import verifyMetaDerivation from "../verify/metaDerivation";
 
 import { nodeQuery } from "../utilities/query";
 
 const metaDerivationNodeQuery = nodeQuery("/metaproof/metaDerivation!");
 
-export default function verifyMetaproof(metaproofNode, conclusion, substitutions, localMetaproof) {
+export default function verifyMetaproof(metaproofNode, conclusion, substitutions, localMetaContext) {
   let metaproofVerified = false;
 
+  localMetaContext = LocalMetaContext.fromLocalMetaContext(localMetaContext); ///
+
   const metaDerivationNode = metaDerivationNodeQuery(metaproofNode),
-        metaDerivationVerified = verifyMetaDerivation(metaDerivationNode, substitutions, localMetaproof);
+        metaDerivationVerified = verifyMetaDerivation(metaDerivationNode, substitutions, localMetaContext);
 
   if (metaDerivationVerified) {
-    const lastMetaproofStep = localMetaproof.getLastMetaproofStep();
-
-    if (lastMetaproofStep !== null) {
-      const metaproofStep = lastMetaproofStep, ///
-            metastatementNode = metaproofStep.getMetastatementNode(),
-            conclusionMetastatementNode = conclusion.getMetastatementNode(),
-            metastatementNodeMatchesConclusionMetastatementNode = metastatementNode.match(conclusionMetastatementNode);
+    const lastMetaproofStep = localMetaContext.getLastMetaproofStep(),
+          metaproofStep = lastMetaproofStep, ///
+          metastatementNode = metaproofStep.getMetastatementNode(),
+          conclusionMetastatementNode = conclusion.getMetastatementNode(),
+          metastatementNodeMatchesConclusionMetastatementNode = metastatementNode.match(conclusionMetastatementNode);
 
-      metaproofVerified = metastatementNodeMatchesConclusionMetastatementNode;  ///
-    }
+    metaproofVerified = metastatementNodeMatchesConclusionMetastatementNode;  ///
   }
 
   return metaproofVerified;

package/src/verify/metastatement/qualified.js

@@ -1,6 +1,5 @@
 "use strict";
 
-import verifyMetastatement from "../metastatement";
 import verifyMetavariableAgainstMetastatement from "../../verify/metavariableAgainstMetastatement";
 
 import { nodeQuery } from "../../utilities/query";
@@ -8,57 +7,124 @@ import { nodeQuery } from "../../utilities/query";
 const metavariableNodeQuery = nodeQuery("/qualifiedMetastatement/reference!/metavariable!"),
       metastatementNodeQuery = nodeQuery("/qualifiedMetastatement/metastatement!");
 
-export default function verifyQualifiedMetastatement(qualifiedMetastatementNode, substitutions, assignments, derived, localMetaContext) {
-  let qualifiedMetastatementVerified = false;
+export default function verifyQualifiedMetastatement(qualifiedMetastatementNode, substitutions, assignments, localMetaContext) {
+  let qualifiedMetastatementVerified;
 
-  const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode);
+  const qualifiedMetastatementString = localMetaContext.nodeAsString(qualifiedMetastatementNode);
 
-  if (metastatementNode !== null) {
-    const metastatementString = localMetaContext.nodeAsString(metastatementNode),
-          metastatementLocalMetaContext = localMetaContext; ///
+  localMetaContext.trace(`Verifying the '${qualifiedMetastatementString}' qualified metastatement...`, qualifiedMetastatementNode);
 
-    localMetaContext.trace(`Verifying the '${metastatementString}' qualified metastatement...`, qualifiedMetastatementNode);
+  const metavariableNode = metavariableNodeQuery(qualifiedMetastatementNode),
+        verifyQualifiedMetastatementFunctions = [
+          verifyQualifiedMetastatementAAgainstRule,
+          verifyQualifiedMetastatementAAgainstReference
+        ];
 
-    const metavariableNode = metavariableNodeQuery(qualifiedMetastatementNode);
+  qualifiedMetastatementVerified = verifyQualifiedMetastatementFunctions.some((verifyQualifiedMetastatementFunction) => {  ///
+    const qualifiedMetastatementVerified = verifyQualifiedMetastatementFunction(qualifiedMetastatementNode, metavariableNode, substitutions, localMetaContext);
 
-    if (!qualifiedMetastatementVerified) {
-      const rule = localMetaContext.findRuleByMetavariableNode(metavariableNode);
-
-      if (rule !== null) {
-        const ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, metastatementLocalMetaContext);
-
-        qualifiedMetastatementVerified = ruleMatchesMetastatement;  ///
-      }
+    if (qualifiedMetastatementVerified) {
+      return true;
     }
+  });
 
-    if (!qualifiedMetastatementVerified) {
-      if (substitutions !== null) {
-        const metavariablePresent = localMetaContext.isMetavariablePresentByMetavariableNode(metavariableNode, localMetaContext);
-
-        if (metavariablePresent) {
-          const metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localMetaContext, () => {
+  if (qualifiedMetastatementVerified) {
+    const derived = false,
+          metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
+          metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localMetaContext, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;
           });
 
-          if (metastatementVerified) {
-            const metavariableVerifiedAgainstMetastatement = verifyMetavariableAgainstMetastatement(metavariableNode, metastatementNode, substitutions, () => {
+    qualifiedMetastatementVerified = metastatementVerified; ///
+  }
+
+  if (qualifiedMetastatementVerified) {
+    localMetaContext.debug(`...verified the '${qualifiedMetastatementString}' qualified metastatement.`, qualifiedMetastatementNode);
+  }
+
+  return qualifiedMetastatementVerified;
+}
+
+function verifyQualifiedMetastatementAAgainstRule(qualifiedMetastatementNode, metavariableNode, substitutions, localMetaContext) {
+  let qualifiedMetastatementVerifiedAgainstRule = false;
+
+  const rule = localMetaContext.findRuleByMetavariableNode(metavariableNode);
+
+  if (rule !== null) {
+    const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
+          metavariableString = localMetaContext.nodeAsString(metavariableNode),
+          qualifiedMetastatementString = localMetaContext.nodeAsString(qualifiedMetastatementNode);
+
+    localMetaContext.trace(`Verifying the '${qualifiedMetastatementString}' qualified metastatement against the '${metavariableString}' rule...`, qualifiedMetastatementNode);
+
+    const ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, localMetaContext);
+
+    qualifiedMetastatementVerifiedAgainstRule = ruleMatchesMetastatement;  ///
+
+    if (qualifiedMetastatementVerifiedAgainstRule) {
+      localMetaContext.debug(`...verified the '${qualifiedMetastatementString}' qualified metastatement against the '${metavariableString}' rule.`, qualifiedMetastatementNode);
+    }
+  }
+
+  return qualifiedMetastatementVerifiedAgainstRule;
+}
+
+function verifyQualifiedMetastatementAAgainstReference(qualifiedMetastatementNode, metavariableNode, substitutions, localMetaContext) {
+  let qualifiedMetastatementVerifiedAgainstReference = false;
+
+  if (substitutions !== null) {
+    const metavariableString = localMetaContext.nodeAsString(metavariableNode),
+          metavariablePresent = localMetaContext.isMetavariablePresentByMetavariableNode(metavariableNode, localMetaContext),
+          qualifiedMetastatementString = localMetaContext.nodeAsString(qualifiedMetastatementNode);
+
+    localMetaContext.trace(`Verifying the '${qualifiedMetastatementString}' qualified metastatement against the '${metavariableString}' reference...`, qualifiedMetastatementNode);
+
+    if (metavariablePresent) {
+      const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
+            metavariableVerifiedAgainstMetastatement = verifyMetavariableAgainstMetastatement(metavariableNode, metastatementNode, substitutions, () => {
               const verifiedAhead = true;
 
               return verifiedAhead;
             });
 
-            qualifiedMetastatementVerified = metavariableVerifiedAgainstMetastatement; ///
-          }
-        }
-      }
+      qualifiedMetastatementVerifiedAgainstReference = metavariableVerifiedAgainstMetastatement; ///
     }
 
-    if (qualifiedMetastatementVerified) {
-      localMetaContext.debug(`...verified the '${metastatementString}' qualified metastatement.`, qualifiedMetastatementNode);
+    if (qualifiedMetastatementVerifiedAgainstReference) {
+      localMetaContext.debug(`...verified the '${qualifiedMetastatementString}' qualified metastatement against the '${metavariableString}' reference.`, qualifiedMetastatementNode);
     }
   }
 
-  return qualifiedMetastatementVerified;
+  return qualifiedMetastatementVerifiedAgainstReference;
+}
+
+function verifyMetastatement(metastatementNode, assignments, derived, localMetaContext) {
+  let metastatementVerified;
+
+  const metastatementString = localMetaContext.nodeAsString(metastatementNode);
+
+  localMetaContext.trace(`Verifying the '${metastatementString}' metastatement...`, metastatementNode);
+
+  const verifyMetaStatementFunctions = [
+    ///
+  ];
+
+  verifyMetaStatementFunctions.some((verifyStatementFunction) => {
+    const metastatementVerified = verifyStatementFunction(metastatementNode, assignments, derived, localMetaContext);
+
+    if (metastatementVerified) {
+      return true;
+    }
+  });
+
+  metastatementVerified = true; ///
+
+  if (metastatementVerified) {
+    localMetaContext.debug(`...verified the '${metastatementString}' metastatement.`, metastatementNode);
+  }
+
+  return metastatementVerified;
 }
+

package/src/verify/metastatement/unqualified.js

@@ -9,32 +9,29 @@ const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatemen
 export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext) {
   let unqualifiedMetastatementVerified = false;
 
-  const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
+  const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
+        unqualifiedMetastatementString = localMetaContext.nodeAsString(unqualifiedMetastatementNode);
 
-  if (metastatementNode !== null) {
-    const metastatementString = localMetaContext.nodeAsString(metastatementNode);
+  localMetaContext.trace(`Verifying the '${unqualifiedMetastatementString}' unqualified metastatement...`, unqualifiedMetastatementNode);
 
-    localMetaContext.trace(`Verifying the '${metastatementString}' unqualified metastatement...`, unqualifiedMetastatementNode);
+  if (derived) {
+    const metastatementMatches = localMetaContext.matchMetastatement(metastatementNode);
 
-    if (derived) {
-      const metastatementMatches = localMetaContext.matchMetastatement(metastatementNode);
-
-      unqualifiedMetastatementVerified = metastatementMatches;  ///
-    }
+    unqualifiedMetastatementVerified = metastatementMatches;  ///
+  }
 
-    if (!unqualifiedMetastatementVerified) {
-      const metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localMetaContext, () => {
-              const verifiedAhead = true;
+  if (!unqualifiedMetastatementVerified) {
+    const metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localMetaContext, () => {
+            const verifiedAhead = true;
 
-              return verifiedAhead;
-            });
+            return verifiedAhead;
+          });
 
-      unqualifiedMetastatementVerified = metastatementVerified; ///
-    }
+    unqualifiedMetastatementVerified = metastatementVerified; ///
+  }
 
-    if (unqualifiedMetastatementVerified) {
-      localMetaContext.debug(`...verified the '${metastatementString}' unqualified metastatement.`, unqualifiedMetastatementNode);
-    }
+  if (unqualifiedMetastatementVerified) {
+    localMetaContext.debug(`...verified the '${unqualifiedMetastatementString}' unqualified metastatement.`, unqualifiedMetastatementNode);
   }
 
   return unqualifiedMetastatementVerified;

package/src/verify/proofStep.js

@@ -0,0 +1,88 @@
+"use strict";
+
+import ProofStep from "../step/proof";
+import verifySubproof from "../verify/subproof";
+import verifySubDerivation from "../verify/subDerivation";
+import verifyQualifiedStatement from "../verify/statement/qualified";
+import verifyUnqualifiedStatement from "../verify/statement/unqualified";
+
+import { nodeQuery } from "../utilities/query";
+import { assignAssignment } from "../utilities/assignments";
+
+const subproofNodeQuery = nodeQuery("/proofStep|lastProofStep/subproof!"),
+      statementNodeQuery = nodeQuery("/qualifiedStatement|unqualifiedStatement/statement!"),
+      qualifiedStatementNodeQuery = nodeQuery("/proofStep|lastProofStep/qualifiedStatement!"),
+      unqualifiedStatementNodeQuery = nodeQuery("/proofStep|lastProofStep/unqualifiedStatement!");
+
+export default function verifyProofStep(proofStepNode, localContext) {
+  let proofStepVerified = false;
+
+  const subproofNode = subproofNodeQuery(proofStepNode),
+        qualifiedStatementNode = qualifiedStatementNodeQuery(proofStepNode),
+        unqualifiedStatementNode = unqualifiedStatementNodeQuery(proofStepNode);
+
+  if (false) {
+    ///
+  } else if (subproofNode !== null) {
+    let subproofVerified;
+
+    subproofVerified = verifySubproof(subproofNode, localContext);
+
+    if (subproofVerified) {
+      const proofStep = ProofStep.fromSubproofNode(subproofNode);
+
+      localContext.addProofStep(proofStep);
+
+      proofStepVerified = true;
+    }
+  } else if (qualifiedStatementNode !== null) {
+    let qualifiedStatementVerified;
+
+    const assignments = [];
+
+    qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, assignments, localContext);
+
+    if (qualifiedStatementVerified) {
+      const assignmentAssigned = assignAssignment(assignments, localContext);
+
+      qualifiedStatementVerified = assignmentAssigned; ///
+    }
+
+    if (qualifiedStatementVerified) {
+      const statementNode = statementNodeQuery(qualifiedStatementNode),
+            proofStep = ProofStep.fromStatementNode(statementNode);
+
+      localContext.addProofStep(proofStep);
+
+      proofStepVerified = true;
+    }
+  } else if (unqualifiedStatementNode !== null) {
+    let unqualifiedStatementVerified;
+
+    const derived = true,
+          assignments = [];
+
+    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);
+
+      proofStepVerified = true;
+    }
+  }
+
+  return proofStepVerified;
+}
+
+Object.assign(verifySubDerivation, {
+  verifyProofStep
+});

package/src/verify/ruleDerivation.js

@@ -1,149 +1,23 @@
 "use strict";
 
-import MetaproofStep from "../step/metaproof";
-import verifyPremises from "../verify/premises";
-import LocalMetaContext from "../context/localMeta";
-import verifyQualifiedMetastatement from "../verify/metastatement/qualified";
-import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
+import verifyRuleProofStep from "../verify/ruleProofStep";
 
-import { assignAssignment } from "../utilities/assignments";
-import { nodeQuery, nodesQuery } from "../utilities/query";
-import { RULE_SUBPROOF_RULE_NAME, QUALIFIED_METASTATEMENT_RULE_NAME, UNQUALIFIED_METASTATEMENT_RULE_NAME } from "../ruleNames";
+import { nodesQuery } from "../utilities/query";
 
-const childNodesQuery = nodesQuery("/ruleDerivation|ruleSubDerivation/*"),
-      premiseNodesQuery = nodesQuery("/ruleSubproof/premise"),
-      metastatementNodeQuery = nodeQuery("/qualifiedMetastatement|unqualifiedMetastatement/metastatement!"),
-      ruleSubDerivationNodeQuery = nodeQuery("/ruleSubproof/ruleSubDerivation");
+const ruleProofStepNodesQuery = nodesQuery("/ruleDerivation/ruleProofStep|lastRuleProofStep");
 
 export default function verifyRuleDerivation(ruleDerivationNode, localMetaContext) {
   let ruleDerivationVerified;
 
-  const childNodes = childNodesQuery(ruleDerivationNode);
+  const ruleProofStepNodes = ruleProofStepNodesQuery(ruleDerivationNode);
 
-  ruleDerivationVerified = childNodes.every((childNode) => {
-    const childVerified = verifyChild(childNode, localMetaContext);
+  ruleDerivationVerified = ruleProofStepNodes.every((ruleProofStepNode) => {
+    const ruleProofStepVerified = verifyRuleProofStep(ruleProofStepNode, localMetaContext);
 
-    if (childVerified) {
+    if (ruleProofStepVerified) {
       return true;
     }
   });
 
   return ruleDerivationVerified;
 }
-
-function verifyRuleSubDerivation(ruleSubDerivationNode, localMetaContext) {
-  let ruleSubDerivationVerified;
-
-  const childNodes = childNodesQuery(ruleSubDerivationNode);
-
-  ruleSubDerivationVerified = childNodes.every((childNode) => {
-    const childVerified = verifyChild(childNode, localMetaContext);
-
-    if (childVerified) {
-      return true;
-    }
-  });
-
-  return ruleSubDerivationVerified;
-}
-
-function verifyRuleSubproof(ruleSubproofNode, localMetaContext) {
-  let ruleSubproofVerified = false;
-
-  localMetaContext = LocalMetaContext.fromLocalMetaContext(localMetaContext); ///
-
-  const premises = [],
-        premiseNodes = premiseNodesQuery(ruleSubproofNode),
-        premisesVerified = verifyPremises(premiseNodes, premises, localMetaContext);
-
-  if (premisesVerified) {
-    const ruleSubDerivationNode = ruleSubDerivationNodeQuery(ruleSubproofNode),
-          ruleSubDerivationVerified = verifyRuleSubDerivation(ruleSubDerivationNode, localMetaContext);
-
-    if (ruleSubDerivationVerified) {
-      ruleSubproofVerified = true;
-    }
-  }
-
-  return ruleSubproofVerified;
-}
-
-function verifyChild(childNode, localMetaContext) {
-  let childVerified;
-
-  const childNodeRuleName = childNode.getRuleName();
-
-  switch (childNodeRuleName) {
-    case RULE_SUBPROOF_RULE_NAME: {
-      const ruleSubproofNode = childNode,  ///
-            ruleSubproofVerified = verifyRuleSubproof(ruleSubproofNode, localMetaContext);
-
-      if (ruleSubproofVerified) {
-        const metaproofStep = MetaproofStep.fromRuleSubproofNode(ruleSubproofNode);
-
-        localMetaContext.addMetaproofStep(metaproofStep);
-
-        childVerified = true;
-      }
-
-      break;
-    }
-
-    case QUALIFIED_METASTATEMENT_RULE_NAME: {
-      let qualifiedMetastatementVerified;
-
-      const derived = true,
-            assignments = [],
-            substitutions = null,
-            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 = qualifiedMetastatementVerified; ///
-      }
-
-      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;
-}