occam-verify-cli 0.0.892 → 0.0.894

package/src/verify/ruleProofStep.js

@@ -0,0 +1,121 @@
+"use strict";
+
+import LocalContext from "../context/local";
+import MetaproofStep from "../step/metaproof";
+import verifyRuleSubproof from "../verify/ruleSubproof";
+import verifyRuleSubDerivation from "../verify/ruleSubDerivation";
+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 statementNodeQuery = nodeQuery("/qualifiedStatement|unqualifiedStatement/statement!"),
+      ruleSubproofNodeQuery = nodeQuery("/ruleProofStep|lastRuleProofStep/ruleSubproof!"),
+      metastatementNodeQuery = nodeQuery("/qualifiedMetastatement|unqualifiedMetastatement/metastatement!"),
+      qualifiedStatementNodeQuery = nodeQuery("/ruleProofStep|lastRuleProofStep/qualifiedStatement!"),
+      unqualifiedStatementNodeQuery = nodeQuery("/ruleProofStep|lastRuleProofStep/unqualifiedStatement!"),
+      qualifiedMetastatementNodeQuery = nodeQuery("/ruleProofStep|lastRuleProofStep/qualifiedMetastatement!"),
+      unqualifiedMetastatementNodeQuery = nodeQuery("/ruleProofStep|lastRuleProofStep/unqualifiedMetastatement!");
+
+export default function verifyRuleProofStep(ruleProofStepNode, localMetaContext) {
+  let ruleProofStepVerified = false;
+
+  const ruleSubproofNode = ruleSubproofNodeQuery(ruleProofStepNode),
+        qualifiedStatementNode = qualifiedStatementNodeQuery(ruleProofStepNode),
+        unqualifiedStatementNode = unqualifiedStatementNodeQuery(ruleProofStepNode),
+        qualifiedMetastatementNode = qualifiedMetastatementNodeQuery(ruleProofStepNode),
+        unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(ruleProofStepNode);
+
+  if (false) {
+    ///
+  } else if (ruleSubproofNode !== null) {
+    let ruleSubproofVerified;
+
+    ruleSubproofVerified = verifyRuleSubproof(ruleSubproofNode, localMetaContext);
+
+    if (ruleSubproofVerified) {
+      const metaproofStep = MetaproofStep.fromRuleSubproofNode(ruleSubproofNode);
+
+      localMetaContext.addMetaproofStep(metaproofStep);
+
+      ruleProofStepVerified = true;
+    }
+  } else if (qualifiedStatementNode !== null) {
+    let qualifiedStatementVerified;
+
+    const assignments = [],
+          localContext = LocalContext.fromLocalMetaContext(localMetaContext);
+
+    qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, assignments, localContext);
+
+    if (qualifiedStatementVerified) {
+      const assignmentAssigned = assignAssignment(assignments, localContext);
+
+      qualifiedStatementVerified = assignmentAssigned; ///
+    }
+
+    if (qualifiedStatementVerified) {
+      const statementNode = statementNodeQuery(qualifiedStatementNode),
+            metaproofStep = MetaproofStep.fromStatementNode(statementNode);
+
+      localMetaContext.addMetaproofStep(metaproofStep);
+
+      ruleProofStepVerified = true;
+    }
+  } else if (unqualifiedStatementNode !== null) {
+    debugger
+  } else if (qualifiedMetastatementNode !== null) {
+    let qualifiedMetastatementVerified;
+
+    const assignments = [],
+          substitutions = null;
+
+    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);
+
+      ruleProofStepVerified = 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);
+
+      ruleProofStepVerified = true;
+    }
+  }
+
+  return ruleProofStepVerified;
+}
+
+Object.assign(verifyRuleSubDerivation, {
+  verifyRuleProofStep
+});

package/src/verify/ruleSubDerivation.js

@@ -0,0 +1,22 @@
+"use strict";
+
+import { nodesQuery } from "../utilities/query";
+
+const ruleProofStepNodesQuery = nodesQuery("/ruleSubDerivation/ruleProofStep|lastRuleProofStep");
+
+export default function verifyRuleSubDerivation(ruleSubDerivationNode, localMetaContext) {
+  let ruleSubDerivationVerified;
+
+  const ruleProofStepNodes = ruleProofStepNodesQuery(ruleSubDerivationNode);
+
+  ruleSubDerivationVerified = ruleProofStepNodes.every((ruleProofStepNode) => {
+    const { verifyRuleProofStep } = verifyRuleSubDerivation,
+          ruleProofStepVerified = verifyRuleProofStep(ruleProofStepNode, localMetaContext);
+
+    if (ruleProofStepVerified) {
+      return true;
+    }
+  });
+
+  return ruleSubDerivationVerified;
+}

package/src/verify/ruleSubproof.js

@@ -0,0 +1,32 @@
+"use strict";
+
+import verifyPremises from "../verify/premises";
+import LocalMetaContext from "../context/localMeta";
+import verifyRuleSubDerivation from "../verify/ruleSubDerivation";
+
+import { nodeQuery, nodesQuery } from "../utilities/query";
+
+const premiseNodesQuery = nodesQuery("/ruleSubproof/premise"),
+      ruleSubDerivationNodeQuery = nodeQuery("/ruleSubproof/ruleSubDerivation");
+
+export default 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;
+}
+

package/src/verify/statement/qualified.js

@@ -1,241 +1,199 @@
 "use strict";
 
-import verifyEquality from "../equality";
-import verifyTypeAssertion from "../typeAssertion";
-
 import { nodeQuery } from "../../utilities/query";
+import { verifyStatementAsEquality, verifyStatementAsTypeAssertion } from "../../verify/statement";
 
-const equalityNodeQuery = nodeQuery("/qualifiedStatement/statement/equality!"),
-      statementNodeQuery = nodeQuery("/qualifiedStatement/statement!"),
-      typeAssertionNodeQuery = nodeQuery("/qualifiedStatement/statement/typeAssertion!"),
-      referenceMetavariableNodeQuery = nodeQuery("/qualifiedStatement/reference!/metavariable!");
-
-export default function verifyQualifiedStatement(qualifiedStatementNode, assignments, derived, localContext) {
-  let qualifiedStatementVerified = false;
+const statementNodeQuery = nodeQuery("/qualifiedStatement/statement!"),
+      metavariableNodeQuery = nodeQuery("/qualifiedStatement/reference!/metavariable!");
 
-  const statementNode = statementNodeQuery(qualifiedStatementNode);
+export default function verifyQualifiedStatement(qualifiedStatementNode, assignments, localContext) {
+  let qualifiedStatementVerified;
 
-  if (statementNode !== null) {
-    const qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+  const qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement...`, qualifiedStatementNode);
+  localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement...`, qualifiedStatementNode);
 
-    const referenceMetavariableNode = referenceMetavariableNodeQuery(qualifiedStatementNode),
-          verifyQualifiedStatementFunctions = [
-            verifyQualifiedStatementAAgainstRule,
-            verifyQualifiedStatementAAgainstAxiom,
-            verifyQualifiedStatementAAgainstLemma,
-            verifyQualifiedStatementAAgainstTheorem,
-            verifyQualifiedStatementAAgainstConjecture
-          ];
+  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
+        verifyQualifiedStatementFunctions = [
+          verifyQualifiedStatementAAgainstRule,
+          verifyQualifiedStatementAAgainstAxiom,
+          verifyQualifiedStatementAAgainstLemma,
+          verifyQualifiedStatementAAgainstTheorem,
+          verifyQualifiedStatementAAgainstConjecture
+        ];
 
-    qualifiedStatementVerified = verifyQualifiedStatementFunctions.some((verifyQualifiedStatementFunction) => {  ///
-      const qualifiedStatementVerified = verifyQualifiedStatementFunction(qualifiedStatementNode, referenceMetavariableNode, localContext);
-
-      if (qualifiedStatementVerified) {
-        return true;
-      }
-    });
+  qualifiedStatementVerified = verifyQualifiedStatementFunctions.some((verifyQualifiedStatementFunction) => {  ///
+    const qualifiedStatementVerified = verifyQualifiedStatementFunction(qualifiedStatementNode, metavariableNode, localContext);
 
     if (qualifiedStatementVerified) {
-      derived = false;  ///
-
-      const verifyQualifiedStatementFunctions = [
-              verifyQualifiedStatementAsEquality,
-              verifyQualifiedStatementAsTypeAssertion
-            ];
+      return true;
+    }
+  });
 
-      qualifiedStatementVerified = verifyQualifiedStatementFunctions.every((verifyQualifiedStatementFunction) => { ///
-        const qualifiedStatementVerified = verifyQualifiedStatementFunction(qualifiedStatementNode, assignments, derived, localContext, () => {
-          const verifiedAhead = true;
+  if (qualifiedStatementVerified) {
+    const derived = false,
+          statementNode = statementNodeQuery(qualifiedStatementNode),
+          statementVerified = verifyStatement(statementNode, assignments, derived, localContext, () => {
+            const verifiedAhead = true;
 
-          return verifiedAhead;
-        });
+            return verifiedAhead;
+          });
 
-        if (qualifiedStatementVerified) {
-          return true;
-        }
-      });
-    }
+    qualifiedStatementVerified = statementVerified;  ///
+  }
 
-    if (qualifiedStatementVerified) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement.`, qualifiedStatementNode);
-    }
+  if (qualifiedStatementVerified) {
+    localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement.`, qualifiedStatementNode);
   }
 
   return qualifiedStatementVerified;
 }
 
-function verifyQualifiedStatementAAgainstRule(qualifiedStatementNode, referenceMetavariableNode, localContext) {
+function verifyQualifiedStatementAAgainstRule(qualifiedStatementNode, metavariableNode, localContext) {
   let qualifiedStatementVerifiedAgainstRule = false;
 
-  const metavariableNode = referenceMetavariableNode,  ///
-        rule = localContext.findRuleByMetavariableNode(metavariableNode);
+  const rule = localContext.findRuleByMetavariableNode(metavariableNode);
 
   if (rule !== null) {
-    const referenceMetavariableString = localContext.nodeAsString(referenceMetavariableNode),
-          statementNode = statementNodeQuery(qualifiedStatementNode),
-          statementLocalContext = localContext, ///
+    const statementNode = statementNodeQuery(qualifiedStatementNode),
+          metavariableString = localContext.nodeAsString(metavariableNode),
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceMetavariableString}' rule...`, statementNode);
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' rule...`, qualifiedStatementNode);
 
-    const ruleMatchesStatement = rule.matchStatement(statementNode, statementLocalContext);
+    const ruleMatchesStatement = rule.matchStatement(statementNode, localContext);
 
     qualifiedStatementVerifiedAgainstRule = ruleMatchesStatement;  ///
 
     if (qualifiedStatementVerifiedAgainstRule) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceMetavariableString}' rule.`, statementNode);
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' rule.`, qualifiedStatementNode);
     }
   }
 
   return qualifiedStatementVerifiedAgainstRule;
 }
 
-function verifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, referenceMetavariableNode, localContext) {
+function verifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, metavariableNode, localContext) {
   let qualifiedStatementVerifiedAgainstAxiom = false;
 
-  const metavariableNode = referenceMetavariableNode,  ///
-        axiom = localContext.findAxiomByMetavariableNode(metavariableNode);
+  const axiom = localContext.findAxiomByMetavariableNode(metavariableNode);
 
   if (axiom !== null) {
-    const referenceMetavariableString = localContext.nodeAsString(referenceMetavariableNode),
-          statementNode = statementNodeQuery(qualifiedStatementNode),
-          statementLocalContext = localContext, ///
+    const statementNode = statementNodeQuery(qualifiedStatementNode),
+          metavariableString = localContext.nodeAsString(metavariableNode),
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceMetavariableString}' axiom...`, statementNode);
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' axiom...`, qualifiedStatementNode);
 
-    const axiomMatchesStatement = axiom.matchStatement(statementNode, statementLocalContext);
+    const axiomMatchesStatement = axiom.matchStatement(statementNode, localContext);
 
     qualifiedStatementVerifiedAgainstAxiom = axiomMatchesStatement; ///
 
     if (qualifiedStatementVerifiedAgainstAxiom) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceMetavariableString}' axiom.`, statementNode);
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' axiom.`, qualifiedStatementNode);
     }
   }
 
   return qualifiedStatementVerifiedAgainstAxiom;
 }
 
-function verifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, referenceMetavariableNode, localContext) {
+function verifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, metavariableNode, localContext) {
   let qualifiedStatementVerifiedAgainstLemma = false;
 
-  const metavariableNode = referenceMetavariableNode,  ///
-        lemma = localContext.findLemmaByMetavariableNode(metavariableNode);
+  const lemma = localContext.findLemmaByMetavariableNode(metavariableNode);
 
   if (lemma !== null) {
-    const referenceMetavariableString = localContext.nodeAsString(referenceMetavariableNode),
-          statementNode = statementNodeQuery(qualifiedStatementNode),
-          statementLocalContext = localContext, ///
+    const statementNode = statementNodeQuery(qualifiedStatementNode),
+          metavariableString = localContext.nodeAsString(metavariableNode),
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceMetavariableString}' lemma...`, statementNode);
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' lemma...`, qualifiedStatementNode);
 
-    const lemmaMatchesStatement = lemma.matchStatement(statementNode, statementLocalContext);
+    const lemmaMatchesStatement = lemma.matchStatement(statementNode, localContext);
 
     qualifiedStatementVerifiedAgainstLemma = lemmaMatchesStatement; ///
 
     if (qualifiedStatementVerifiedAgainstLemma) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceMetavariableString}' lemma.`, statementNode);
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' lemma.`, qualifiedStatementNode);
     }
   }
 
   return qualifiedStatementVerifiedAgainstLemma;
 }
 
-function verifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, referenceMetavariableNode, localContext) {
+function verifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, metavariableNode, localContext) {
   let qualifiedStatementVerifiedAgainstTheorem = false;
 
-  const metavariableNode = referenceMetavariableNode,  ///
-        theorem = localContext.findTheoremByMetavariableNode(metavariableNode);
+  const theorem = localContext.findTheoremByMetavariableNode(metavariableNode);
 
   if (theorem !== null) {
-    const referenceMetavariableString = localContext.nodeAsString(referenceMetavariableNode),
-          statementNode = statementNodeQuery(qualifiedStatementNode),
-          statementLocalContext = localContext, ///
+    const statementNode = statementNodeQuery(qualifiedStatementNode),
+          metavariableString = localContext.nodeAsString(metavariableNode),
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceMetavariableString}' theorem...`, statementNode);
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' theorem...`, qualifiedStatementNode);
 
-    const theoremMatchesStatement = theorem.matchStatement(statementNode, statementLocalContext);
+    const theoremMatchesStatement = theorem.matchStatement(statementNode, localContext);
 
     qualifiedStatementVerifiedAgainstTheorem = theoremMatchesStatement; ///
 
     if (qualifiedStatementVerifiedAgainstTheorem) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceMetavariableString}' theorem.`, statementNode);
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' theorem.`, qualifiedStatementNode);
     }
   }
 
   return qualifiedStatementVerifiedAgainstTheorem;
 }
 
-function verifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, referenceMetavariableNode, localContext) {
+function verifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, metavariableNode, localContext) {
   let qualifiedStatementVerifiedAgainstConjecture = false;
 
-  const metavariableNode = referenceMetavariableNode,  ///
-        conjecture = localContext.findConjectureByMetavariableNode(metavariableNode);
+  const conjecture = localContext.findConjectureByMetavariableNode(metavariableNode);
 
   if (conjecture !== null) {
-    const referenceMetavariableString = localContext.nodeAsString(referenceMetavariableNode),
-          statementNode = statementNodeQuery(qualifiedStatementNode),
-          statementLocalContext = localContext, ///
+    const statementNode = statementNodeQuery(qualifiedStatementNode),
+          metavariableString = localContext.nodeAsString(metavariableNode),
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceMetavariableString}' conjecture...`, statementNode);
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' conjecture...`, qualifiedStatementNode);
 
-    const conjectureMatchesStatement = conjecture.matchStatement(statementNode, statementLocalContext);
+    const conjectureMatchesStatement = conjecture.matchStatement(statementNode, localContext);
 
     qualifiedStatementVerifiedAgainstConjecture = conjectureMatchesStatement; ///
 
     if (qualifiedStatementVerifiedAgainstConjecture) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceMetavariableString}' conjecture.`, statementNode);
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' conjecture.`, qualifiedStatementNode);
     }
   }
 
   return qualifiedStatementVerifiedAgainstConjecture;
 }
 
-function verifyQualifiedStatementAsEquality(qualifiedStatementNode, assignments, derived, localContext, verifyAhead) {
-  let statementVerifiedAsEquality = true; ///
-
-  const equalityNode = equalityNodeQuery(qualifiedStatementNode);
+function verifyStatement(statementNode, assignments, derived, localContext, verifyAhead) {
+  let statementVerified;
 
-  if (equalityNode !== null) {
-    const qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+  const statementString = localContext.nodeAsString(statementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement as an equality...`, qualifiedStatementNode);
+  localContext.trace(`Verifying the '${statementString}' statement...`, statementNode);
 
-    const equalityVerified = verifyEquality(equalityNode, assignments, derived, localContext, verifyAhead);
+  const verifyStatementFunctions = [
+    verifyStatementAsEquality,
+    verifyStatementAsTypeAssertion
+  ];
 
-    statementVerifiedAsEquality = equalityVerified; ///
+  verifyStatementFunctions.some((verifyStatementFunction) => {
+    const statementVerified = verifyStatementFunction(statementNode, assignments, derived, localContext, verifyAhead);
 
-    if (statementVerifiedAsEquality) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement as an equality.`, qualifiedStatementNode);
+    if (statementVerified) {
+      return true;
     }
-  }
-
-  return statementVerifiedAsEquality;
-}
+  });
 
-function verifyQualifiedStatementAsTypeAssertion(qualifiedStatementNode, assignments, derived, localContext, verifyAhead) {
-  let statementVerifiedAsTypeAssertion = true;  ///
+  statementVerified = true; ///
 
-  const typeAssertionNode = typeAssertionNodeQuery(qualifiedStatementNode);
-
-  if (typeAssertionNode !== null) {
-    const qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
-
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement as a type assertion...`, qualifiedStatementNode);
-
-    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, localContext, verifyAhead);
-
-    statementVerifiedAsTypeAssertion = typeAssertionVerified; ///
-
-    if (statementVerifiedAsTypeAssertion) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement as a type assertion.`, qualifiedStatementNode);
-    }
+  if (statementVerified) {
+    localContext.debug(`...verified the '${statementString}' statement.`, statementNode);
   }
 
-  return statementVerifiedAsTypeAssertion;
+  return statementVerified;
 }

package/src/verify/statement/unqualified.js

@@ -9,32 +9,29 @@ const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
 export default function verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext) {
   let unqualifiedStatementVerified = false;
 
-  const statementNode = statementNodeQuery(unqualifiedStatementNode);
+  const statementNode = statementNodeQuery(unqualifiedStatementNode),
+        unqualifiedStatementString = localContext.nodeAsString(unqualifiedStatementNode);
 
-  if (statementNode !== null) {
-    const statementString = localContext.nodeAsString(statementNode);
+  localContext.trace(`Verifying the '${unqualifiedStatementString}' unqualified statement...`, unqualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${statementString}' unqualified statement...`, unqualifiedStatementNode);
+  if (derived) {
+    const statementMatches = localContext.matchStatement(statementNode);
 
-    if (derived) {
-      const statementMatches = localContext.matchStatement(statementNode);
-
-      unqualifiedStatementVerified = statementMatches;  ///
-    }
+    unqualifiedStatementVerified = statementMatches;  ///
+  }
 
-    if (!unqualifiedStatementVerified) {
-      const statementVerified = verifyStatement(statementNode, assignments, derived, localContext, () => {
-              const verifiedAhead = true;
+  if (!unqualifiedStatementVerified) {
+    const statementVerified = verifyStatement(statementNode, assignments, derived, localContext, () => {
+            const verifiedAhead = true;
 
-              return verifiedAhead;
-            });
+            return verifiedAhead;
+          });
 
-      unqualifiedStatementVerified = statementVerified;  ///
-    }
+    unqualifiedStatementVerified = statementVerified;  ///
+  }
 
-    if (unqualifiedStatementVerified) {
-      localContext.debug(`...verified the '${statementString}' unqualified statement.`, unqualifiedStatementNode);
-    }
+  if (unqualifiedStatementVerified) {
+    localContext.debug(`...verified the '${unqualifiedStatementString}' unqualified statement.`, unqualifiedStatementNode);
   }
 
   return unqualifiedStatementVerified;

package/src/verify/statement.js

@@ -71,7 +71,7 @@ Object.assign(statementAgainstCombinatorNodesVerifier, {
 
 export default verifyStatement;
 
-function verifyStatementAsEquality(statementNode, assignments, derived, localContext, verifyAhead) {
+export function verifyStatementAsEquality(statementNode, assignments, derived, localContext, verifyAhead) {
   let statementVerifiedAsEquality = false;
 
   const equalityNode = equalityNodeQuery(statementNode);
@@ -93,7 +93,7 @@ function verifyStatementAsEquality(statementNode, assignments, derived, localCon
   return statementVerifiedAsEquality;
 }
 
-function verifyStatementAsTypeAssertion(statementNode, assignments, derived, localContext, verifyAhead) {
+export function verifyStatementAsTypeAssertion(statementNode, assignments, derived, localContext, verifyAhead) {
   let statementVerifiedAsTypeAssertion = false;
 
   const typeAssertionNode = typeAssertionNodeQuery(statementNode);

package/src/verify/subDerivation.js

@@ -0,0 +1,22 @@
+"use strict";
+
+import { nodesQuery } from "../utilities/query";
+
+const proofStepNodesQuery = nodesQuery("/subDerivation/proofStep|lastProofStep");
+
+export default function verifySubDerivation(subDerivationNode, localMetaContext) {
+  let subDerivationVerified;
+
+  const proofStepNodes = proofStepNodesQuery(subDerivationNode);
+
+  subDerivationVerified = proofStepNodes.every((proofStepNode) => {
+    const { verifyProofStep } = verifySubDerivation,
+          proofStepVerified = verifyProofStep(proofStepNode, localMetaContext);
+
+    if (proofStepVerified) {
+      return true;
+    }
+  });
+
+  return subDerivationVerified;
+}

package/src/verify/subproof.js

@@ -0,0 +1,32 @@
+"use strict";
+
+import LocalContext from "../context/local";
+import verifySuppositions from "../verify/suppositions";
+import verifySubDerivation from "../verify/subDerivation";
+
+import { nodeQuery, nodesQuery } from "../utilities/query";
+
+const suppositionNodesQuery = nodesQuery("/subproof/supposition"),
+      subDerivationNodeQuery = nodeQuery("/subproof/subDerivation");
+
+export default 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;
+}
+