occam-verify-cli 0.0.913 → 0.0.915

package/src/verifier/node/statementAsCombinator.js

@@ -20,11 +20,11 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
     const nodeQueryMaps = [
       {
         nodeQuery: termNodeQuery,
-        verifyNode: (node, localMetaContext, verifyAhead) => {
+        verifyNode: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const termNode = node, ///
-                termNodeVerified = this.verifyTermNode(termNode, localMetaContext, verifyAhead);
+                termNodeVerified = this.verifyTermNode(termNode, localContext, verifyAhead);
 
           nonTerminalNodeVerified = termNodeVerified; ///
 
@@ -33,11 +33,11 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
       },
       {
         nodeQuery: typeNodeQuery,
-        verifyNode: (node, localMetaContext, verifyAhead) => {
+        verifyNode: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const typeNode = node, ///
-                typeNodeVerified = this.verifyTypeNode(typeNode, localMetaContext, verifyAhead);
+                typeNodeVerified = this.verifyTypeNode(typeNode, localContext, verifyAhead);
 
           nonTerminalNodeVerified = typeNodeVerified; ///
 
@@ -46,11 +46,11 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
       },
       {
         nodeQuery: statementNodeQuery,
-        verifyNode: (node, localMetaContext, verifyAhead) => {
+        verifyNode: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const statementNode = node, ///
-                statementNodeVerified = this.verifyStatementNode(statementNode, localMetaContext, verifyAhead);
+                statementNodeVerified = this.verifyStatementNode(statementNode, localContext, verifyAhead);
 
           nonTerminalNodeVerified = statementNodeVerified; ///
 
@@ -59,14 +59,14 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
       },
       {
         nodeQuery: nonTerminalNodeQuery,
-        verifyNode: (node, localMetaContext, verifyAhead) => {
+        verifyNode: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const nonTerminalNode = node; ///
 
           nonTerminalNodeVerified =
 
-            super.verifyNonTerminalNode(nonTerminalNode, localMetaContext, verifyAhead);
+            super.verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead);
 
           return nonTerminalNodeVerified;
         }

package/src/verifier/node/termAsConstructor.js

@@ -18,11 +18,11 @@ class TermAsConstructorNodeVerifier extends NodeVerifier {
     const nodeQueryMaps = [
       {
         nodeQuery: termNodeQuery,
-        verifyNode: (node, localMetaContext, verifyAhead) => {
+        verifyNode: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const termNode = node, ///
-            termNodeVerified = this.verifyTermNode(termNode, localMetaContext, verifyAhead);
+            termNodeVerified = this.verifyTermNode(termNode, localContext, verifyAhead);
 
           nonTerminalNodeVerified = termNodeVerified; ///
 
@@ -31,11 +31,11 @@ class TermAsConstructorNodeVerifier extends NodeVerifier {
       },
       {
         nodeQuery: typeNodeQuery,
-        verifyNode: (node, localMetaContext, verifyAhead) => {
+        verifyNode: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const typeNode = node, ///
-            typeNodeVerified = this.verifyTypeNode(typeNode, localMetaContext, verifyAhead);
+            typeNodeVerified = this.verifyTypeNode(typeNode, localContext, verifyAhead);
 
           nonTerminalNodeVerified = typeNodeVerified; ///
 
@@ -44,14 +44,14 @@ class TermAsConstructorNodeVerifier extends NodeVerifier {
       },
       {
         nodeQuery: nonTerminalNodeQuery,
-        verifyNode: (node, localMetaContext, verifyAhead) => {
+        verifyNode: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const nonTerminalNode = node; ///
 
           nonTerminalNodeVerified =
 
-            super.verifyNonTerminalNode(nonTerminalNode, localMetaContext, verifyAhead);
+            super.verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead);
 
           return nonTerminalNodeVerified;
         }

package/src/verify/axiom.js

@@ -1,10 +1,10 @@
 "use strict";
 
 import Axiom from "../axiom";
-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 { nodeQuery, nodesQuery } from "../utilities/query";
@@ -16,9 +16,10 @@ const labelNodesQuery = nodesQuery("/axiom/label"),
 export default function verifyAxiom(axiomNode, fileContext) {
   let axiomVerified = false;
 
-  const labelNodes = labelNodesQuery(axiomNode),
+  const intrinsicLevelLocalContext = IntrinsicLevelLocalContext.fromFileContext(fileContext),
+        labelNodes = labelNodesQuery(axiomNode),
         labelsString = fileContext.nodesAsString(labelNodes),
-        localContext = LocalContext.fromFileContext(fileContext);
+        localContext = intrinsicLevelLocalContext;  ///
 
   fileContext.trace(`Verifying the '${labelsString}' axiom...`, axiomNode);
 

package/src/verify/conclusion.js

@@ -11,12 +11,12 @@ const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
       unqualifiedStatementNodeQuery = nodeQuery("/conclusion/unqualifiedStatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/conclusion/unqualifiedMetastatement!");
 
-export default function verifyConclusion(conclusionNode, conclusions, localMetaContext) {
+export default function verifyConclusion(conclusionNode, conclusions, localContext) {
   let conclusionVerified = false;
 
-  const conclusionString = localMetaContext.nodeAsString(conclusionNode);
+  const conclusionString = localContext.nodeAsString(conclusionNode);
 
-  localMetaContext.trace(`Verifying the '${conclusionString}' conclusion...`, conclusionNode);
+  localContext.trace(`Verifying the '${conclusionString}' conclusion...`, conclusionNode);
 
   const unqualifiedStatementNode = unqualifiedStatementNodeQuery(conclusionNode),
         unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(conclusionNode);
@@ -24,7 +24,6 @@ export default function verifyConclusion(conclusionNode, conclusions, localMetaC
   if (unqualifiedStatementNode !== null) {
     const derived = false,
           assignments = [],
-          localContext = localMetaContext,  ///
           unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
 
     conclusionVerified = unqualifiedStatementVerified; ///
@@ -33,7 +32,7 @@ export default function verifyConclusion(conclusionNode, conclusions, localMetaC
   if (unqualifiedMetastatementNode !== null) {
     const derived = false,
           assignments = [],
-          unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
+          unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localContext);
 
     conclusionVerified = unqualifiedMetastatementVerified; ///
   }
@@ -55,7 +54,7 @@ export default function verifyConclusion(conclusionNode, conclusions, localMetaC
 
     conclusions.push(conclusion);
 
-    localMetaContext.debug(`...verified the '${conclusionString}' conclusion.`, conclusionNode);
+    localContext.debug(`...verified the '${conclusionString}' conclusion.`, conclusionNode);
   }
 
   return conclusionVerified;

package/src/verify/conjecture.js

@@ -2,10 +2,10 @@
 
 import Conjecture from "../conjecture";
 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 { nodeQuery, nodesQuery } from "../utilities/query";
@@ -18,9 +18,10 @@ const proofNodeQuery = nodeQuery("/conjecture/proof!"),
 export default function verifyConjecture(conjectureNode, fileContext) {
   let conjectureVerified = false;
 
-  const labelNodes = labelNodesQuery(conjectureNode),
+  const intrinsicLevelLocalContext = IntrinsicLevelLocalContext.fromFileContext(fileContext),
+        labelNodes = labelNodesQuery(conjectureNode),
         labelsString = fileContext.nodesAsString(labelNodes),
-        localContext = LocalContext.fromFileContext(fileContext);
+        localContext = intrinsicLevelLocalContext;  ///
 
   fileContext.trace(`Verifying the '${labelsString}' conjecture...`, conjectureNode);
 

package/src/verify/containedAssertion.js

@@ -1,5 +1,7 @@
 "use strict";
 
+import metaLevelNodeVerifier from "../verifier/node/metaLevel";
+
 import { isAssertionNegated } from "../utilities/verify";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
@@ -79,13 +81,32 @@ function verifyDerivedContainedAssertion(containedAssertionNode, assignments, de
 }
 
 function verifyStatedContainedAssertion(containedAssertionNode, assignments, derived, localContext) {
-  let derivedStatedAssertionVerified = false;
+  let statedContainedAssertionVerified = false;
 
   if (!derived) {
     const containedAssertionString = localContext.nodeAsString(containedAssertionNode);
 
-    localContext.debug(`The stated '${containedAssertionString}' contained assertion cannot be verified.`, containedAssertionNode);
+    localContext.trace(`Verifying the stated '${containedAssertionString}' contained assertion...`, containedAssertionNode);
+
+    const intrinsicLevel = localContext.isIntrinsicLevel();
+
+    if (intrinsicLevel) {
+      localContext.debug(`The stated '${containedAssertionString}' contained assertion cannot be verified at intrinsic level.`, containedAssertionNode);
+    } else {
+      const nonTerminalNode = containedAssertionNode, ///
+            nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
+              const verifiedAhead = true;
+
+              return verifiedAhead;
+            });
+
+      statedContainedAssertionVerified = nonTerminalNodeVerified; ///
+    }
+
+    if (statedContainedAssertionVerified) {
+      localContext.debug(`...verified the stated '${containedAssertionString}' contained assertion.`, containedAssertionNode);
+    }
   }
 
-  return derivedStatedAssertionVerified;
+  return statedContainedAssertionVerified;
 }

package/src/verify/declaration.js

@@ -2,7 +2,7 @@
 
 import Declaration from "../declaration"
 import referenceMetaType from "../metaType/reference";
-import metastatementNodeVerifier from "../verifier/node/metastatement";
+import metaLevelNodeVerifier from "../verifier/node/metaLevel";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -10,23 +10,23 @@ const referenceNodeQuery = nodeQuery("/declaration/reference!"),
       metavariableNodeQuery = nodeQuery("/reference/metavariable!"),
       metastatementNodeQuery = nodeQuery("/declaration/metastatement!");
 
-export default function verifyDeclaration(declarationNode, declarations, localMetaContext) {
+export default function verifyDeclaration(declarationNode, declarations, localContext) {
   let declarationVerified = false;
 
-  const declarationString = localMetaContext.nodeAsString(declarationNode);
+  const declarationString = localContext.nodeAsString(declarationNode);
 
-  localMetaContext.trace(`Verifying the '${declarationString}' declaration...`, declarationNode);
+  localContext.trace(`Verifying the '${declarationString}' declaration...`, declarationNode);
 
   const referenceNode = referenceNodeQuery(declarationNode),
-        referenceVerified = verifyReference(referenceNode, localMetaContext);
+        referenceVerified = verifyReference(referenceNode, localContext);
 
   if (referenceVerified) {
     const metastatementNode = metastatementNodeQuery(declarationNode);
 
-    const { verifyMetastatement } = metastatementNodeVerifier,
+    const { verifyMetastatement } = metaLevelNodeVerifier,
           derived = false,
           assignments = [],
-          metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localMetaContext, () => {
+          metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localContext, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;
@@ -43,21 +43,21 @@ export default function verifyDeclaration(declarationNode, declarations, localMe
   }
 
   if (declarationVerified) {
-    localMetaContext.debug(`...verified the '${declarationString}' declaration.`, declarationNode);
+    localContext.debug(`...verified the '${declarationString}' declaration.`, declarationNode);
   }
 
   return declarationVerified;
 }
 
-function verifyReference(referenceNode, localMetaContext) {
+function verifyReference(referenceNode, localContext) {
   let referenceVerified = false;
 
-  const referenceString = localMetaContext.nodeAsString(referenceNode);
+  const referenceString = localContext.nodeAsString(referenceNode);
 
-  localMetaContext.trace(`Verifying the '${referenceString}' reference...`, referenceNode);
+  localContext.trace(`Verifying the '${referenceString}' reference...`, referenceNode);
 
   const metavariableNode = metavariableNodeQuery(referenceNode),
-        metavariable = localMetaContext.findMetavariableByMetavariableNode(metavariableNode, localMetaContext);
+        metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode, localContext);
 
   if (metavariable !== null) {
     const metaType = metavariable.getMetaType();
@@ -68,14 +68,14 @@ function verifyReference(referenceNode, localMetaContext) {
       const referenceMetaTypeName = referenceMetaType.getName(),
             metaTypeString = metaType.asString();
 
-      localMetaContext.debug(`The '${referenceString}' metavariable's meta-type is '${metaTypeString}' when it should be '${referenceMetaTypeName}'.`, referenceNode);
+      localContext.debug(`The '${referenceString}' metavariable's meta-type is '${metaTypeString}' when it should be '${referenceMetaTypeName}'.`, referenceNode);
     }
   } else {
-    localMetaContext.debug(`The '${referenceString}' metavariable is not present'.`, referenceNode);
+    localContext.debug(`The '${referenceString}' metavariable is not present'.`, referenceNode);
   }
 
   if (referenceVerified) {
-    localMetaContext.debug(`...verified the '${referenceString}' reference.`, referenceNode);
+    localContext.debug(`...verified the '${referenceString}' reference.`, referenceNode);
   }
 
   return referenceVerified;

package/src/verify/definedAssertion.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import verifyTerm from "./term";
+import metaLevelNodeVerifier from "../verifier/node/metaLevel";
 
 import { first } from "../utilities/array";
 import { nodeQuery } from "../utilities/query";
@@ -105,13 +106,32 @@ function verifyDerivedDefinedAssertion(definedAssertionNode, assignments, derive
 }
 
 function verifyStatedDefinedAssertion(definedAssertionNode, assignments, derived, localContext) {
-  let derivedStatedAssertionVerified = false;
+  let statedDefinedAssertionVerified = false;
 
   if (!derived) {
     const definedAssertionString = localContext.nodeAsString(definedAssertionNode);
 
-    localContext.debug(`The stated '${definedAssertionString}' defined assertion cannot be verified.`, definedAssertionNode);
+    localContext.trace(`Verifying the stated '${definedAssertionString}' defined assertion...`, definedAssertionNode);
+
+    const intrinsicLevel = localContext.isIntrinsicLevel();
+
+    if (intrinsicLevel) {
+      localContext.debug(`The stated '${definedAssertionString}' defined assertion cannot be verified at intrinsic level.`, definedAssertionNode);
+    } else {
+      const nonTerminalNode = definedAssertionNode, ///
+            nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
+              const verifiedAhead = true;
+
+              return verifiedAhead;
+            });
+
+      statedDefinedAssertionVerified = nonTerminalNodeVerified; ///
+    }
+
+    if (statedDefinedAssertionVerified) {
+      localContext.debug(`...verified the stated '${definedAssertionString}' defined assertion.`, definedAssertionNode);
+    }
   }
 
-  return derivedStatedAssertionVerified;
+  return statedDefinedAssertionVerified;
 }

package/src/verify/derivation.js

@@ -6,13 +6,13 @@ import { nodesQuery } from "../utilities/query";
 
 const proofStepNodesQuery = nodesQuery("/derivation/proofStep|lastProofStep");
 
-export default function verifyDerivation(ruleDerivationNode, localMetaContext) {
+export default function verifyDerivation(ruleDerivationNode, localContext) {
   let ruleDerivationVerified;
 
   const proofStepNodes = proofStepNodesQuery(ruleDerivationNode);
 
   ruleDerivationVerified = proofStepNodes.every((proofStepNode) => {
-    const proofStepVerified = verifyProofStep(proofStepNode, localMetaContext);
+    const proofStepVerified = verifyProofStep(proofStepNode, localContext);
 
     if (proofStepVerified) {
       return true;

package/src/verify/frame.js

@@ -10,17 +10,17 @@ import { nodesQuery } from "../utilities/query";
 const declarationNodesQuery = nodesQuery("/frame/declaration"),
       metavariableNodesQuery = nodesQuery("/frame/metavariable");
 
-export default function verifyFrame(frameNode, frames, assignments, derived, localMetaContext) {
+export default function verifyFrame(frameNode, frames, assignments, derived, localContext) {
   let frameVerified;
 
-  const frameString = localMetaContext.nodeAsString(frameNode);
+  const frameString = localContext.nodeAsString(frameNode);
 
-  localMetaContext.trace(`Verifying the '${frameString}' frame...`, frameNode);
+  localContext.trace(`Verifying the '${frameString}' frame...`, frameNode);
 
   const declarations = [],
         declarationNodes = declarationNodesQuery(frameNode),
         declarationsVerified = declarationNodes.every((declarationNode) => {
-          const declarationVerified = verifyDeclaration(declarationNode, declarations, localMetaContext);
+          const declarationVerified = verifyDeclaration(declarationNode, declarations, localContext);
 
           return declarationVerified;
         });
@@ -28,7 +28,7 @@ export default function verifyFrame(frameNode, frames, assignments, derived, loc
   if (declarationsVerified) {
     const metavariableNodes = metavariableNodesQuery(frameNode),
           metavariablesVerified = metavariableNodes.every((metavariableNode) => {
-            const metavariableVerified = verifyMetavariable(metavariableNode, declarations, localMetaContext);
+            const metavariableVerified = verifyMetavariable(metavariableNode, declarations, localContext);
 
             return metavariableVerified;
           });
@@ -43,26 +43,26 @@ export default function verifyFrame(frameNode, frames, assignments, derived, loc
   }
 
   if (frameVerified) {
-    localMetaContext.debug(`...verified the '${frameString}' frame.`, frameNode);
+    localContext.debug(`...verified the '${frameString}' frame.`, frameNode);
   }
 
   return frameVerified;
 }
 
-function verifyMetavariable(metavariableNode, declarations, localMetaContext) {
+function verifyMetavariable(metavariableNode, declarations, localContext) {
   let metavariableVerified = false;
 
-  const metavariableString = localMetaContext.nodeAsString(metavariableNode);
+  const metavariableString = localContext.nodeAsString(metavariableNode);
 
-  localMetaContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
+  localContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
 
-  const metavariable = localMetaContext.findMetavariableByMetavariableNode(metavariableNode, localMetaContext);
+  const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode, localContext);
 
   if (metavariable !== null) {
     const metaType = metavariable.getMetaType();
 
     if (metaType === frameMetaType) {
-      const frameAssertion = localMetaContext.findFrameAssertionByMetavariableNode(metavariableNode);
+      const frameAssertion = localContext.findFrameAssertionByMetavariableNode(metavariableNode);
 
       if (frameAssertion !== null) {
         const frameAssertionDeclarations = frameAssertion.getDeclarations();
@@ -71,20 +71,20 @@ function verifyMetavariable(metavariableNode, declarations, localMetaContext) {
 
         metavariableVerified = true;
       } else {
-        localMetaContext.debug(`There is no frame assertion for the '${metavariableString}' metavariable.`, metavariableNode);
+        localContext.debug(`There is no frame assertion for the '${metavariableString}' metavariable.`, metavariableNode);
       }
     } else {
       const frameMetaTypeName = frameMetaType.getName(),
             metaTypeString = metaType.asString();
 
-      localMetaContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metaTypeString}' when it should be '${frameMetaTypeName}'.`, metavariableNode);
+      localContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metaTypeString}' when it should be '${frameMetaTypeName}'.`, metavariableNode);
     }
   } else {
-    localMetaContext.debug(`The '${metavariableString}' metavariable is not present'.`, metavariableNode);
+    localContext.debug(`The '${metavariableString}' metavariable is not present'.`, metavariableNode);
   }
 
   if (metavariableVerified) {
-    localMetaContext.debug(`...verified the '${metavariableString}' metavariable.`, metavariableNode);
+    localContext.debug(`...verified the '${metavariableString}' metavariable.`, metavariableNode);
   }
 
   return metavariableVerified;

package/src/verify/frameAssertion.js

@@ -11,12 +11,12 @@ import { nodeQuery } from "../utilities/query";
 const frameNodeQuery = nodeQuery("/frameAssertion/frame!"),
       metavariableNodeQuery = nodeQuery("/frameAssertion/metavariable!");
 
-export default function verifyFrameAssertion(frameAssertionNode, assignments, derived, localMetaContext) {
+export default function verifyFrameAssertion(frameAssertionNode, assignments, derived, localContext) {
   let frameAssertionVerified;
 
-  const frameAssertionString = localMetaContext.nodeAsString(frameAssertionNode);
+  const frameAssertionString = localContext.nodeAsString(frameAssertionNode);
 
-  localMetaContext.trace(`Verifying the '${frameAssertionString}' frame assertion...`, frameAssertionNode);
+  localContext.trace(`Verifying the '${frameAssertionString}' frame assertion...`, frameAssertionNode);
 
   const verifyFrameAssertionFunctions = [
     verifyDerivedFrameAssertion,
@@ -24,7 +24,7 @@ export default function verifyFrameAssertion(frameAssertionNode, assignments, de
   ];
 
   frameAssertionVerified = verifyFrameAssertionFunctions.some((verifyFrameAssertionFunction) => {
-    const frameAssertionVerified = verifyFrameAssertionFunction(frameAssertionNode, assignments, derived, localMetaContext);
+    const frameAssertionVerified = verifyFrameAssertionFunction(frameAssertionNode, assignments, derived, localContext);
 
     if (frameAssertionVerified) {
       return true;
@@ -32,30 +32,30 @@ export default function verifyFrameAssertion(frameAssertionNode, assignments, de
   });
 
   if (frameAssertionVerified) {
-    localMetaContext.debug(`...verified the '${frameAssertionString}' frame assertion.`, frameAssertionNode);
+    localContext.debug(`...verified the '${frameAssertionString}' frame assertion.`, frameAssertionNode);
   }
 
   return frameAssertionVerified;
 }
 
-function verifyDerivedFrameAssertion(frameAssertionNode, assignments, derived, localMetaContext) {
+function verifyDerivedFrameAssertion(frameAssertionNode, assignments, derived, localContext) {
   let derivedFrameAssertionVerified = false;
 
   if (derived) {
-    const frameAssertionString = localMetaContext.nodeAsString(frameAssertionNode);
+    const frameAssertionString = localContext.nodeAsString(frameAssertionNode);
 
-    localMetaContext.trace(`Verifying the '${frameAssertionString}' derived frame assertion...`, frameAssertionNode);
+    localContext.trace(`Verifying the '${frameAssertionString}' derived frame assertion...`, frameAssertionNode);
 
     const metavariableNode = metavariableNodeQuery(frameAssertionNode),
-          metavariableVerified = verifyMetavariable(metavariableNode, localMetaContext);
+          metavariableVerified = verifyMetavariable(metavariableNode, localContext);
 
     if (metavariableVerified) {
-      const frameAssertion = localMetaContext.findFrameAssertionByMetavariableNode(metavariableNode);
+      const frameAssertion = localContext.findFrameAssertionByMetavariableNode(metavariableNode);
 
       if (frameAssertion !== null) {
         const frames = [],
               frameNode = frameNodeQuery(frameAssertionNode),
-              frameVerified = verifyFrame(frameNode, frames, assignments, derived, localMetaContext);
+              frameVerified = verifyFrame(frameNode, frames, assignments, derived, localContext);
 
         if (frameVerified) {
           const firstFrame = first(frames),
@@ -65,8 +65,8 @@ function verifyDerivedFrameAssertion(frameAssertionNode, assignments, derived, l
           if (frameSingular) {
             const declaration = frame.getDeclaration(),
                   metavariableNode = declaration.getMetavariableNode(),
-                  metaLemma = localMetaContext.findMetaLemmaByMetavariableNode(metavariableNode),
-                  metatheorem = localMetaContext.findMetatheoremByMetavariableNode(metavariableNode),
+                  metaLemma = localContext.findMetaLemmaByMetavariableNode(metavariableNode),
+                  metatheorem = localContext.findMetatheoremByMetavariableNode(metavariableNode),
                   metaLemmaMetatheorem = (metaLemma || metatheorem);  ///
 
             if (metaLemmaMetatheorem !== null) {
@@ -75,46 +75,46 @@ function verifyDerivedFrameAssertion(frameAssertionNode, assignments, derived, l
 
               derivedFrameAssertionVerified = (declarationMatchesMetaLemmaMetatheorem && frameAssertionMatchesMetaLemmaMetatheorem);
             } else {
-              const metavariableString = localMetaContext.nodeAsString(metavariableNode);
+              const metavariableString = localContext.nodeAsString(metavariableNode);
 
-              localMetaContext.debug(`There are no meta-lemmas or metatheorems corresponding to the '${metavariableString}' metavariable.`, frameAssertionNode);
+              localContext.debug(`There are no meta-lemmas or metatheorems corresponding to the '${metavariableString}' metavariable.`, frameAssertionNode);
             }
           } else {
-            const frameString = localMetaContext.nodeAsString(frameNode);
+            const frameString = localContext.nodeAsString(frameNode);
 
-            localMetaContext.debug(`The '${frameString}' is not singular.`, frameAssertionNode);
+            localContext.debug(`The '${frameString}' is not singular.`, frameAssertionNode);
           }
         }
       } else {
-        const metavariableString = localMetaContext.nodeAsString(metavariableNode);
+        const metavariableString = localContext.nodeAsString(metavariableNode);
 
-        localMetaContext.debug(`There is no frameAssertion present for the '${metavariableString}' metavariable.`, frameAssertionNode);
+        localContext.debug(`There is no frameAssertion present for the '${metavariableString}' metavariable.`, frameAssertionNode);
       }
     }
 
     if (derivedFrameAssertionVerified) {
-      localMetaContext.debug(`...verified the '${frameAssertionString}' derived frame assertion.`, frameAssertionNode);
+      localContext.debug(`...verified the '${frameAssertionString}' derived frame assertion.`, frameAssertionNode);
     }
   }
 
   return derivedFrameAssertionVerified;
 }
 
-function verifyStatedFrameAssertion(frameAssertionNode, assignments, derived, localMetaContext) {
+function verifyStatedFrameAssertion(frameAssertionNode, assignments, derived, localContext) {
   let statedFrameAssertionVerified = false;
 
   if (!derived) {
-    const frameAssertionString = localMetaContext.nodeAsString(frameAssertionNode);
+    const frameAssertionString = localContext.nodeAsString(frameAssertionNode);
 
-    localMetaContext.trace(`Verifying the '${frameAssertionString}' stated frame assertion...`, frameAssertionNode);
+    localContext.trace(`Verifying the '${frameAssertionString}' stated frame assertion...`, frameAssertionNode);
 
     const metavariableNode = metavariableNodeQuery(frameAssertionNode),
-          metavariableVerified = verifyMetavariable(metavariableNode, localMetaContext);
+          metavariableVerified = verifyMetavariable(metavariableNode, localContext);
 
     if (metavariableVerified) {
       const frames = [],
             frameNode = frameNodeQuery(frameAssertionNode),
-            frameVerified = verifyFrame(frameNode, frames, assignments, derived, localMetaContext);
+            frameVerified = verifyFrame(frameNode, frames, assignments, derived, localContext);
 
       if (frameVerified) {
         const firstFrame = first(frames),
@@ -130,21 +130,21 @@ function verifyStatedFrameAssertion(frameAssertionNode, assignments, derived, lo
     }
 
     if (statedFrameAssertionVerified) {
-      localMetaContext.debug(`...verified the '${frameAssertionString}' stated frame assertion.`, frameAssertionNode);
+      localContext.debug(`...verified the '${frameAssertionString}' stated frame assertion.`, frameAssertionNode);
     }
   }
 
   return statedFrameAssertionVerified;
 }
 
-function verifyMetavariable(metavariableNode, localMetaContext) {
+function verifyMetavariable(metavariableNode, localContext) {
   let metavariableVerified = false;
 
-  const metavariableString = localMetaContext.nodeAsString(metavariableNode);
+  const metavariableString = localContext.nodeAsString(metavariableNode);
 
-  localMetaContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
+  localContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
 
-  const metavariable = localMetaContext.findMetavariableByMetavariableNode(metavariableNode, localMetaContext);
+  const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode, localContext);
 
   if (metavariable !== null) {
     const metaType = metavariable.getMetaType();
@@ -155,14 +155,14 @@ function verifyMetavariable(metavariableNode, localMetaContext) {
       const frameMetaTypeName = frameMetaType.getName(),
             metaTypeString = metaType.asString();
 
-      localMetaContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metaTypeString}' when it should be '${frameMetaTypeName}'.`, metavariableNode);
+      localContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metaTypeString}' when it should be '${frameMetaTypeName}'.`, metavariableNode);
     }
   } else {
-    localMetaContext.debug(`The '${metavariableString}' metavariable is not present'.`, metavariableNode);
+    localContext.debug(`The '${metavariableString}' metavariable is not present'.`, metavariableNode);
   }
 
   if (metavariableVerified) {
-    localMetaContext.debug(`...verified the '${metavariableString}' metavariable.`, metavariableNode);
+    localContext.debug(`...verified the '${metavariableString}' metavariable.`, metavariableNode);
   }
 
   return metavariableVerified;