occam-verify-cli 0.0.922 → 0.0.923

package/src/verifier/nodes/intrinsicLevelAgainstMetaLevel.js

@@ -11,10 +11,9 @@ const termNodeQuery = nodeQuery("/term!"),
       statementNodeQuery = nodeQuery("/statement!"),
       nonTerminalNodeQuery = nodeQuery("/*"),
       termVariableNodeQuery = nodeQuery("/term/variable!"),
-      metastatementNodeQuery = nodeQuery("/metastatement!"),
       metaArgumentStatementNodeQuery = nodeQuery("/metaArgument/statement!"),
-      metastatementMetavariableNodeQuery = nodeQuery("/metastatement/metavariable!"),
-      metastatementSubstitutionNodeQuery = nodeQuery("/metastatement/substitution");
+      statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!"),
+      statementSubstitutionNodeQuery = nodeQuery("/statement/substitution");
 
 class IntrinsicLevelAgainstMetaLevelNodesVerifier extends NodesVerifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead) {
@@ -22,54 +21,54 @@ class IntrinsicLevelAgainstMetaLevelNodesVerifier extends NodesVerifier {
 
     const nodeQueryMaps = [
       {
-        nodeQueryA: metastatementMetavariableNodeQuery,
+        nodeQueryA: statementMetavariableNodeQuery,
         nodeQueryB: metaArgumentStatementNodeQuery,
         verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const metaArgumentStatementNodeB = nodeB,  ///
-                metastatementMetavariableNodeA = nodeA, ///
-                metastatementSubstitutionNodeA = metastatementSubstitutionNodeQuery(nonTerminalNodeA),
-                metastatementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode =
+                statementMetavariableNodeA = nodeA, ///
+                statementSubstitutionNodeA = statementSubstitutionNodeQuery(nonTerminalNodeA),
+                statementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode =
 
-                  this.verifyMetastatementMetavariableNodeAgainstMetaArgumentStatementNode(metastatementMetavariableNodeA, metaArgumentStatementNodeB, metastatementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead);
+                  this.verifyStatementMetavariableNodeAgainstMetaArgumentStatementNode(statementMetavariableNodeA, metaArgumentStatementNodeB, statementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead);
 
-          nonTerminalNodeVerified = metastatementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode;  ///
+          nonTerminalNodeVerified = statementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode;  ///
 
           return nonTerminalNodeVerified;
         }
       },
       {
-        nodeQueryA: metastatementMetavariableNodeQuery,
+        nodeQueryA: statementMetavariableNodeQuery,
         nodeQueryB: statementNodeQuery,
         verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const statementNodeB = nodeB,  ///
-                metastatementMetavariableNodeA = nodeA, ///
-                metastatementSubstitutionNodeA = metastatementSubstitutionNodeQuery(nonTerminalNodeA),
-                metastatementMetavariableNodeVerifiedAgainstStatementNode =
+                statementMetavariableNodeA = nodeA, ///
+                statementSubstitutionNodeA = statementSubstitutionNodeQuery(nonTerminalNodeA),
+                statementMetavariableNodeVerifiedAgainstStatementNode =
 
-                  this.verifyMetastatementMetavariableNodeAgainstStatementNode(metastatementMetavariableNodeA, statementNodeB, metastatementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead);
+                  this.verifyStatementMetavariableNodeAgainstStatementNode(statementMetavariableNodeA, statementNodeB, statementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead);
 
-          nonTerminalNodeVerified = metastatementMetavariableNodeVerifiedAgainstStatementNode;  ///
+          nonTerminalNodeVerified = statementMetavariableNodeVerifiedAgainstStatementNode;  ///
 
           return nonTerminalNodeVerified;
         }
       },
       {
-        nodeQueryA: metastatementNodeQuery,
+        nodeQueryA: statementNodeQuery,
         nodeQueryB: statementNodeQuery,
         verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const statementNodeB = nodeB,  ///
-                metastatementNodeA = nodeA, ///
-                metastatementNodeVerifiedAgainstStatementNode =
+                statementNodeA = nodeA, ///
+                statementNodeVerifiedAgainstStatementNode =
 
-                  this.verifyMetastatementNodeAgainstStatementNode(metastatementNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead);
+                  this.verifyStatementNodeAgainstStatementNode(statementNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
-          nonTerminalNodeVerified = metastatementNodeVerifiedAgainstStatementNode;  ///
+          nonTerminalNodeVerified = statementNodeVerifiedAgainstStatementNode;  ///
 
           return nonTerminalNodeVerified;
         }
@@ -116,35 +115,35 @@ class IntrinsicLevelAgainstMetaLevelNodesVerifier extends NodesVerifier {
     return nonTerminalNodeVerified;
   }
 
-  verifyMetastatementMetavariableNodeAgainstMetaArgumentStatementNode(metastatementMetavariableNodeA, metaArgumentStatementNodeB, metastatementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead) {
-    let metastatementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode;
+  verifyStatementMetavariableNodeAgainstMetaArgumentStatementNode(statementMetavariableNodeA, metaArgumentStatementNodeB, statementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead) {
+    let statementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode;
 
     const statementNodeB = metaArgumentStatementNodeB, ///
-          substitutionNode = metastatementSubstitutionNodeA,  ///
-          metavariableNodeA = metastatementMetavariableNodeA,  ///
+          substitutionNode = statementSubstitutionNodeA,  ///
+          metavariableNodeA = statementMetavariableNodeA,  ///
           metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNode, substitutions, localContextA, localContextB, verifyAhead)
 
-    metastatementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode = metavariableVerifiedAgainstStatement; ///
+    statementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode = metavariableVerifiedAgainstStatement; ///
 
-    return metastatementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode;
+    return statementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode;
   }
 
-  verifyMetastatementMetavariableNodeAgainstStatementNode(metastatementMetavariableNodeA, statementNodeB, metastatementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead) {
-    let metastatementMetavariableNodeVerifiedAgainstStatementNode;
+  verifyStatementMetavariableNodeAgainstStatementNode(statementMetavariableNodeA, statementNodeB, statementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead) {
+    let statementMetavariableNodeVerifiedAgainstStatementNode;
 
-    const substitutionNode = metastatementSubstitutionNodeA,  ///
-          metavariableNodeA = metastatementMetavariableNodeA,  ///
+    const substitutionNode = statementSubstitutionNodeA,  ///
+          metavariableNodeA = statementMetavariableNodeA,  ///
           metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNode, substitutions, localContextA, localContextB, verifyAhead)
 
-    metastatementMetavariableNodeVerifiedAgainstStatementNode = metavariableVerifiedAgainstStatement; ///
+    statementMetavariableNodeVerifiedAgainstStatementNode = metavariableVerifiedAgainstStatement; ///
 
-    return metastatementMetavariableNodeVerifiedAgainstStatementNode;
+    return statementMetavariableNodeVerifiedAgainstStatementNode;
   }
 
-  verifyMetastatementNodeAgainstStatementNode(metastatementNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead) {
-    let metastatementNodeVerifiedAgainstStatementNode;
+  verifyStatementNodeAgainstStatementNode(statementNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead) {
+    let statementNodeVerifiedAgainstStatementNode;
 
-    const nonTerminalNodeA = metastatementNodeA,  ///
+    const nonTerminalNodeA = statementNodeA,  ///
           nonTerminalNodeB = statementNodeB,  ///
           nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
           nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
@@ -152,9 +151,9 @@ class IntrinsicLevelAgainstMetaLevelNodesVerifier extends NodesVerifier {
           childNodesB = nonTerminalNodeBChildNodes, ///
           childNodesVerified = this.verifyChildNodes(childNodesA, childNodesB, substitutions, localContextA, localContextB, verifyAhead);
 
-    metastatementNodeVerifiedAgainstStatementNode = childNodesVerified; ///
+    statementNodeVerifiedAgainstStatementNode = childNodesVerified; ///
 
-    return metastatementNodeVerifiedAgainstStatementNode;
+    return statementNodeVerifiedAgainstStatementNode;
   }
 
   verifyTermVariableNodeAgainstTermNode(termVariableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {

package/src/verifier/nodes/metaLevel.js

@@ -2,16 +2,16 @@
 
 import NodesVerifier from "../../verifier/nodes";
 import verifyVariableAgainstTerm from "../../verify/variableAgainstTerm";
-import verifyMetavariableAgainstMetastatement from "../../verify/metavariableAgainstMetastatement";
+import verifyMetavariableAgainstStatement from "../../verify/metavariableAgainstStatement";
 
 import { nodeQuery } from "../../utilities/query";
 import { verifyNodes } from "../../utilities/verifier";
 
 const termNodeQuery = nodeQuery("/term!"),
       nonTerminalNodeQuery = nodeQuery("/*"),
+      statementNodeQuery = nodeQuery("/statement!"),
       termVariableNodeQuery = nodeQuery("/term/variable!"),
-      metastatementNodeQuery = nodeQuery("/metastatement!"),
-      metastatementMetavariableNodeQuery = nodeQuery("/metastatement/metavariable!");
+      statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!");
 
 class MetaLevelNodesVerifier extends NodesVerifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead) {
@@ -19,18 +19,18 @@ class MetaLevelNodesVerifier extends NodesVerifier {
 
     const nodeQueryMaps = [
       {
-        nodeQueryA: metastatementMetavariableNodeQuery,
-        nodeQueryB: metastatementNodeQuery,
+        nodeQueryA: statementMetavariableNodeQuery,
+        nodeQueryB: statementNodeQuery,
         verifyNodes: (nodeA, nodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead) => {
           let nonTerminalNodeVerified;
 
-          const metastatementNodeB = nodeB, ///
-                metastatementMetavariableNodeA = nodeA, ///
-                metastatementMetavariableNodeVerifiedAgainstMetastatementNode =
+          const statementNodeB = nodeB, ///
+                statementMetavariableNodeA = nodeA, ///
+                statementMetavariableNodeVerifiedAgainstStatementNode =
 
-                  this.verifyMetastatementMetavariableNodeAgainstMetastatementNode(metastatementMetavariableNodeA, metastatementNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead);
+                  this.verifyStatementMetavariableNodeAgainstStatementNode(statementMetavariableNodeA, statementNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead);
 
-          nonTerminalNodeVerified = metastatementMetavariableNodeVerifiedAgainstMetastatementNode;  ///
+          nonTerminalNodeVerified = statementMetavariableNodeVerifiedAgainstStatementNode;  ///
 
           return nonTerminalNodeVerified;
         }
@@ -77,16 +77,16 @@ class MetaLevelNodesVerifier extends NodesVerifier {
     return nonTerminalNodeVerified;
   }
 
-  verifyMetastatementMetavariableNodeAgainstMetastatementNode(metastatementMetavariableNodeA, metastatementNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead) {
-    let metastatementMetavariableNodeVerifiedAgainstMetastatementNode;
+  verifyStatementMetavariableNodeAgainstStatementNode(statementMetavariableNodeA, statementNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead) {
+    let statementMetavariableNodeVerifiedAgainstStatementNode;
 
-    const metavariableNode = metastatementMetavariableNodeA, ///
-          metastatementNode = metastatementNodeB, ///
-          metavariableVerifiedAgainstMetastatement = verifyMetavariableAgainstMetastatement(metavariableNode, metastatementNode, substitutions, verifyAhead);
+    const metavariableNode = statementMetavariableNodeA, ///
+          statementNode = statementNodeB, ///
+          metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNode, statementNode, substitutions, verifyAhead);
 
-    metastatementMetavariableNodeVerifiedAgainstMetastatementNode = metavariableVerifiedAgainstMetastatement;  ///
+    statementMetavariableNodeVerifiedAgainstStatementNode = metavariableVerifiedAgainstStatement;  ///
 
-    return metastatementMetavariableNodeVerifiedAgainstMetastatementNode;
+    return statementMetavariableNodeVerifiedAgainstStatementNode;
   }
 
   verifyTermVariableNodeAgainstTermNode(termVariableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {

package/src/verify/conclusion.js

@@ -1,15 +1,12 @@
 "use strict";
 
 import Conclusion from "../conclusion";
-import verifyUnqualifiedStatement from "./statement/unqualified";
-import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
+import verifyUnqualifiedStatement from "../verify/statement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
-      metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
-      unqualifiedStatementNodeQuery = nodeQuery("/conclusion/unqualifiedStatement!"),
-      unqualifiedMetastatementNodeQuery = nodeQuery("/conclusion/unqualifiedMetastatement!");
+      unqualifiedStatementNodeQuery = nodeQuery("/conclusion/unqualifiedStatement!");
 
 export default function verifyConclusion(conclusionNode, conclusions, localContext) {
   let conclusionVerified = false;
@@ -18,8 +15,7 @@ export default function verifyConclusion(conclusionNode, conclusions, localConte
 
   localContext.trace(`Verifying the '${conclusionString}' conclusion...`, conclusionNode);
 
-  const unqualifiedStatementNode = unqualifiedStatementNodeQuery(conclusionNode),
-        unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(conclusionNode);
+  const unqualifiedStatementNode = unqualifiedStatementNodeQuery(conclusionNode);
 
   if (unqualifiedStatementNode !== null) {
     const derived = false,
@@ -29,12 +25,12 @@ export default function verifyConclusion(conclusionNode, conclusions, localConte
     conclusionVerified = unqualifiedStatementVerified; ///
   }
 
-  if (unqualifiedMetastatementNode !== null) {
+  if (unqualifiedStatementNode !== null) {
     const derived = false,
           assignments = [],
-          unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localContext);
+          unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
 
-    conclusionVerified = unqualifiedMetastatementVerified; ///
+    conclusionVerified = unqualifiedStatementVerified; ///
   }
 
   if (conclusionVerified) {
@@ -46,10 +42,10 @@ export default function verifyConclusion(conclusionNode, conclusions, localConte
       conclusion = Conclusion.fromStatementNode(statementNode);
     }
 
-    if (unqualifiedMetastatementNode !== null) {
-      const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
+    if (unqualifiedStatementNode !== null) {
+      const statementNode = statementNodeQuery(unqualifiedStatementNode);
 
-      conclusion = Conclusion.fromMetastatementNode(metastatementNode);
+      conclusion = Conclusion.fromStatementNode(statementNode);
     }
 
     conclusions.push(conclusion);

package/src/verify/declaration.js

@@ -7,8 +7,8 @@ import metaLevelNodeVerifier from "../verifier/node/metaLevel";
 import { nodeQuery } from "../utilities/query";
 
 const referenceNodeQuery = nodeQuery("/declaration/reference!"),
-      metavariableNodeQuery = nodeQuery("/reference/metavariable!"),
-      metastatementNodeQuery = nodeQuery("/declaration/metastatement!");
+      statementNodeQuery = nodeQuery("/declaration/statement!"),
+      metavariableNodeQuery = nodeQuery("/reference/metavariable!");
 
 export default function verifyDeclaration(declarationNode, declarations, localContext) {
   let declarationVerified = false;
@@ -21,20 +21,20 @@ export default function verifyDeclaration(declarationNode, declarations, localCo
         referenceVerified = verifyReference(referenceNode, localContext);
 
   if (referenceVerified) {
-    const metastatementNode = metastatementNodeQuery(declarationNode);
+    const statementNode = statementNodeQuery(declarationNode);
 
-    const { verifyMetastatement } = metaLevelNodeVerifier,
+    const { verifyStatement } = metaLevelNodeVerifier,
           derived = false,
           assignments = [],
-          metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localContext, () => {
+          statementVerified = verifyStatement(statementNode, assignments, derived, localContext, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;
           });
 
-    if (metastatementVerified) {
+    if (statementVerified) {
       const metavariableNode = metavariableNodeQuery(referenceNode),
-            declaration = Declaration.fromMetavariableNodeAndMetastatementNode(metavariableNode, metastatementNode);
+            declaration = Declaration.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode);
 
       declarations.push(declaration);
 

package/src/verify/metaLemma.js

@@ -1,20 +1,20 @@
 "use strict";
 
 import MetaLemma from "../metaLemma";
+import verifyProof from "../verify/proof";
 import LocalContext from "../context/local";
 import verifyLabels from "../verify/labels";
-import verifyMetaproof from "../verify/metaproof";
-import verifyMetaConsequent from "../verify/metaConsequent";
-import verifyMetaSuppositions from "../verify/metaSuppositions";
+import verifyConsequent from "../verify/consequent";
+import verifySuppositions from "../verify/suppositions";
 
 import { first } from "../utilities/array";
 import { EMPTY_STRING } from "../constants";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const labelNodesQuery = nodesQuery("/metaLemma/label"),
-      metaproofNodeQuery = nodeQuery("/metaLemma/metaproof!"),
-      metaConsequentNodeQuery = nodeQuery("/metaLemma/metaConsequent!"),
-      metaSuppositionsNodeQuery = nodesQuery("/metaLemma/metaSupposition");
+const proofNodeQuery = nodeQuery("/metaLemma/proof!"),
+      labelNodesQuery = nodesQuery("/metaLemma/label"),
+      consequentNodeQuery = nodeQuery("/metaLemma/consequent!"),
+      suppositionsNodeQuery = nodesQuery("/metaLemma/supposition");
 
 export default function verifyMetaLemma(metaLemmaNode, fileContext) {
   let metaLemmaVerified = false;
@@ -32,24 +32,24 @@ export default function verifyMetaLemma(metaLemmaNode, fileContext) {
   if (labelsVerified) {
     const localContext = LocalContext.fromFileContext(fileContext), ///
           substitutions = [],
-          metaSuppositions = [],
-          metaSuppositionNodes = metaSuppositionsNodeQuery(metaLemmaNode),
-          metaSuppositionsVerified = verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, substitutions, localContext);
+          suppositions = [],
+          suppositionNodes = suppositionsNodeQuery(metaLemmaNode),
+          suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, substitutions, localContext);
 
-    if (metaSuppositionsVerified) {
-      const metaConsequents = [],
-            metaConsequentNode = metaConsequentNodeQuery(metaLemmaNode),
-            metaConsequentVerified = verifyMetaConsequent(metaConsequentNode, metaConsequents, substitutions, localContext);
+    if (suppositionsVerified) {
+      const consequents = [],
+            consequentNode = consequentNodeQuery(metaLemmaNode),
+            consequentVerified = verifyConsequent(consequentNode, consequents, substitutions, localContext);
 
-      if (metaConsequentVerified) {
-        const metaproofNode = metaproofNodeQuery(metaLemmaNode),
-              firstMetaConsequent = first(metaConsequents),
-              metaConsequent = firstMetaConsequent, ///
-              metastatementNode = metaConsequent.getMetastatementNode(),
-              metaproofVerified = verifyMetaproof(metaproofNode, metastatementNode, substitutions, localContext);
+      if (consequentVerified) {
+        const proofNode = proofNodeQuery(metaLemmaNode),
+              firstConsequent = first(consequents),
+              consequent = firstConsequent, ///
+              statementNode = consequent.getStatementNode(),
+              proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);
 
-        if (metaproofVerified) {
-          const metaLemma = MetaLemma.fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(labels, metaSuppositions, metaConsequent, substitutions, fileContext);
+        if (proofVerified) {
+          const metaLemma = MetaLemma.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext);
 
           fileContext.addMetaLemma(metaLemma);
 

package/src/verify/metastatement.js

@@ -2,142 +2,142 @@
 
 import verifyJudgement from "../verify/judgement";
 import metaLevelNodeVerifier from "../verifier/node/metaLevel";
-import verifyMetastatementAsDefinedAssertion from "./metastatementAsDefinedAssertion";
-import verifyMetastatementAsContainedAssertion from "./metastatementAsContainedAssertion";
+import verifyStatementAsDefinedAssertion from "./statementAsDefinedAssertion";
+import verifyStatementAsContainedAssertion from "./statementAsContainedAssertion";
 
 import { nodeQuery } from "../utilities/query";
 
-const judgementNodeQuery = nodeQuery("/metastatement/judgement!");
+const judgementNodeQuery = nodeQuery("/statement/judgement!");
 
-function verifyMetastatement(metastatementNode, assignments, derived, localContext) {
-  let metastatementVerified;
+function verifyStatement(statementNode, assignments, derived, localContext) {
+  let statementVerified;
 
-  const metastatementString = localContext.nodeAsString(metastatementNode);
+  const statementString = localContext.nodeAsString(statementNode);
 
-  localContext.trace(`Verifying the '${metastatementString}' metastatement...`, metastatementNode);
+  localContext.trace(`Verifying the '${statementString}' statement...`, statementNode);
 
-  const verifyMetaStatementFunctions = [
-    verifyMetastatementAsJudgement,
-    verifyMetastatementAsDefinedAssertion,
-    verifyMetastatementAsContainedAssertion,
-    verifyMetastatementAsIs
+  const verifyStatementFunctions = [
+    verifyStatementAsJudgement,
+    verifyStatementAsDefinedAssertion,
+    verifyStatementAsContainedAssertion,
+    verifyStatementAsIs
   ];
 
-  metastatementVerified = verifyMetaStatementFunctions.some((verifyStatementFunction) => {
-    const metastatementVerified = verifyStatementFunction(metastatementNode, assignments, derived, localContext);
+  statementVerified = verifyStatementFunctions.some((verifyStatementFunction) => {
+    const statementVerified = verifyStatementFunction(statementNode, assignments, derived, localContext);
 
-    if (metastatementVerified) {
+    if (statementVerified) {
       return true;
     }
   });
 
-  if (metastatementVerified) {
-    localContext.debug(`...verified the '${metastatementString}' metastatement.`, metastatementNode);
+  if (statementVerified) {
+    localContext.debug(`...verified the '${statementString}' statement.`, statementNode);
   }
 
-  return metastatementVerified;
+  return statementVerified;
 }
 
 Object.assign(metaLevelNodeVerifier, {
-  verifyMetastatement
+  verifyStatement
 });
 
-export default verifyMetastatement;
+export default verifyStatement;
 
-function verifyMetastatementAsJudgement(metastatementNode, assignments, derived, localContext) {
-  let metastatementVerifiedAsJudgement = false;
+function verifyStatementAsJudgement(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAsJudgement = false;
 
-  const metastatementJudgement = isMetastatementJudgement(metastatementNode);
+  const statementJudgement = isStatementJudgement(statementNode);
 
-  if (metastatementJudgement) {
-    const metastatementString = localContext.nodeAsString(metastatementNode);
+  if (statementJudgement) {
+    const statementString = localContext.nodeAsString(statementNode);
 
-    localContext.trace(`Verifying the '${metastatementString}' metastatement as a judgement...`, metastatementNode);
+    localContext.trace(`Verifying the '${statementString}' statement as a judgement...`, statementNode);
 
-    const judgementNode = judgementNodeQuery(metastatementNode),
+    const judgementNode = judgementNodeQuery(statementNode),
           judgementVerified = verifyJudgement(judgementNode, assignments, derived, localContext);
 
-    metastatementVerifiedAsJudgement = judgementVerified;  ///
+    statementVerifiedAsJudgement = judgementVerified;  ///
 
-    if (metastatementVerifiedAsJudgement) {
-      localContext.debug(`...verified the '${metastatementString}' metastatement as a judgement.`, metastatementNode);
+    if (statementVerifiedAsJudgement) {
+      localContext.debug(`...verified the '${statementString}' statement as a judgement.`, statementNode);
     }
   }
 
-  return metastatementVerifiedAsJudgement;
+  return statementVerifiedAsJudgement;
 }
 
-function verifyMetastatementAsIs(metastatementNode, assignments, derived, localContext) {
-  let metastatementVerifiedAsIs;
+function verifyStatementAsIs(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAsIs;
 
-  const metastatementJudgement = isMetastatementJudgement(metastatementNode);
+  const statementJudgement = isStatementJudgement(statementNode);
 
-  if (!metastatementJudgement) {
-    const metastatementString = localContext.nodeAsString(metastatementNode);
+  if (!statementJudgement) {
+    const statementString = localContext.nodeAsString(statementNode);
 
-    localContext.trace(`Verifying the '${metastatementString}' metastatement as is...`, metastatementNode);
+    localContext.trace(`Verifying the '${statementString}' statement as is...`, statementNode);
 
-    const verifyMetastatementAsIsFunctions = [
-      verifyDerivedMetastatementAsIs,
-      verifyStatedMetastatementAsIs
+    const verifyStatementAsIsFunctions = [
+      verifyDerivedStatementAsIs,
+      verifyStatedStatementAsIs
     ];
 
-    metastatementVerifiedAsIs = verifyMetastatementAsIsFunctions.some((verifyMetastatementAsIsFunction) => {
-      const metastatementVerifiedAsIs = verifyMetastatementAsIsFunction(metastatementNode, assignments, derived, localContext);
+    statementVerifiedAsIs = verifyStatementAsIsFunctions.some((verifyStatementAsIsFunction) => {
+      const statementVerifiedAsIs = verifyStatementAsIsFunction(statementNode, assignments, derived, localContext);
 
-      if (metastatementVerifiedAsIs) {
+      if (statementVerifiedAsIs) {
         return true;
       }
     });
 
-    if (metastatementVerifiedAsIs) {
-      localContext.debug(`...verified the '${metastatementString}' metastatement as is.`, metastatementNode);
+    if (statementVerifiedAsIs) {
+      localContext.debug(`...verified the '${statementString}' statement as is.`, statementNode);
     }
   }
 
-  return metastatementVerifiedAsIs;
+  return statementVerifiedAsIs;
 }
 
-function verifyDerivedMetastatementAsIs(metastatementNode, assignments, derived, localContext) {
-  let derivedMetastatementVerifiedAsIs = false;
+function verifyDerivedStatementAsIs(statementNode, assignments, derived, localContext) {
+  let derivedStatementVerifiedAsIs = false;
 
   if (derived) {
-    const metastatementString = localContext.nodeAsString(metastatementNode);
+    const statementString = localContext.nodeAsString(statementNode);
 
-    localContext.debug(`Cannot verify the derived '${metastatementString}' metastatement as is.`, metastatementNode);
+    localContext.debug(`Cannot verify the derived '${statementString}' statement as is.`, statementNode);
   }
 
-  return derivedMetastatementVerifiedAsIs;
+  return derivedStatementVerifiedAsIs;
 }
 
-function verifyStatedMetastatementAsIs(metastatementNode, assignments, derived, localContext) {
-  let statedMetastatementVerifiedAsIs = false;
+function verifyStatedStatementAsIs(statementNode, assignments, derived, localContext) {
+  let statedStatementVerifiedAsIs = false;
 
   if (!derived) {
-    const metastatementString = localContext.nodeAsString(metastatementNode);
+    const statementString = localContext.nodeAsString(statementNode);
 
-    localContext.trace(`Verifying the stated '${metastatementString}' metastatement as is...`, metastatementNode);
+    localContext.trace(`Verifying the stated '${statementString}' statement as is...`, statementNode);
 
-    const nonTerminalNode = metastatementNode, ///
+    const nonTerminalNode = statementNode, ///
           nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;
           });
 
-    statedMetastatementVerifiedAsIs = nonTerminalNodeVerified;  ///
+    statedStatementVerifiedAsIs = nonTerminalNodeVerified;  ///
 
-    if (statedMetastatementVerifiedAsIs) {
-      localContext.debug(`...verified the stated '${metastatementString}' metastatement as is.`, metastatementNode);
+    if (statedStatementVerifiedAsIs) {
+      localContext.debug(`...verified the stated '${statementString}' statement as is.`, statementNode);
     }
   }
 
-  return statedMetastatementVerifiedAsIs;
+  return statedStatementVerifiedAsIs;
 }
 
-function isMetastatementJudgement(metastatementNode) {
-  const judgementNode = judgementNodeQuery(metastatementNode),
-        metastatementJudgement = (judgementNode !== null);
+function isStatementJudgement(statementNode) {
+  const judgementNode = judgementNodeQuery(statementNode),
+        statementJudgement = (judgementNode !== null);
 
-  return metastatementJudgement;
+  return statementJudgement;
 }