occam-verify-cli 0.0.932 → 0.0.934

package/src/verifier/{node/statementAsCombinator.js → statementAsCombinator.js}

@@ -1,26 +1,26 @@
 "use strict";
 
-import NodeVerifier from "../../verifier/node";
+import Verifier from "../verifier";
 
-import { nodeQuery } from "../../utilities/query";
-import { verifyNode } from "../../utilities/verifier";
-import { verifyStandaloneType } from "./../../verify/type";
-import { verifyStandaloneTerm } from "./../../verify/term";
-import { verifyStandaloneStatement } from "../../verify/statement";
+import { verify } from "../verifier";
+import { nodeQuery } from "../utilities/query";
+import { verifyStandaloneType } from "../verify/type";
+import { verifyStandaloneTerm } from "../verify/term";
+import { verifyStandaloneStatement } from "../verify/statement";
 
 const termNodeQuery = nodeQuery("/term!"),
       typeNodeQuery = nodeQuery("/type!"),
       statementNodeQuery = nodeQuery("/statement!"),
       nonTerminalNodeQuery = nodeQuery("/*");
 
-class StatementAsCombinatorNodeVerifier extends NodeVerifier {
+class StatementAsCombinatorVerifier extends Verifier {
   verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead) {
     let nonTerminalNodeVerified;
 
     const nodeQueryMaps = [
       {
         nodeQuery: termNodeQuery,
-        verifyNode: (node, localContext, verifyAhead) => {
+        verify: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const termNode = node, ///
@@ -33,7 +33,7 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
       },
       {
         nodeQuery: typeNodeQuery,
-        verifyNode: (node, localContext, verifyAhead) => {
+        verify: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const typeNode = node, ///
@@ -46,7 +46,7 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
       },
       {
         nodeQuery: statementNodeQuery,
-        verifyNode: (node, localContext, verifyAhead) => {
+        verify: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const statementNode = node, ///
@@ -59,7 +59,7 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
       },
       {
         nodeQuery: nonTerminalNodeQuery,
-        verifyNode: (node, localContext, verifyAhead) => {
+        verify: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const nonTerminalNode = node; ///
@@ -73,7 +73,7 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
       }
     ];
 
-    const nodeVerified = verifyNode(nodeQueryMaps, nonTerminalNode, localContext, verifyAhead);
+    const nodeVerified = verify(nodeQueryMaps, nonTerminalNode, localContext, verifyAhead);
 
     nonTerminalNodeVerified = nodeVerified; ///
 
@@ -102,6 +102,6 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
   }
 }
 
-const statementAsCombinatorNodeVerifier = new StatementAsCombinatorNodeVerifier();
+const statementAsCombinatorVerifier = new StatementAsCombinatorVerifier();
 
-export default statementAsCombinatorNodeVerifier;
+export default statementAsCombinatorVerifier;

package/src/verifier/{node/termAsConstructor.js → termAsConstructor.js}

@@ -1,24 +1,24 @@
 "use strict";
 
-import NodeVerifier from "../../verifier/node";
+import Verifier from "../verifier";
 
-import { nodeQuery } from "../../utilities/query";
-import { verifyNode } from "../../utilities/verifier";
-import { verifyStandaloneType } from "../../verify/type";
-import { verifyStandaloneTerm } from "../../verify/term";
+import { verify } from "../verifier";
+import { nodeQuery } from "../utilities/query";
+import { verifyStandaloneType } from "../verify/type";
+import { verifyStandaloneTerm } from "../verify/term";
 
 const termNodeQuery = nodeQuery("/term!"),
       typeNodeQuery = nodeQuery("/type!"),
       nonTerminalNodeQuery = nodeQuery("/*");
 
-class TermAsConstructorNodeVerifier extends NodeVerifier {
+class TermAsConstructorVerifier extends Verifier {
   verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead) {
     let nonTerminalNodeVerified;
 
     const nodeQueryMaps = [
       {
         nodeQuery: termNodeQuery,
-        verifyNode: (node, localContext, verifyAhead) => {
+        verify: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const termNode = node, ///
@@ -31,7 +31,7 @@ class TermAsConstructorNodeVerifier extends NodeVerifier {
       },
       {
         nodeQuery: typeNodeQuery,
-        verifyNode: (node, localContext, verifyAhead) => {
+        verify: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const typeNode = node, ///
@@ -44,7 +44,7 @@ class TermAsConstructorNodeVerifier extends NodeVerifier {
       },
       {
         nodeQuery: nonTerminalNodeQuery,
-        verifyNode: (node, localContext, verifyAhead) => {
+        verify: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const nonTerminalNode = node; ///
@@ -58,7 +58,7 @@ class TermAsConstructorNodeVerifier extends NodeVerifier {
       }
     ];
 
-    const nodeVerified = verifyNode(nodeQueryMaps, nonTerminalNode, localContext, verifyAhead);
+    const nodeVerified = verify(nodeQueryMaps, nonTerminalNode, localContext, verifyAhead);
 
     nonTerminalNodeVerified = nodeVerified; ///
 
@@ -80,6 +80,6 @@ class TermAsConstructorNodeVerifier extends NodeVerifier {
   }
 }
 
-const termAsConstructorNodeVerifier = new TermAsConstructorNodeVerifier();
+const termAsConstructorVerifier = new TermAsConstructorVerifier();
 
-export default termAsConstructorNodeVerifier;
+export default termAsConstructorVerifier;

package/src/{verifier/node.js → verifier.js}

@@ -1,6 +1,6 @@
 "use strict";
 
-export default class NodeVerifier {
+export default class Verifier {
   verifyNode(node, ...remainingArguments) {
     let nodeVerified;
 
@@ -82,3 +82,21 @@ export default class NodeVerifier {
     return childNodesVerify;
   }
 }
+
+export function verify(nodeQueryMaps, nonTerminalNode, ...remainingArguments) {
+  let nodeVerified = false;
+
+  nodeVerified = nodeQueryMaps.some((nodeQueryMap) => {
+    const { nodeQuery, verifyNode } = nodeQueryMap;
+
+    const node = nodeQuery(nonTerminalNode);
+
+    if (node !== null) {
+      nodeVerified = verifyNode(node, ...remainingArguments);
+
+      return true;
+    }
+  });
+
+  return nodeVerified;
+}

package/src/verify/assertion/contained.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import metaLevelNodeVerifier from "../../verifier/node/metaLevel";
+import metaLevelVerifier from "../../verifier/metaLevel";
 
 import { isAssertionNegated } from "../../utilities/verify";
 import { nodeQuery, nodesQuery } from "../../utilities/query";
@@ -84,7 +84,7 @@ function verifyStatedContainedAssertion(containedAssertionNode, assignments, der
     localContext.debug(`The '${containedAssertionString}' stated contained assertion cannot be verified.`, containedAssertionNode);
 
     const nonTerminalNode = containedAssertionNode, ///
-          nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
+          nonTerminalNodeVerified = metaLevelVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;

package/src/verify/assertion/defined.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import verifyTerm from "../../verify/term";
-import metaLevelNodeVerifier from "../../verifier/node/metaLevel";
+import metaLevelVerifier from "../../verifier/metaLevel";
 
 import { first } from "../../utilities/array";
 import { nodeQuery } from "../../utilities/query";
@@ -113,7 +113,7 @@ function verifyStatedDefinedAssertion(definedAssertionNode, assignments, derived
     localContext.trace(`Verifying the '${definedAssertionString}' stated defined assertion...`, definedAssertionNode);
 
     const nonTerminalNode = definedAssertionNode, ///
-          nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
+          nonTerminalNodeVerified = metaLevelVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;

package/src/verify/declaration.js

@@ -1,14 +1,13 @@
 "use strict";
 
+import shim from "../shim";
 import Declaration from "../declaration"
 import referenceMetaType from "../metaType/reference";
-import metaLevelNodeVerifier from "../verifier/node/metaLevel";
 
 import { nodeQuery } from "../utilities/query";
 
-const referenceNodeQuery = nodeQuery("/declaration/reference!"),
-      statementNodeQuery = nodeQuery("/declaration/statement!"),
-      metavariableNodeQuery = nodeQuery("/reference/metavariable!");
+const statementNodeQuery = nodeQuery("/declaration/statement!"),
+      metavariableNodeQuery = nodeQuery("/declaration/metavariable!");
 
 export default function verifyDeclaration(declarationNode, declarations, localContext) {
   let declarationVerified = false;
@@ -17,20 +16,19 @@ export default function verifyDeclaration(declarationNode, declarations, localCo
 
   localContext.trace(`Verifying the '${declarationString}' declaration...`, declarationNode);
 
-  const referenceNode = referenceNodeQuery(declarationNode),
-        referenceVerified = verifyReference(referenceNode, localContext);
+  const metavariableNode = metavariableNodeQuery(declarationNode),
+        metavariableVerified = verifyMetavariable(metavariableNode, localContext);
 
-  if (referenceVerified) {
+  if (metavariableVerified) {
     const statementNode = statementNodeQuery(declarationNode);
 
-    const { verifyStatement } = metaLevelNodeVerifier,
+    const { verifyStatement } = shim,
           derived = false,
           assignments = [],
           statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
 
     if (statementVerified) {
-      const metavariableNode = metavariableNodeQuery(referenceNode),
-            declaration = Declaration.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode);
+      const declaration = Declaration.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode);
 
       declarations.push(declaration);
 
@@ -45,34 +43,33 @@ export default function verifyDeclaration(declarationNode, declarations, localCo
   return declarationVerified;
 }
 
-function verifyReference(referenceNode, localContext) {
-  let referenceVerified = false;
+function verifyMetavariable(metavariableNode, localContext) {
+  let metavariableVerified = false;
 
-  const referenceString = localContext.nodeAsString(referenceNode);
+  const metavariableString = localContext.nodeAsString(metavariableNode);
 
-  localContext.trace(`Verifying the '${referenceString}' reference...`, referenceNode);
+  localContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
 
-  const metavariableNode = metavariableNodeQuery(referenceNode),
-        metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode);
+  const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode);
 
   if (metavariable !== null) {
     const metaType = metavariable.getMetaType();
 
     if (metaType === referenceMetaType) {
-      referenceVerified = true;
+      metavariableVerified = true;
     } else {
       const referenceMetaTypeName = referenceMetaType.getName(),
             metaTypeString = metaType.asString();
 
-      localContext.debug(`The '${referenceString}' metavariable's meta-type is '${metaTypeString}' when it should be '${referenceMetaTypeName}'.`, referenceNode);
+      localContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metaTypeString}' when it should be '${referenceMetaTypeName}'.`, metavariableNode);
     }
   } else {
-    localContext.debug(`The '${referenceString}' metavariable is not present'.`, referenceNode);
+    localContext.debug(`The '${metavariableString}' metavariable is not present'.`, metavariableNode);
   }
 
-  if (referenceVerified) {
-    localContext.debug(`...verified the '${referenceString}' reference.`, referenceNode);
+  if (metavariableVerified) {
+    localContext.debug(`...verified the '${metavariableString}' metavariable.`, metavariableNode);
   }
 
-  return referenceVerified;
-}
+  return metavariableVerified;
+}

package/src/verify/frame.js

@@ -19,27 +19,24 @@ export default function verifyFrame(frameNode, frames, assignments, derived, loc
 
   const declarations = [],
         declarationNodes = declarationNodesQuery(frameNode),
+        metavariableNodes = metavariableNodesQuery(frameNode),
         declarationsVerified = declarationNodes.every((declarationNode) => {
           const declarationVerified = verifyDeclaration(declarationNode, declarations, localContext);
 
           return declarationVerified;
-        });
-
-  if (declarationsVerified) {
-    const metavariableNodes = metavariableNodesQuery(frameNode),
-          metavariablesVerified = metavariableNodes.every((metavariableNode) => {
-            const metavariableVerified = verifyMetavariable(metavariableNode, declarations, localContext);
+        }),
+        metavariablesVerified = metavariableNodes.every((metavariableNode) => {
+          const metavariableVerified = verifyMetavariable(metavariableNode, declarations, localContext);
 
-            return metavariableVerified;
-          });
+          return metavariableVerified;
+        });
 
-    if (metavariablesVerified) {
-      const frame = Frame.fromDeclarations(declarations);
+  if (declarationsVerified && metavariablesVerified) {
+    const frame = Frame.fromDeclarations(declarations);
 
-      frames.push(frame);
+    frames.push(frame);
 
-      frameVerified = true;
-    }
+    frameVerified = true;
   }
 
   if (frameVerified) {

package/src/verify/proofStep.js

@@ -1,8 +1,8 @@
 "use strict";
 
+import shim from "../shim";
 import ProofStep from "../proofStep";
 import verifySubproof from "../verify/subproof";
-import verifySubDerivation from "../verify/subDerivation";
 import verifyQualifiedStatement from "../verify/statement/qualified";
 import verifyUnqualifiedStatement from "../verify/statement/unqualified";
 
@@ -83,6 +83,6 @@ export default function verifyProofStep(proofStepNode, substitutions, localConte
   return proofStepVerified;
 }
 
-Object.assign(verifySubDerivation, {
+Object.assign(shim, {
   verifyProofStep
 });

package/src/verify/statement/qualified.js

@@ -1,12 +1,17 @@
 "use strict";
 
+import verifyEquality from "../equality";
+import verifyJudgement from "../judgement";
+import verifyTypeAssertion from "../assertion/type";
+import unifyMetavariableAgainstStatement from "../../unify/metavariableAgainstStatement";
+
 import { nodeQuery } from "../../utilities/query";
-import { verifyStatementAsEquality, verifyStatementAsTypeAssertion } from "../../verify/statement";
 
 const statementNodeQuery = nodeQuery("/qualifiedStatement/statement!"),
-      metavariableNodeQuery = nodeQuery("/qualifiedStatement/reference/metavariable!");
-
-import verifyMetavariableAgainstStatement from "../../verify/metavariableAgainstStatement";
+      equalityNodeQuery = nodeQuery("/statement/equality!"),
+      judgementNodeQuery = nodeQuery("/statement/judgement!"),
+      metavariableNodeQuery = nodeQuery("/qualifiedStatement/reference/metavariable!"),
+      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
 
 export default function verifyQualifiedStatement(qualifiedStatementNode, substitutions, assignments, localContext) {
   let qualifiedStatementVerified;
@@ -184,7 +189,16 @@ function verifyQualifiedStatementAAgainstReference(qualifiedStatementNode, subst
 
   if (metavariablePresent) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
-          metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNode, substitutions, localContextA, localContextB, verifyAhead);
+          localContextA = null,
+          localContextB = localContext, ///
+          statementNodeB = statementNode, ///
+          substitutionNode = null,
+          metavariableNodeA = metavariableNode, ///
+          metavariableVerifiedAgainstStatement = unifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNode, substitutions, localContextA, localContextB, () => {
+            const verifiedAhead = true;
+
+            return verifiedAhead;
+          });
 
     qualifiedStatementVerifiedAgainstReference = metavariableVerifiedAgainstStatement; ///
   }
@@ -203,13 +217,14 @@ function verifyStatedStatement(statementNode, assignments, derived, localContext
 
   localContext.trace(`Verifying the '${statementString}' stated statement...`, statementNode);
 
-  const verifyStatementFunctions = [
-    verifyStatementAsEquality,
-    verifyStatementAsTypeAssertion
+  const verifyStatedStatementFunctions = [
+    verifyStatedStatementAsEquality,
+    verifyStatedStatementAsJudgement,
+    verifyStatedStatementAsTypeAssertion
   ];
 
-  verifyStatementFunctions.some((verifyStatementFunction) => {
-    const statedStatementVerified = verifyStatementFunction(statementNode, assignments, derived, localContext);
+  verifyStatedStatementFunctions.every((verifyStatedStatementFunction) => { ///
+    const statedStatementVerified = verifyStatedStatementFunction(statementNode, assignments, derived, localContext);
 
     if (statedStatementVerified) {
       return true;
@@ -224,3 +239,73 @@ function verifyStatedStatement(statementNode, assignments, derived, localContext
 
   return statedStatementVerified;
 }
+
+function verifyStatedStatementAsEquality(statementNode, assignments, derived, localContext) {
+  let statedStatementVerifiedAsEquality = true; ///
+
+  const equalityNode = equalityNodeQuery(statementNode);
+
+  if (equalityNode !== null) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the '${statementString}' stated statement as an equality...`, statementNode);
+
+    const equalityVerified = verifyEquality(equalityNode, assignments, derived, localContext, () => {
+      const verifiedAhead = true;
+
+      return verifiedAhead;
+    });
+
+    statedStatementVerifiedAsEquality = equalityVerified; ///
+
+    if (statedStatementVerifiedAsEquality) {
+      localContext.debug(`...verified the '${statementString}' stated statement as an equality.`, statementNode);
+    }
+  }
+
+  return statedStatementVerifiedAsEquality;
+}
+
+function verifyStatedStatementAsJudgement(statementNode, assignments, derived, localContext) {
+  let statedStatementVerifiedAsJudgement = true;
+
+  const judgementNode = judgementNodeQuery(statementNode);
+
+  if (judgementNode !== null) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the '${statementString}' stated statement as a judgement...`, statementNode);
+
+    const judgementVerified = verifyJudgement(judgementNode, assignments, derived, localContext);
+
+    statedStatementVerifiedAsJudgement = judgementVerified;  ///
+
+    if (statedStatementVerifiedAsJudgement) {
+      localContext.debug(`...verified the '${statementString}' stated statement as a judgement.`, statementNode);
+    }
+  }
+
+  return statedStatementVerifiedAsJudgement;
+}
+
+function verifyStatedStatementAsTypeAssertion(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAsTypeAssertion = true;  ///
+
+  const typeAssertionNode = typeAssertionNodeQuery(statementNode);
+
+  if (typeAssertionNode !== null) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the '${statementString}' stated statement as a type assertion...`, statementNode);
+
+    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, localContext);
+
+    statementVerifiedAsTypeAssertion = typeAssertionVerified; ///
+
+    if (statementVerifiedAsTypeAssertion) {
+      localContext.debug(`...verified the '${statementString}' stated statement as a type assertion.`, statementNode);
+    }
+  }
+
+  return statementVerifiedAsTypeAssertion;
+}

package/src/verify/statement/unqualified.js

@@ -1,11 +1,16 @@
 "use strict";
 
+import verifyEquality from "../../verify/equality";
+import verifyJudgement from "../../verify/judgement";
 import verifyStatement from "../../verify/statement";
+import verifyTypeAssertion from "../assertion/type";
 
 import { nodeQuery } from "../../utilities/query";
-import { verifyStatementAsEquality, verifyStatementAsTypeAssertion } from "../../verify/statement";
 
-const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
+const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
+      equalityNodeQuery = nodeQuery("/statement/equality!"),
+      judgementNodeQuery = nodeQuery("/statement/judgement!"),
+      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
 
 export default function verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext) {
   let unqualifiedStatementVerified;
@@ -43,9 +48,9 @@ function verifyDerivedUnqualifiedStatement(unqualifiedStatementNode, assignments
 
     localContext.trace(`Verifying the '${unqualifiedStatementString}' derived unqualified statement...`, unqualifiedStatementNode);
 
-    const matchesStatementNode = localContext.matchStatementNode(statementNode);
+    const statementUnified = localContext.unifyStatement(statementNode);
 
-    if (matchesStatementNode) {
+    if (statementUnified) {
       derivedUnqualifiedStatementVerified = true;
     } else {
       const statementNode = statementNodeQuery(unqualifiedStatementNode),
@@ -90,24 +95,93 @@ function verifyDerivedStatement(statementNode, assignments, derived, localContex
 
   localContext.trace(`Verifying the '${statementString}' derived statement...`, statementNode);
 
-  const verifyStatementFunctions = [
-    verifyStatementAsEquality,
-    verifyStatementAsTypeAssertion
+  const verifyDerivedStatementFunctions = [
+    verifyDerivedStatementAsEquality,
+    verifyDerivedStatementAsJudgement,
+    verifyDerivedStatementAsTypeAssertion
   ];
 
-  verifyStatementFunctions.some((verifyStatementFunction) => {
-    const derivedStatementVerified = verifyStatementFunction(statementNode, assignments, derived, localContext);
+  derivedStatementVerified = verifyDerivedStatementFunctions.every((verifyDerivedStatementFunction) => {  ///
+    const derivedStatementVerified = verifyDerivedStatementFunction(statementNode, assignments, derived, localContext);
 
     if (derivedStatementVerified) {
       return true;
     }
   });
 
-  derivedStatementVerified = true; ///
-
   if (derivedStatementVerified) {
     localContext.debug(`...verified the '${statementString}' derived statement.`, statementNode);
   }
 
   return derivedStatementVerified;
 }
+
+function verifyDerivedStatementAsEquality(statementNode, assignments, derived, localContext) {
+  let derivedStatementVerifiedAsEquality = true; ///
+
+  const equalityNode = equalityNodeQuery(statementNode);
+
+  if (equalityNode !== null) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the '${statementString}' derived statement as an equality...`, statementNode);
+
+    const equalityVerified = verifyEquality(equalityNode, assignments, derived, localContext, () => {
+      const verifiedAhead = true;
+
+      return verifiedAhead;
+    });
+
+    derivedStatementVerifiedAsEquality = equalityVerified; ///
+
+    if (derivedStatementVerifiedAsEquality) {
+      localContext.debug(`...verified the '${statementString}' derived statement as an equality.`, statementNode);
+    }
+  }
+
+  return derivedStatementVerifiedAsEquality;
+}
+
+function verifyDerivedStatementAsJudgement(statementNode, assignments, derived, localContext) {
+  let derivedStatementVerifiedAsJudgement = true;
+
+  const judgementNode = judgementNodeQuery(statementNode);
+
+  if (judgementNode !== null) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the '${statementString}' derived statement as a judgement...`, statementNode);
+
+    const judgementVerified = verifyJudgement(judgementNode, assignments, derived, localContext);
+
+    derivedStatementVerifiedAsJudgement = judgementVerified;  ///
+
+    if (derivedStatementVerifiedAsJudgement) {
+      localContext.debug(`...verified the '${statementString}' derived statement as a judgement.`, statementNode);
+    }
+  }
+
+  return derivedStatementVerifiedAsJudgement;
+}
+
+function verifyDerivedStatementAsTypeAssertion(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAsTypeAssertion = true;  ///
+
+  const typeAssertionNode = typeAssertionNodeQuery(statementNode);
+
+  if (typeAssertionNode !== null) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the '${statementString}' derived statement as a type assertion...`, statementNode);
+
+    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, localContext);
+
+    statementVerifiedAsTypeAssertion = typeAssertionVerified; ///
+
+    if (statementVerifiedAsTypeAssertion) {
+      localContext.debug(`...verified the '${statementString}' derived statement as a type assertion.`, statementNode);
+    }
+  }
+
+  return statementVerifiedAsTypeAssertion;
+}