occam-verify-cli 0.0.914 → 0.0.916

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

@@ -13,18 +13,18 @@ const termNodeQuery = nodeQuery("/term!"),
       nonTerminalNodeQuery = nodeQuery("/*"),
       metavariableNodeQuery = nodeQuery("/metavariable!");
 
-class MetastatementNodeVerifier extends NodeVerifier {
-  verifyNonTerminalNode(nonTerminalNode, localMetaContext, verifyAhead) {
+class MetaLevelNodeVerifier extends NodeVerifier {
+  verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead) {
     let nonTerminalNodeVerified;
 
     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 MetastatementNodeVerifier extends NodeVerifier {
       },
       {
         nodeQuery: variableNodeQuery,
-        verifyNode: (node, localMetaContext, verifyAhead) => {
+        verifyNode: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const variableNode = node, ///
-                variableNodeVerified = this.verifyVariableNode(variableNode, localMetaContext, verifyAhead);
+                variableNodeVerified = this.verifyVariableNode(variableNode, localContext, verifyAhead);
 
           nonTerminalNodeVerified = variableNodeVerified; ///
 
@@ -46,11 +46,11 @@ class MetastatementNodeVerifier extends NodeVerifier {
       },
       {
         nodeQuery: metavariableNodeQuery,
-        verifyNode: (node, localMetaContext, verifyAhead) => {
+        verifyNode: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const metavariableNode = node, ///
-                metavariableNodeVerified = this.verifyMetavariableNode(metavariableNode, localMetaContext, verifyAhead);
+                metavariableNodeVerified = this.verifyMetavariableNode(metavariableNode, localContext, verifyAhead);
 
           nonTerminalNodeVerified = metavariableNodeVerified; ///
 
@@ -59,51 +59,49 @@ class MetastatementNodeVerifier 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;
         }
       }
     ];
 
-    const nodeVerified = verifyNode(nodeQueryMaps, nonTerminalNode, localMetaContext, verifyAhead);
+    const nodeVerified = verifyNode(nodeQueryMaps, nonTerminalNode, localContext, verifyAhead);
 
     nonTerminalNodeVerified = nodeVerified; ///
 
     return nonTerminalNodeVerified;
   }
 
-  verifyMetavariableNode(metavariableNode, localMetaContext, verifyAhead) {
-    const standaloneMetavariableVerified = verifyStandaloneMetavariable(metavariableNode, localMetaContext, verifyAhead),
+  verifyMetavariableNode(metavariableNode, localContext, verifyAhead) {
+    const standaloneMetavariableVerified = verifyStandaloneMetavariable(metavariableNode, localContext, verifyAhead),
           metavariableNodeVerified = standaloneMetavariableVerified;  ///
 
     return metavariableNodeVerified;
   }
 
-  verifyVariableNode(variableNode, localMetaContext, verifyAhead) {
-    const localContext = localMetaContext,  ///
-          standaloneVariableVerified = verifyStandaloneVariable(variableNode, localContext, verifyAhead),
+  verifyVariableNode(variableNode, localContext, verifyAhead) {
+    const standaloneVariableVerified = verifyStandaloneVariable(variableNode, localContext, verifyAhead),
           variableNodeVerified = standaloneVariableVerified;  ///
 
     return variableNodeVerified;
   }
 
-  verifyTermNode(termNode, localMetaContext, verifyAhead) {
-    const localContext = localMetaContext,  ///
-          standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
+  verifyTermNode(termNode, localContext, verifyAhead) {
+    const standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
           termNodeVerified = standaloneTermVerified;  ///
 
     return termNodeVerified;
   }
 }
 
-const metastatementNodeVerifier = new MetastatementNodeVerifier();
+const metaLevelNodeVerifier = new MetaLevelNodeVerifier();
 
-export default metastatementNodeVerifier;
+export default metaLevelNodeVerifier;

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,48 +43,48 @@ 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 judgement = localContext.findJudgementByMetavariableNode(metavariableNode);
 
-      if (frameAssertion !== null) {
-        const frameAssertionDeclarations = frameAssertion.getDeclarations();
+      if (judgement !== null) {
+        const judgementDeclarations = judgement.getDeclarations();
 
-        push(declarations, frameAssertionDeclarations);
+        push(declarations, judgementDeclarations);
 
         metavariableVerified = true;
       } else {
-        localMetaContext.debug(`There is no frame assertion for the '${metavariableString}' metavariable.`, metavariableNode);
+        localContext.debug(`There is no judgement 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;