occam-verify-cli 0.0.913 → 0.0.915

package/src/verify/lemma.js

@@ -2,10 +2,10 @@
 
 import Lemma from "../lemma";
 import verifyProof from "../verify/proof";
-import LocalContext from "../context/local";
 import verifyLabels from "../verify/labels";
 import verifyConsequent from "../verify/consequent";
 import verifySuppositions from "../verify/suppositions";
+import IntrinsicLevelLocalContext from "../context/local/intrinsicLevel";
 
 import { first } from "../utilities/array";
 import { EMPTY_STRING } from "../constants";
@@ -19,9 +19,10 @@ const proofNodeQuery = nodeQuery("/lemma/proof!"),
 export default function verifyLemma(lemmaNode, fileContext) {
   let lemmaVerified = false;
 
-  const labelNodes = labelNodesQuery(lemmaNode),
+  const intrinsicLevelLocalContext = IntrinsicLevelLocalContext.fromFileContext(fileContext),
+        labelNodes = labelNodesQuery(lemmaNode),
         labelsString = fileContext.nodesAsString(labelNodes),
-        localContext = LocalContext.fromFileContext(fileContext);
+        localContext = intrinsicLevelLocalContext;  ///
 
   (labelsString === EMPTY_STRING) ?
     fileContext.trace(`Verifying a lemma...`, lemmaNode) :

package/src/verify/metaConsequent.js

@@ -11,12 +11,12 @@ const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
       unqualifiedStatementNodeQuery = nodeQuery("/metaConsequent/unqualifiedStatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/metaConsequent/unqualifiedMetastatement!");
 
-export default function verifyMetaConsequent(metaConsequentNode, metaConsequents, substitutions, localMetaContext) {
+export default function verifyMetaConsequent(metaConsequentNode, metaConsequents, substitutions, localContext) {
   let metaConsequentVerified = false;
 
-  const metaConsequentString = localMetaContext.nodeAsString(metaConsequentNode);
+  const metaConsequentString = localContext.nodeAsString(metaConsequentNode);
 
-  localMetaContext.trace(`Verifying the '${metaConsequentString}' meta-consequent...`, metaConsequentNode);
+  localContext.trace(`Verifying the '${metaConsequentString}' meta-consequent...`, metaConsequentNode);
 
   const unqualifiedStatementNode = unqualifiedStatementNodeQuery(metaConsequentNode),
         unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(metaConsequentNode);
@@ -24,7 +24,6 @@ export default function verifyMetaConsequent(metaConsequentNode, metaConsequents
   if (unqualifiedStatementNode !== null) {
     const derived = false,
           assignments = [],
-          localContext = localMetaContext,  ///
           unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
 
     metaConsequentVerified = unqualifiedStatementVerified; ///
@@ -33,7 +32,7 @@ export default function verifyMetaConsequent(metaConsequentNode, metaConsequents
   if (unqualifiedMetastatementNode !== null) {
     const derived = false,
           assignments = [],
-          unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
+          unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localContext);
 
     metaConsequentVerified = unqualifiedMetastatementVerified; ///
   }
@@ -55,7 +54,7 @@ export default function verifyMetaConsequent(metaConsequentNode, metaConsequents
 
     metaConsequents.push(metaConsequent);
 
-    localMetaContext.debug(`...verified the '${metaConsequentString}' meta-consequent.`, metaConsequentNode);
+    localContext.debug(`...verified the '${metaConsequentString}' meta-consequent.`, metaConsequentNode);
   }
 
   return metaConsequentVerified;

package/src/verify/metaDerivation.js

@@ -6,13 +6,13 @@ import { nodesQuery } from "../utilities/query";
 
 const metaproofStepNodesQuery = nodesQuery("/metaDerivation/metaproofStep|lastMetaproofStep");
 
-export default function verifyMetaDerivation(metaDerivationNode, substitutions, localMetaContext) {
+export default function verifyMetaDerivation(metaDerivationNode, substitutions, localContext) {
   let metaDerivationVerified;
 
   const metaproofStepNodes = metaproofStepNodesQuery(metaDerivationNode);
 
   metaDerivationVerified = metaproofStepNodes.every((metaproofStepNode) => {
-    const metaproofStepVerified = verifyMetaproofStep(metaproofStepNode, substitutions, localMetaContext);
+    const metaproofStepVerified = verifyMetaproofStep(metaproofStepNode, substitutions, localContext);
 
     if (metaproofStepVerified) {
       return true;

package/src/verify/metaLemma.js

@@ -3,8 +3,8 @@
 import MetaLemma from "../metaLemma";
 import verifyLabels from "../verify/labels";
 import verifyMetaproof from "../verify/metaproof";
-import LocalMetaContext from "../context/localMeta";
 import verifyMetaConsequent from "../verify/metaConsequent";
+import MetaLevelLocalContext from "../context/local/metaLevel";
 import verifyMetaSuppositions from "../verify/metaSuppositions";
 
 import { first } from "../utilities/array";
@@ -20,8 +20,7 @@ export default function verifyMetaLemma(metaLemmaNode, fileContext) {
   let metaLemmaVerified = false;
 
   const labelNodes = labelNodesQuery(metaLemmaNode),
-        labelsString = fileContext.nodesAsString(labelNodes),
-        localMetaContext = LocalMetaContext.fromFileContext(fileContext);
+        labelsString = fileContext.nodesAsString(labelNodes);
 
   (labelsString === EMPTY_STRING) ?
     fileContext.trace(`Verifying a meta-lLemma...`, metaLemmaNode) :
@@ -31,21 +30,23 @@ export default function verifyMetaLemma(metaLemmaNode, fileContext) {
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
-    const substitutions = [],
+    const metaLevelLocalContext = MetaLevelLocalContext.fromFileContext(fileContext),
+          localContext = metaLevelLocalContext, ///
+          substitutions = [],
           metaSuppositions = [],
           metaSuppositionNodes = metaSuppositionsNodeQuery(metaLemmaNode),
-          metaSuppositionsVerified = verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, substitutions, localMetaContext);
+          metaSuppositionsVerified = verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, substitutions, localContext);
 
     if (metaSuppositionsVerified) {
       const metaConsequents = [],
             metaConsequentNode = metaConsequentNodeQuery(metaLemmaNode),
-            metaConsequentVerified = verifyMetaConsequent(metaConsequentNode, metaConsequents, substitutions, localMetaContext);
+            metaConsequentVerified = verifyMetaConsequent(metaConsequentNode, metaConsequents, substitutions, localContext);
 
       if (metaConsequentVerified) {
         const metaproofNode = metaproofNodeQuery(metaLemmaNode),
               firstMetaConsequent = first(metaConsequents),
               metaConsequent = firstMetaConsequent, ///
-              metaproofVerified = verifyMetaproof(metaproofNode, metaConsequent, substitutions, localMetaContext);
+              metaproofVerified = verifyMetaproof(metaproofNode, metaConsequent, substitutions, localContext);
 
         if (metaproofVerified) {
           const metaLemma = MetaLemma.fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(labels, metaSuppositions, metaConsequent, substitutions, fileContext);

package/src/verify/metaSubDerivation.js

@@ -4,14 +4,14 @@ import { nodesQuery } from "../utilities/query";
 
 const metaproofStepNodesQuery = nodesQuery("/metaSubDerivation/metaproofStep|lastMetaproofStep");
 
-export default function verifyMetaSubDerivation(metaSubDerivationNode, substitutions, localMetaContext) {
+export default function verifyMetaSubDerivation(metaSubDerivationNode, substitutions, localContext) {
   let metaSubDerivationVerified;
 
   const metaproofStepNodes = metaproofStepNodesQuery(metaSubDerivationNode);
 
   metaSubDerivationVerified = metaproofStepNodes.every((metaproofStepNode) => {
     const { verifyMetaproofStep } = verifyMetaSubDerivation,
-          metaproofStepVerified = verifyMetaproofStep(metaproofStepNode, substitutions, localMetaContext);
+          metaproofStepVerified = verifyMetaproofStep(metaproofStepNode, substitutions, localContext);
 
     if (metaproofStepVerified) {
       return true;

package/src/verify/metaSubproof.js

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

package/src/verify/metaSupposition.js

@@ -13,12 +13,12 @@ const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
       unqualifiedStatementNodeQuery = nodeQuery("/metaSupposition/unqualifiedStatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/metaSupposition/unqualifiedMetastatement!");
 
-export default function verifyMetaSupposition(metaSuppositionNode, metaSuppositions, localMetaContext) {
+export default function verifyMetaSupposition(metaSuppositionNode, metaSuppositions, localContext) {
   let metaSuppositionVerified = false;
 
-  const metaSuppositionString = localMetaContext.nodeAsString(metaSuppositionNode);
+  const metaSuppositionString = localContext.nodeAsString(metaSuppositionNode);
 
-  localMetaContext.trace(`Verifying the '${metaSuppositionString}' meta-supposition...`, metaSuppositionNode);
+  localContext.trace(`Verifying the '${metaSuppositionString}' meta-supposition...`, metaSuppositionNode);
 
   const unqualifiedStatementNode = unqualifiedStatementNodeQuery(metaSuppositionNode),
         unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(metaSuppositionNode);
@@ -26,7 +26,6 @@ export default function verifyMetaSupposition(metaSuppositionNode, metaSuppositi
   if (unqualifiedStatementNode !== null) {
     const derived = false,
           assignments = [],
-          localContext = localMetaContext,  ///
           unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
 
     if (unqualifiedStatementVerified) {
@@ -39,10 +38,10 @@ export default function verifyMetaSupposition(metaSuppositionNode, metaSuppositi
   if (unqualifiedMetastatementNode !== null) {
     const derived = false,
           assignments = [],
-          unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
+          unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localContext);
 
     if (unqualifiedMetastatementVerified) {
-      const localContext = localMetaContext,  ///
+      const localContext = localContext,  ///
             assignmentAssigned = assignAssignment(assignments, localContext);
 
       metaSuppositionVerified = assignmentAssigned; ///
@@ -71,9 +70,9 @@ export default function verifyMetaSupposition(metaSuppositionNode, metaSuppositi
 
     metaSuppositions.push(metaSupposition);
 
-    localMetaContext.addMetaproofStep(metaproofStep);
+    localContext.addMetaproofStep(metaproofStep);
 
-    localMetaContext.debug(`...verified the '${metaSuppositionString}' meta-supposition.`, metaSuppositionNode);
+    localContext.debug(`...verified the '${metaSuppositionString}' meta-supposition.`, metaSuppositionNode);
   }
 
   return metaSuppositionVerified;

package/src/verify/metaSuppositions.js

@@ -2,11 +2,11 @@
 
 import verifyMetaSupposition from "../verify/metaSupposition";
 
-export default function verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, substitutions, localMetaContext) {
+export default function verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, substitutions, localContext) {
   let metaSuppositionsVerified;
 
   metaSuppositionsVerified = metaSuppositionNodes.every((metaSuppositionNode) => {
-    const metaSuppositionVerified = verifyMetaSupposition(metaSuppositionNode, metaSuppositions, localMetaContext);
+    const metaSuppositionVerified = verifyMetaSupposition(metaSuppositionNode, metaSuppositions, localContext);
 
     if (metaSuppositionVerified) {
       return true;

package/src/verify/metaproof.js

@@ -1,22 +1,24 @@
 "use strict";
 
-import LocalMetaContext from "../context/localMeta";
 import verifyMetaDerivation from "../verify/metaDerivation";
+import MetaLevelLocalContext from "../context/local/metaLevel";
 
 import { nodeQuery } from "../utilities/query";
 
 const metaDerivationNodeQuery = nodeQuery("/metaproof/metaDerivation!");
 
-export default function verifyMetaproof(metaproofNode, conclusion, substitutions, localMetaContext) {
+export default function verifyMetaproof(metaproofNode, conclusion, substitutions, localContext) {
   let metaproofVerified = false;
 
-  localMetaContext = LocalMetaContext.fromLocalMetaContext(localMetaContext); ///
+  const metaLevelLocalContext = MetaLevelLocalContext.fromLocalContext(localContext);
+
+  localContext = metaLevelLocalContext; ///
 
   const metaDerivationNode = metaDerivationNodeQuery(metaproofNode),
-        metaDerivationVerified = verifyMetaDerivation(metaDerivationNode, substitutions, localMetaContext);
+        metaDerivationVerified = verifyMetaDerivation(metaDerivationNode, substitutions, localContext);
 
   if (metaDerivationVerified) {
-    const lastMetaproofStep = localMetaContext.getLastMetaproofStep(),
+    const lastMetaproofStep = localContext.getLastMetaproofStep(),
           metaproofStep = lastMetaproofStep, ///
           metastatementNode = metaproofStep.getMetastatementNode(),
           conclusionMetastatementNode = conclusion.getMetastatementNode(),

package/src/verify/metaproofStep.js

@@ -18,7 +18,7 @@ const metaSubproofNodeQuery = nodeQuery("/metaproofStep|lastMetaproofStep/metaSu
       qualifiedMetastatementNodeQuery = nodeQuery("/metaproofStep|lastMetaproofStep/qualifiedMetastatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/metaproofStep|lastMetaproofStep/unqualifiedMetastatement!");
 
-export default function verifyMetaproofStep(metaproofStepNode, substitutions, localMetaContext) {
+export default function verifyMetaproofStep(metaproofStepNode, substitutions, localContext) {
   let metaproofStepVerified = false;
 
   const metaSubproofNode = metaSubproofNodeQuery(metaproofStepNode),
@@ -32,20 +32,19 @@ export default function verifyMetaproofStep(metaproofStepNode, substitutions, lo
   } else if (metaSubproofNode !== null) {
     let metaSubproofVerified;
 
-    metaSubproofVerified = verifyMetaSubproof(metaSubproofNode, substitutions, localMetaContext);
+    metaSubproofVerified = verifyMetaSubproof(metaSubproofNode, substitutions, localContext);
 
     if (metaSubproofVerified) {
       const metaproofStep = MetaproofStep.fromMetaSubproofNode(metaSubproofNode);
 
-      localMetaContext.addMetaproofStep(metaproofStep);
+      localContext.addMetaproofStep(metaproofStep);
 
       metaproofStepVerified = true;
     }
   } else if (qualifiedStatementNode !== null) {
     let qualifiedStatementVerified;
 
-    const assignments = [],
-          localContext = localMetaContext;  ///
+    const assignments = [];  ///
 
     qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, assignments, localContext);
 
@@ -59,43 +58,41 @@ export default function verifyMetaproofStep(metaproofStepNode, substitutions, lo
       const statementNode = statementNodeQuery(qualifiedStatementNode),
             metaproofStep = MetaproofStep.fromStatementNode(statementNode);
 
-      localMetaContext.addMetaproofStep(metaproofStep);
+      localContext.addMetaproofStep(metaproofStep);
 
       metaproofStepVerified = true;
     }
   } else if (unqualifiedStatementNode !== null) {
-    let qualifiedStatementVerified;
+    let unqualifiedStatementVerified;
 
-    const assignments = [],
-          localContext = localMetaContext,  ///
-          substitutions = null;
+    const derived = true,
+          assignments = [];
 
-    qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, substitutions, assignments, localContext);
+    unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
 
-    if (qualifiedStatementVerified) {
+    if (unqualifiedStatementVerified) {
       const assignmentAssigned = assignAssignment(assignments, localContext);
 
-      qualifiedStatementVerified = assignmentAssigned; ///
+      unqualifiedStatementVerified = assignmentAssigned; ///
     }
 
-    if (qualifiedStatementVerified) {
-      const statementNode = statementNodeQuery(qualifiedStatementNode),
+    if (unqualifiedStatementVerified) {
+      const statementNode = statementNodeQuery(unqualifiedStatementNode),
             metaproofStep = MetaproofStep.fromStatementNode(statementNode);
 
-      localMetaContext.addMetaproofStep(metaproofStep);
+      localContext.addMetaproofStep(metaproofStep);
 
-      metaproofStepVerified = qualifiedStatementVerified; ///
+      metaproofStepVerified = unqualifiedStatementVerified; ///
     }
   } else if (qualifiedMetastatementNode !== null) {
     let qualifiedMetastatementVerified;
 
     const assignments = [];
 
-    qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, substitutions, assignments, localMetaContext);
+    qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, substitutions, assignments, localContext);
 
     if (qualifiedMetastatementVerified) {
-      const localContext = localMetaContext,  ///
-            assignmentAssigned = assignAssignment(assignments, localContext);
+      const assignmentAssigned = assignAssignment(assignments, localContext);
 
       qualifiedMetastatementVerified = assignmentAssigned; ///
     }
@@ -104,7 +101,7 @@ export default function verifyMetaproofStep(metaproofStepNode, substitutions, lo
       const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
             metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
 
-      localMetaContext.addMetaproofStep(metaproofStep);
+      localContext.addMetaproofStep(metaproofStep);
 
       metaproofStepVerified = qualifiedMetastatementVerified; ///
     }
@@ -114,11 +111,10 @@ export default function verifyMetaproofStep(metaproofStepNode, substitutions, lo
     const derived = true,
           assignments = [];
 
-    unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
+    unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localContext);
 
     if (unqualifiedMetastatementVerified) {
-      const localContext = localMetaContext,  ///
-            assignmentAssigned = assignAssignment(assignments, localContext);
+      const assignmentAssigned = assignAssignment(assignments, localContext);
 
       unqualifiedMetastatementVerified = assignmentAssigned; ///
     }
@@ -127,7 +123,7 @@ export default function verifyMetaproofStep(metaproofStepNode, substitutions, lo
       const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
             metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
 
-      localMetaContext.addMetaproofStep(metaproofStep);
+      localContext.addMetaproofStep(metaproofStep);
 
       metaproofStepVerified = true;
     }

package/src/verify/metastatement/qualified.js

@@ -7,12 +7,12 @@ import { nodeQuery } from "../../utilities/query";
 const metavariableNodeQuery = nodeQuery("/qualifiedMetastatement/reference!/metavariable!"),
       metastatementNodeQuery = nodeQuery("/qualifiedMetastatement/metastatement!");
 
-export default function verifyQualifiedMetastatement(qualifiedMetastatementNode, substitutions, assignments, localMetaContext) {
+export default function verifyQualifiedMetastatement(qualifiedMetastatementNode, substitutions, assignments, localContext) {
   let qualifiedMetastatementVerified;
 
-  const qualifiedMetastatementString = localMetaContext.nodeAsString(qualifiedMetastatementNode);
+  const qualifiedMetastatementString = localContext.nodeAsString(qualifiedMetastatementNode);
 
-  localMetaContext.trace(`Verifying the '${qualifiedMetastatementString}' qualified metastatement...`, qualifiedMetastatementNode);
+  localContext.trace(`Verifying the '${qualifiedMetastatementString}' qualified metastatement...`, qualifiedMetastatementNode);
 
   const metavariableNode = metavariableNodeQuery(qualifiedMetastatementNode),
         verifyQualifiedMetastatementFunctions = [
@@ -21,7 +21,7 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
         ];
 
   qualifiedMetastatementVerified = verifyQualifiedMetastatementFunctions.some((verifyQualifiedMetastatementFunction) => {  ///
-    const qualifiedMetastatementVerified = verifyQualifiedMetastatementFunction(qualifiedMetastatementNode, metavariableNode, substitutions, localMetaContext);
+    const qualifiedMetastatementVerified = verifyQualifiedMetastatementFunction(qualifiedMetastatementNode, metavariableNode, substitutions, localContext);
 
     if (qualifiedMetastatementVerified) {
       return true;
@@ -31,7 +31,7 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
   if (qualifiedMetastatementVerified) {
     const derived = false,
           metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
-          metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localMetaContext, () => {
+          metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localContext, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;
@@ -41,45 +41,45 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
   }
 
   if (qualifiedMetastatementVerified) {
-    localMetaContext.debug(`...verified the '${qualifiedMetastatementString}' qualified metastatement.`, qualifiedMetastatementNode);
+    localContext.debug(`...verified the '${qualifiedMetastatementString}' qualified metastatement.`, qualifiedMetastatementNode);
   }
 
   return qualifiedMetastatementVerified;
 }
 
-function verifyQualifiedMetastatementAAgainstRule(qualifiedMetastatementNode, metavariableNode, substitutions, localMetaContext) {
+function verifyQualifiedMetastatementAAgainstRule(qualifiedMetastatementNode, metavariableNode, substitutions, localContext) {
   let qualifiedMetastatementVerifiedAgainstRule = false;
 
-  const rule = localMetaContext.findRuleByMetavariableNode(metavariableNode);
+  const rule = localContext.findRuleByMetavariableNode(metavariableNode);
 
   if (rule !== null) {
     const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
-          metavariableString = localMetaContext.nodeAsString(metavariableNode),
-          qualifiedMetastatementString = localMetaContext.nodeAsString(qualifiedMetastatementNode);
+          metavariableString = localContext.nodeAsString(metavariableNode),
+          qualifiedMetastatementString = localContext.nodeAsString(qualifiedMetastatementNode);
 
-    localMetaContext.trace(`Verifying the '${qualifiedMetastatementString}' qualified metastatement against the '${metavariableString}' rule...`, qualifiedMetastatementNode);
+    localContext.trace(`Verifying the '${qualifiedMetastatementString}' qualified metastatement against the '${metavariableString}' rule...`, qualifiedMetastatementNode);
 
-    const ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, localMetaContext);
+    const ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, localContext);
 
     qualifiedMetastatementVerifiedAgainstRule = ruleMatchesMetastatement;  ///
 
     if (qualifiedMetastatementVerifiedAgainstRule) {
-      localMetaContext.debug(`...verified the '${qualifiedMetastatementString}' qualified metastatement against the '${metavariableString}' rule.`, qualifiedMetastatementNode);
+      localContext.debug(`...verified the '${qualifiedMetastatementString}' qualified metastatement against the '${metavariableString}' rule.`, qualifiedMetastatementNode);
     }
   }
 
   return qualifiedMetastatementVerifiedAgainstRule;
 }
 
-function verifyQualifiedMetastatementAAgainstReference(qualifiedMetastatementNode, metavariableNode, substitutions, localMetaContext) {
+function verifyQualifiedMetastatementAAgainstReference(qualifiedMetastatementNode, metavariableNode, substitutions, localContext) {
   let qualifiedMetastatementVerifiedAgainstReference = false;
 
   if (substitutions !== null) {
-    const metavariableString = localMetaContext.nodeAsString(metavariableNode),
-          metavariablePresent = localMetaContext.isMetavariablePresentByMetavariableNode(metavariableNode, localMetaContext),
-          qualifiedMetastatementString = localMetaContext.nodeAsString(qualifiedMetastatementNode);
+    const metavariableString = localContext.nodeAsString(metavariableNode),
+          metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode, localContext),
+          qualifiedMetastatementString = localContext.nodeAsString(qualifiedMetastatementNode);
 
-    localMetaContext.trace(`Verifying the '${qualifiedMetastatementString}' qualified metastatement against the '${metavariableString}' reference...`, qualifiedMetastatementNode);
+    localContext.trace(`Verifying the '${qualifiedMetastatementString}' qualified metastatement against the '${metavariableString}' reference...`, qualifiedMetastatementNode);
 
     if (metavariablePresent) {
       const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
@@ -93,26 +93,26 @@ function verifyQualifiedMetastatementAAgainstReference(qualifiedMetastatementNod
     }
 
     if (qualifiedMetastatementVerifiedAgainstReference) {
-      localMetaContext.debug(`...verified the '${qualifiedMetastatementString}' qualified metastatement against the '${metavariableString}' reference.`, qualifiedMetastatementNode);
+      localContext.debug(`...verified the '${qualifiedMetastatementString}' qualified metastatement against the '${metavariableString}' reference.`, qualifiedMetastatementNode);
     }
   }
 
   return qualifiedMetastatementVerifiedAgainstReference;
 }
 
-function verifyMetastatement(metastatementNode, assignments, derived, localMetaContext) {
+function verifyMetastatement(metastatementNode, assignments, derived, localContext) {
   let metastatementVerified;
 
-  const metastatementString = localMetaContext.nodeAsString(metastatementNode);
+  const metastatementString = localContext.nodeAsString(metastatementNode);
 
-  localMetaContext.trace(`Verifying the '${metastatementString}' metastatement...`, metastatementNode);
+  localContext.trace(`Verifying the '${metastatementString}' metastatement...`, metastatementNode);
 
   const verifyMetaStatementFunctions = [
     ///
   ];
 
   verifyMetaStatementFunctions.some((verifyStatementFunction) => {
-    const metastatementVerified = verifyStatementFunction(metastatementNode, assignments, derived, localMetaContext);
+    const metastatementVerified = verifyStatementFunction(metastatementNode, assignments, derived, localContext);
 
     if (metastatementVerified) {
       return true;
@@ -122,7 +122,7 @@ function verifyMetastatement(metastatementNode, assignments, derived, localMetaC
   metastatementVerified = true; ///
 
   if (metastatementVerified) {
-    localMetaContext.debug(`...verified the '${metastatementString}' metastatement.`, metastatementNode);
+    localContext.debug(`...verified the '${metastatementString}' metastatement.`, metastatementNode);
   }
 
   return metastatementVerified;

package/src/verify/metastatement/unqualified.js

@@ -6,28 +6,28 @@ import { nodeQuery } from "../../utilities/query";
 
 const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
 
-export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext) {
+export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localContext) {
   let unqualifiedMetastatementVerified = false;
 
   const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
-        unqualifiedMetastatementString = localMetaContext.nodeAsString(unqualifiedMetastatementNode);
+        unqualifiedMetastatementString = localContext.nodeAsString(unqualifiedMetastatementNode);
 
-  localMetaContext.trace(`Verifying the '${unqualifiedMetastatementString}' unqualified metastatement...`, unqualifiedMetastatementNode);
+  localContext.trace(`Verifying the '${unqualifiedMetastatementString}' unqualified metastatement...`, unqualifiedMetastatementNode);
 
   if (derived) {
-    const matchesMetastatementNode = localMetaContext.matchMetastatementNode(metastatementNode);
+    const matchesMetastatementNode = localContext.matchMetastatementNode(metastatementNode);
 
     unqualifiedMetastatementVerified = matchesMetastatementNode;  ///
   }
 
   if (!unqualifiedMetastatementVerified) {
-    const metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localMetaContext);
+    const metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localContext);
 
     unqualifiedMetastatementVerified = metastatementVerified; ///
   }
 
   if (unqualifiedMetastatementVerified) {
-    localMetaContext.debug(`...verified the '${unqualifiedMetastatementString}' unqualified metastatement.`, unqualifiedMetastatementNode);
+    localContext.debug(`...verified the '${unqualifiedMetastatementString}' unqualified metastatement.`, unqualifiedMetastatementNode);
   }
 
   return unqualifiedMetastatementVerified;