occam-verify-cli 0.0.923 → 0.0.924

package/src/verify/metastatement.js

@@ -2,8 +2,6 @@
 
 import verifyJudgement from "../verify/judgement";
 import metaLevelNodeVerifier from "../verifier/node/metaLevel";
-import verifyStatementAsDefinedAssertion from "./statementAsDefinedAssertion";
-import verifyStatementAsContainedAssertion from "./statementAsContainedAssertion";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -17,9 +15,6 @@ function verifyStatement(statementNode, assignments, derived, localContext) {
   localContext.trace(`Verifying the '${statementString}' statement...`, statementNode);
 
   const verifyStatementFunctions = [
-    verifyStatementAsJudgement,
-    verifyStatementAsDefinedAssertion,
-    verifyStatementAsContainedAssertion,
     verifyStatementAsIs
   ];
 
@@ -44,29 +39,6 @@ Object.assign(metaLevelNodeVerifier, {
 
 export default verifyStatement;
 
-function verifyStatementAsJudgement(statementNode, assignments, derived, localContext) {
-  let statementVerifiedAsJudgement = false;
-
-  const statementJudgement = isStatementJudgement(statementNode);
-
-  if (statementJudgement) {
-    const statementString = localContext.nodeAsString(statementNode);
-
-    localContext.trace(`Verifying the '${statementString}' statement as a judgement...`, statementNode);
-
-    const judgementNode = judgementNodeQuery(statementNode),
-          judgementVerified = verifyJudgement(judgementNode, assignments, derived, localContext);
-
-    statementVerifiedAsJudgement = judgementVerified;  ///
-
-    if (statementVerifiedAsJudgement) {
-      localContext.debug(`...verified the '${statementString}' statement as a judgement.`, statementNode);
-    }
-  }
-
-  return statementVerifiedAsJudgement;
-}
-
 function verifyStatementAsIs(statementNode, assignments, derived, localContext) {
   let statementVerifiedAsIs;
 
@@ -104,7 +76,7 @@ function verifyDerivedStatementAsIs(statementNode, assignments, derived, localCo
   if (derived) {
     const statementString = localContext.nodeAsString(statementNode);
 
-    localContext.debug(`Cannot verify the derived '${statementString}' statement as is.`, statementNode);
+    localContext.debug(`Cannot verify the '${statementString}' derived statement as is.`, statementNode);
   }
 
   return derivedStatementVerifiedAsIs;
@@ -116,7 +88,7 @@ function verifyStatedStatementAsIs(statementNode, assignments, derived, localCon
   if (!derived) {
     const statementString = localContext.nodeAsString(statementNode);
 
-    localContext.trace(`Verifying the stated '${statementString}' statement as is...`, statementNode);
+    localContext.trace(`Verifying the '${statementString}' stated statement as is...`, statementNode);
 
     const nonTerminalNode = statementNode, ///
           nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
@@ -128,7 +100,7 @@ function verifyStatedStatementAsIs(statementNode, assignments, derived, localCon
     statedStatementVerifiedAsIs = nonTerminalNodeVerified;  ///
 
     if (statedStatementVerifiedAsIs) {
-      localContext.debug(`...verified the stated '${statementString}' statement as is.`, statementNode);
+      localContext.debug(`...verified the '${statementString}' stated statement as is.`, statementNode);
     }
   }
 

package/src/verify/metatheorem.js

@@ -27,21 +27,21 @@ export default function verifyMetatheorem(metatheoremNode, fileContext) {
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
-    const localContext = LocalContext.fromFileContext(fileContext), ///
-          substitutions = [],
+    const localContext = LocalContext.fromFileContext(fileContext),
           suppositions = [],
           suppositionNodes = suppositionsNodeQuery(metatheoremNode),
-          suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, substitutions, localContext);
+          suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
 
     if (suppositionsVerified) {
       const consequents = [],
             consequentNode = consequentNodeQuery(metatheoremNode),
-            consequentVerified = verifyConsequent(consequentNode, consequents, substitutions, localContext);
+            consequentVerified = verifyConsequent(consequentNode, consequents, localContext);
 
       if (consequentVerified) {
         const proofNode = proofNodeQuery(metatheoremNode),
               firstConsequent = first(consequents),
               consequent = firstConsequent, ///
+              substitutions = [],
               statementNode = consequent.getStatementNode(),
               proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);
 

package/src/verify/metavariable.js

@@ -73,7 +73,7 @@ export function verifyStandaloneMetavariable(metavariableNode, localContext, ver
 
   localContext.trace(`Verifying the '${metavariableString}' standalone metavariable...`, metavariableNode);
 
-  const metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode, localContext);
+  const metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode);
 
   if (metavariablePresent) {
     const verifiedAhead = verifyAhead();

package/src/verify/proof.js

@@ -7,13 +7,13 @@ import { nodeQuery } from "../utilities/query";
 
 const derivationNodeQuery = nodeQuery("/proof/derivation!");
 
-export default function verifyProof(proofNode, conclusion, localContext) {
+export default function verifyProof(proofNode, conclusion, substitutions, localContext) {
   let proofVerified = false;
 
   localContext = LocalContext.fromLocalContext(localContext); ///
 
   const derivationNode = derivationNodeQuery(proofNode),
-        derivationVerified = verifyDerivation(derivationNode, localContext);
+        derivationVerified = verifyDerivation(derivationNode, substitutions, localContext);
 
   if (derivationVerified) {
     const lastProofStep = localContext.getLastProofStep();

package/src/verify/proofStep.js

@@ -14,7 +14,7 @@ const subproofNodeQuery = nodeQuery("/proofStep|lastProofStep/subproof!"),
       qualifiedStatementNodeQuery = nodeQuery("/proofStep|lastProofStep/qualifiedStatement!"),
       unqualifiedStatementNodeQuery = nodeQuery("/proofStep|lastProofStep/unqualifiedStatement!");
 
-export default function verifyProofStep(proofStepNode, localContext) {
+export default function verifyProofStep(proofStepNode, substitutions, localContext) {
   let proofStepVerified = false;
 
   const subproofNode = subproofNodeQuery(proofStepNode),
@@ -26,7 +26,7 @@ export default function verifyProofStep(proofStepNode, localContext) {
   } else if (subproofNode !== null) {
     let subproofVerified;
 
-    subproofVerified = verifySubproof(subproofNode, localContext);
+    subproofVerified = verifySubproof(subproofNode, substitutions, localContext);
 
     if (subproofVerified) {
       const proofStep = ProofStep.fromSubproofNode(subproofNode);
@@ -40,7 +40,7 @@ export default function verifyProofStep(proofStepNode, localContext) {
 
     const assignments = [];
 
-    qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, assignments, localContext);
+    qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, substitutions, assignments, localContext);
 
     if (qualifiedStatementVerified) {
       const assignmentAssigned = assignAssignment(assignments, localContext);

package/src/verify/rule.js

@@ -10,9 +10,9 @@ import verifyConclusion from "../verify/conclusion";
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const labelNodesQuery = nodesQuery("/rule/label"),
+const proofNodeQuery = nodeQuery("/rule/proof!"),
+      labelNodesQuery = nodesQuery("/rule/label"),
       premisesNodeQuery = nodesQuery("/rule/premise"),
-      proofNodeQuery = nodeQuery("/rule/proof!"),
       conclusionNodeQuery = nodeQuery("/rule/conclusion!");
 
 export default function verifyRule(ruleNode, fileContext) {
@@ -27,8 +27,8 @@ export default function verifyRule(ruleNode, fileContext) {
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
-    const premises = [],
-          localContext = LocalContext.fromFileContext(fileContext),
+    const localContext = LocalContext.fromFileContext(fileContext),
+          premises = [],
           premiseNodes = premisesNodeQuery(ruleNode),
           premisesVerified = verifyPremises(premiseNodes, premises, localContext);
 

package/src/verify/statement/qualified.js

@@ -15,18 +15,17 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, substit
 
   localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement...`, qualifiedStatementNode);
 
-  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
-        verifyQualifiedStatementFunctions = [
-          verifyQualifiedStatementAAgainstRule,
-          verifyQualifiedStatementAAgainstReference,
-          verifyQualifiedStatementAAgainstAxiom,
-          verifyQualifiedStatementAAgainstLemma,
-          verifyQualifiedStatementAAgainstTheorem,
-          verifyQualifiedStatementAAgainstConjecture
-        ];
+  const verifyQualifiedStatementFunctions = [
+    verifyQualifiedStatementAAgainstRule,
+    verifyQualifiedStatementAAgainstAxiom,
+    verifyQualifiedStatementAAgainstLemma,
+    verifyQualifiedStatementAAgainstTheorem,
+    verifyQualifiedStatementAAgainstConjecture,
+    verifyQualifiedStatementAAgainstReference
+  ];
 
   qualifiedStatementVerified = verifyQualifiedStatementFunctions.some((verifyQualifiedStatementFunction) => {  ///
-    const qualifiedStatementVerified = verifyQualifiedStatementFunction(qualifiedStatementNode, metavariableNode, substitutions, localContext);
+    const qualifiedStatementVerified = verifyQualifiedStatementFunction(qualifiedStatementNode, substitutions, localContext);
 
     if (qualifiedStatementVerified) {
       return true;
@@ -36,11 +35,7 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, substit
   if (qualifiedStatementVerified) {
     const derived = false,
           statementNode = statementNodeQuery(qualifiedStatementNode),
-          statementVerified = verifyStatement(statementNode, assignments, derived, localContext, () => {
-            const verifiedAhead = true;
-
-            return verifiedAhead;
-          });
+          statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
 
     qualifiedStatementVerified = statementVerified; ///
   }
@@ -52,10 +47,11 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, substit
   return qualifiedStatementVerified;
 }
 
-function verifyQualifiedStatementAAgainstRule(qualifiedStatementNode, metavariableNode, substitutions, localContext) {
+function verifyQualifiedStatementAAgainstRule(qualifiedStatementNode, substitutions, localContext) {
   let qualifiedStatementVerifiedAgainstRule = false;
 
-  const rule = localContext.findRuleByMetavariableNode(metavariableNode);
+  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
+        rule = localContext.findRuleByMetavariableNode(metavariableNode);
 
   if (rule !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
@@ -76,10 +72,11 @@ function verifyQualifiedStatementAAgainstRule(qualifiedStatementNode, metavariab
   return qualifiedStatementVerifiedAgainstRule;
 }
 
-function verifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, metavariableNode, substitutions, localContext) {
+function verifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, substitutions, localContext) {
   let qualifiedStatementVerifiedAgainstAxiom = false;
 
-  const axiom = localContext.findAxiomByMetavariableNode(metavariableNode);
+  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
+        axiom = localContext.findAxiomByMetavariableNode(metavariableNode);
 
   if (axiom !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
@@ -100,10 +97,11 @@ function verifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, metavaria
   return qualifiedStatementVerifiedAgainstAxiom;
 }
 
-function verifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, metavariableNode, substitutions, localContext) {
+function verifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, substitutions, localContext) {
   let qualifiedStatementVerifiedAgainstLemma = false;
 
-  const lemma = localContext.findLemmaByMetavariableNode(metavariableNode);
+  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
+        lemma = localContext.findLemmaByMetavariableNode(metavariableNode);
 
   if (lemma !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
@@ -124,10 +122,11 @@ function verifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, metavaria
   return qualifiedStatementVerifiedAgainstLemma;
 }
 
-function verifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, metavariableNode, substitutions, localContext) {
+function verifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, substitutions, localContext) {
   let qualifiedStatementVerifiedAgainstTheorem = false;
 
-  const theorem = localContext.findTheoremByMetavariableNode(metavariableNode);
+  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
+        theorem = localContext.findTheoremByMetavariableNode(metavariableNode);
 
   if (theorem !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
@@ -148,10 +147,11 @@ function verifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, metavar
   return qualifiedStatementVerifiedAgainstTheorem;
 }
 
-function verifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, metavariableNode, substitutions, localContext) {
+function verifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, substitutions, localContext) {
   let qualifiedStatementVerifiedAgainstConjecture = false;
 
-  const conjecture = localContext.findConjectureByMetavariableNode(metavariableNode);
+  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
+        conjecture = localContext.findConjectureByMetavariableNode(metavariableNode);
 
   if (conjecture !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
@@ -172,22 +172,23 @@ function verifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, meta
   return qualifiedStatementVerifiedAgainstConjecture;
 }
 
-function verifyQualifiedStatementAAgainstReference(qualifiedStatementNode, metavariableNode, substitutions, localContext) {
+function verifyQualifiedStatementAAgainstReference(qualifiedStatementNode, substitutions, localContext) {
   let qualifiedStatementVerifiedAgainstReference = false;
 
-  const metavariableString = localContext.nodeAsString(metavariableNode),
-        metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode, localContext),
+  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
+        metavariableString = localContext.nodeAsString(metavariableNode),
+        metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode),
         qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
   localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' reference...`, qualifiedStatementNode);
 
   if (metavariablePresent) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
-      metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNode, statementNode, substitutions, () => {
-        const verifiedAhead = true;
+          metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNode, statementNode, substitutions, () => {
+            const verifiedAhead = true;
 
-        return verifiedAhead;
-      });
+            return verifiedAhead;
+          });
 
     qualifiedStatementVerifiedAgainstReference = metavariableVerifiedAgainstStatement; ///
   }

package/src/verify/statement/unqualified.js

@@ -7,28 +7,70 @@ import { nodeQuery } from "../../utilities/query";
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
 
 export default function verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext) {
-  let unqualifiedStatementVerified = false;
+  let unqualifiedStatementVerified;
 
-  const statementNode = statementNodeQuery(unqualifiedStatementNode),
-        unqualifiedStatementString = localContext.nodeAsString(unqualifiedStatementNode);
+  const unqualifiedStatementString = localContext.nodeAsString(unqualifiedStatementNode);
 
   localContext.trace(`Verifying the '${unqualifiedStatementString}' unqualified statement...`, unqualifiedStatementNode);
 
+  const verifyUnqualifiedStatementFunctions = [
+    verifyDerivedUnqualifiedStatement,
+    verifyStatedUnqualifiedStatement
+  ];
+
+  unqualifiedStatementVerified = verifyUnqualifiedStatementFunctions.some((verifyUnqualifiedStatementFunction) => {
+    const unqualifiedStatementVerified = verifyUnqualifiedStatementFunction(unqualifiedStatementNode, assignments, derived, localContext);
+
+    if (unqualifiedStatementVerified) {
+      return true;
+    }
+  });
+
+  if (unqualifiedStatementVerified) {
+    localContext.debug(`...verified the '${unqualifiedStatementString}' unqualified statement.`, unqualifiedStatementNode);
+  }
+
+  return unqualifiedStatementVerified;
+}
+
+function verifyDerivedUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext) {
+  let derivedUnqualifiedStatementVerified = false;
+
   if (derived) {
+    const statementNode = statementNodeQuery(unqualifiedStatementNode),
+          unqualifiedStatementString = localContext.nodeAsString(unqualifiedStatementNode);
+
+    localContext.trace(`Verifying the '${unqualifiedStatementString}' derived unqualified statement...`, unqualifiedStatementNode);
+
     const matchesStatementNode = localContext.matchStatementNode(statementNode);
 
-    unqualifiedStatementVerified = matchesStatementNode;  ///
+    derivedUnqualifiedStatementVerified = matchesStatementNode;  ///
+
+    if (derivedUnqualifiedStatementVerified) {
+      localContext.debug(`...verified the '${unqualifiedStatementString}' derived unqualified statement.`, unqualifiedStatementNode);
+    }
   }
 
-  if (!unqualifiedStatementVerified) {
+  return derivedUnqualifiedStatementVerified;
+}
+
+function verifyStatedUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext) {
+  let statedUnqualifiedStatementVerified = false;
+
+  if (!derived) {
+    const statementNode = statementNodeQuery(unqualifiedStatementNode),
+          unqualifiedStatementString = localContext.nodeAsString(unqualifiedStatementNode);
+
+    localContext.trace(`Verifying the '${unqualifiedStatementString}' stated unqualified statement...`, unqualifiedStatementNode);
+
     const statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
 
-    unqualifiedStatementVerified = statementVerified; ///
-  }
+    statedUnqualifiedStatementVerified = statementVerified; ///
 
-  if (unqualifiedStatementVerified) {
-    localContext.debug(`...verified the '${unqualifiedStatementString}' unqualified statement.`, unqualifiedStatementNode);
+    if (statedUnqualifiedStatementVerified) {
+      localContext.debug(`...verified the '${unqualifiedStatementString}' stated unqualified statement.`, unqualifiedStatementNode);
+    }
   }
 
-  return unqualifiedStatementVerified;
+  return statedUnqualifiedStatementVerified;
 }

package/src/verify/statement.js

@@ -1,18 +1,21 @@
 "use strict";
 
 import verifyEquality from "../verify/equality";
-import bracketedCombinator from "../ocmbinator/bracketed";
+import verifyJudgement from "../verify/judgement";
 import verifyTypeAssertion from "../verify/typeAssertion";
-import verifyStatementAsDefinedAssertion from "../verify/statementAsDefinedAssertion";
-import verifyStatementAsContainedAssertion from "../verify/statementAsContainedAssertion";
+import verifyDefinedAssertion from "./definedAssertion";
+import verifyContainedAssertion from "./containedAssertion";
 import statementAgainstCombinatorNodesVerifier from "../verifier/nodes/statementAgainstCombinator";
 
 import { nodeQuery } from "../utilities/query";
-import { isStatementDefinedAssertion } from "../verify/statementAsDefinedAssertion";
-import { isStatementContainedAssertion } from "../verify/statementAsContainedAssertion";
+import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 
 const equalityNodeQuery = nodeQuery("/statement/equality!"),
-      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
+      judgementNodeQuery = nodeQuery("/statement/judgement!"),
+      metavariableNodeQuery = nodeQuery("/statement/metavariable!"),
+      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!"),
+      definedAssertionNodeQuery = nodeQuery("/statement/definedAssertion!"),
+      containedAssertionNodeQuery = nodeQuery("/statement/containedAssertion!");
 
 function verifyStatement(statementNode, assignments, derived, localContext) {
   let statementVerified;
@@ -22,7 +25,9 @@ function verifyStatement(statementNode, assignments, derived, localContext) {
   localContext.trace(`Verifying the '${statementString}' statement...`, statementNode);
 
   const verifyStatementFunctions = [
+    verifyStatementAsMetavariable,
     verifyStatementAsEquality,
+    verifyStatementAsJudgement,
     verifyStatementAsTypeAssertion,
     verifyStatementAsDefinedAssertion,
     verifyStatementAsContainedAssertion,
@@ -77,15 +82,14 @@ export default verifyStatement;
 export function verifyStatementAsEquality(statementNode, assignments, derived, localContext) {
   let statementVerifiedAsEquality = false;
 
-  const statementEquality = isStatementEquality(statementNode);
+  const equalityNode = equalityNodeQuery(statementNode);
 
-  if (statementEquality) {
+  if (equalityNode !== null) {
     const statementString = localContext.nodeAsString(statementNode);
 
     localContext.trace(`Verifying the '${statementString}' statement as an equality...`, statementNode);
 
-    const equalityNode = equalityNodeQuery(statementNode),
-          equalityVerified = verifyEquality(equalityNode, assignments, derived, localContext, () => {
+    const equalityVerified = verifyEquality(equalityNode, assignments, derived, localContext, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;
@@ -104,15 +108,14 @@ export function verifyStatementAsEquality(statementNode, assignments, derived, l
 export function verifyStatementAsTypeAssertion(statementNode, assignments, derived, localContext) {
   let statementVerifiedAsTypeAssertion = false;
 
-  const statementTypeAssertion = isStatementTypeAssertion(statementNode);
+  const typeAssertionNode = typeAssertionNodeQuery(statementNode);
 
-  if (statementTypeAssertion) {
+  if (typeAssertionNode !== null) {
     const statementString = localContext.nodeAsString(statementNode);
 
     localContext.trace(`Verifying the '${statementString}' statement as a type assertion...`, statementNode);
 
-    const typeAssertionNode = typeAssertionNodeQuery(statementNode),
-          typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, localContext, () => {
+    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, localContext, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;
@@ -128,21 +131,126 @@ export function verifyStatementAsTypeAssertion(statementNode, assignments, deriv
   return statementVerifiedAsTypeAssertion;
 }
 
+function verifyStatementAsJudgement(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAsJudgement = false;
+
+  const judgementNode = judgementNodeQuery(statementNode);
+
+  if (judgementNode !== null) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the '${statementString}' statement as a judgement...`, statementNode);
+
+    const judgementVerified = verifyJudgement(judgementNode, assignments, derived, localContext);
+
+    statementVerifiedAsJudgement = judgementVerified;  ///
+
+    if (statementVerifiedAsJudgement) {
+      localContext.debug(`...verified the '${statementString}' statement as a judgement.`, statementNode);
+    }
+  }
+
+  return statementVerifiedAsJudgement;
+}
+
+function verifyStatementAsMetavariable(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAsMetavariable = false;
+
+  const metavariableNode = metavariableNodeQuery(statementNode);
+
+  if (metavariableNode !== null) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the '${statementString}' statement as a metavariable...`, statementNode);
+
+    const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode);
+
+    if (metavariable !== null) {
+      const metaTypeName  = metavariable.getMetaTypeName();
+
+      if (metaTypeName === STATEMENT_META_TYPE_NAME) {
+        statementVerifiedAsMetavariable = true;
+      }
+    }
+
+    if (statementVerifiedAsMetavariable) {
+      localContext.debug(`...verified the '${statementString}' statement as a metavariable.`, statementNode);
+    }
+  }
+
+  return statementVerifiedAsMetavariable;
+}
+
+function verifyStatementAsDefinedAssertion(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAsDefinedAssertion = false;
+
+  const definedAssertionNode = definedAssertionNodeQuery(statementNode);
+
+  if (definedAssertionNode !== null) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the '${statementString}' statement as a defined assertion...`, statementNode);
+
+    const definedAssertionVerified = verifyDefinedAssertion(definedAssertionNode, assignments, derived, localContext, () => {
+      const verifiedAhead = true;
+
+      return verifiedAhead;
+    });
+
+    statementVerifiedAsDefinedAssertion = definedAssertionVerified; ///
+
+    if (statementVerifiedAsDefinedAssertion) {
+      localContext.debug(`...verified the '${statementString}' statement as a defined assertion.`, statementNode);
+    }
+  }
+
+  return statementVerifiedAsDefinedAssertion;
+}
+
+function verifyStatementAsContainedAssertion(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAsContainedAssertion = false;
+
+  const containedAssertionNode = containedAssertionNodeQuery(statementNode);
+
+  if (containedAssertionNode !== null) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the '${statementString}' statement as a defined assertion...`, statementNode);
+
+    const containedAssertionVerified = verifyContainedAssertion(containedAssertionNode, assignments, derived, localContext, () => {
+      const verifiedAhead = true;
+
+      return verifiedAhead;
+    });
+
+    statementVerifiedAsContainedAssertion = containedAssertionVerified; ///
+
+    if (statementVerifiedAsContainedAssertion) {
+      localContext.debug(`...verified the '${statementString}' statement as a defined assertion.`, statementNode);
+    }
+  }
+
+  return statementVerifiedAsContainedAssertion;
+}
+
 function verifyStatementAgainstCombinators(statementNode, assignments, derived, localContext) {
   let statementVerifiedAgainstCombinators = false;
 
-  const statementEquality = isStatementEquality(statementNode),
-        statementTypeAssertion = isStatementTypeAssertion(statementNode),
-        statementDefinedAssertion = isStatementDefinedAssertion(statementNode),
-        statementContainedAssertion = isStatementContainedAssertion(statementNode);
+  const equalityNode = equalityNodeQuery(statementNode),
+        judgementNode = judgementNodeQuery(statementNode),
+        metavariableNode = metavariableNodeQuery(statementNode),
+        typeAssertionNode = typeAssertionNodeQuery(statementNode),
+        definedAssertionNode = definedAssertionNodeQuery(statementNode),
+        containedAssertionNode = containedAssertionNodeQuery(statementNode);
 
-  if (!statementEquality && !statementTypeAssertion && !statementDefinedAssertion && !statementContainedAssertion) {
-    let combinators = localContext.getCombinators();
+  if (  (equalityNode === null) &&
+        (judgementNode === null) &&
+        (metavariableNode === null) &&
+        (typeAssertionNode === null) &&
+        (definedAssertionNode === null) &&
+        (containedAssertionNode === null) ) {
 
-    combinators = [ ///
-      bracketedCombinator,
-      ...combinators
-    ];
+    const combinators = localContext.getCombinators();
 
     statementVerifiedAgainstCombinators = combinators.some((combinator) => {
       const statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, localContext);
@@ -180,18 +288,4 @@ function verifyStatementAgainstCombinator(statementNode, combinator, localContex
   }
 
   return statementVerifiedAgainstCombinator;
-}
-
-function isStatementEquality(statementNode) {
-  const equalityNode = equalityNodeQuery(statementNode),
-        statementEquality = (equalityNode !== null);
-
-  return statementEquality;
-}
-
-function isStatementTypeAssertion(statementNode) {
-  const typeAssertionNode = typeAssertionNodeQuery(statementNode),
-        statementTypeAssertion = (typeAssertionNode !== null);
-
-  return statementTypeAssertion;
-}
+}

package/src/verify/subDerivation.js

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