occam-verify-cli 0.0.914 → 0.0.916

package/src/verify/judgement.js

@@ -0,0 +1,169 @@
+"use strict";
+
+import Judgement from "../judgement";
+import verifyFrame from "../verify/frame";
+import frameMetaType from "../metaType/frame";
+import JudgementAssignment from "../assignment/judgement";
+
+import { first } from "../utilities/array";
+import { nodeQuery } from "../utilities/query";
+
+const frameNodeQuery = nodeQuery("/judgement/frame!"),
+      metavariableNodeQuery = nodeQuery("/judgement/metavariable!");
+
+export default function verifyJudgement(judgementNode, assignments, derived, localContext) {
+  let judgementVerified;
+
+  const judgementString = localContext.nodeAsString(judgementNode);
+
+  localContext.trace(`Verifying the '${judgementString}' judgement...`, judgementNode);
+
+  const verifyJudgementFunctions = [
+    verifyDerivedJudgement,
+    verifyStatedJudgement
+  ];
+
+  judgementVerified = verifyJudgementFunctions.some((verifyJudgementFunction) => {
+    const judgementVerified = verifyJudgementFunction(judgementNode, assignments, derived, localContext);
+
+    if (judgementVerified) {
+      return true;
+    }
+  });
+
+  if (judgementVerified) {
+    localContext.debug(`...verified the '${judgementString}' judgement.`, judgementNode);
+  }
+
+  return judgementVerified;
+}
+
+function verifyDerivedJudgement(judgementNode, assignments, derived, localContext) {
+  let derivedJudgementVerified = false;
+
+  if (derived) {
+    const judgementString = localContext.nodeAsString(judgementNode);
+
+    localContext.trace(`Verifying the '${judgementString}' derived judgement...`, judgementNode);
+
+    const metavariableNode = metavariableNodeQuery(judgementNode),
+          metavariableVerified = verifyMetavariable(metavariableNode, localContext);
+
+    if (metavariableVerified) {
+      const judgement = localContext.findJudgementByMetavariableNode(metavariableNode);
+
+      if (judgement !== null) {
+        const frames = [],
+              frameNode = frameNodeQuery(judgementNode),
+              frameVerified = verifyFrame(frameNode, frames, assignments, derived, localContext);
+
+        if (frameVerified) {
+          const firstFrame = first(frames),
+                frame = firstFrame, ///
+                frameSingular = frame.isSingular();
+
+          if (frameSingular) {
+            const declaration = frame.getDeclaration(),
+                  metavariableNode = declaration.getMetavariableNode(),
+                  metaLemma = localContext.findMetaLemmaByMetavariableNode(metavariableNode),
+                  metatheorem = localContext.findMetatheoremByMetavariableNode(metavariableNode),
+                  metaLemmaMetatheorem = (metaLemma || metatheorem);  ///
+
+            if (metaLemmaMetatheorem !== null) {
+              const declarationMatchesMetaLemmaMetatheorem = declaration.matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem),
+                    judgementMatchesMetaLemmaMetatheorem = judgement.matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem);
+
+              derivedJudgementVerified = (declarationMatchesMetaLemmaMetatheorem && judgementMatchesMetaLemmaMetatheorem);
+            } else {
+              const metavariableString = localContext.nodeAsString(metavariableNode);
+
+              localContext.debug(`There are no meta-lemmas or metatheorems corresponding to the '${metavariableString}' metavariable.`, judgementNode);
+            }
+          } else {
+            const frameString = localContext.nodeAsString(frameNode);
+
+            localContext.debug(`The '${frameString}' is not singular.`, judgementNode);
+          }
+        }
+      } else {
+        const metavariableString = localContext.nodeAsString(metavariableNode);
+
+        localContext.debug(`There is no judgement present for the '${metavariableString}' metavariable.`, judgementNode);
+      }
+    }
+
+    if (derivedJudgementVerified) {
+      localContext.debug(`...verified the '${judgementString}' derived judgement.`, judgementNode);
+    }
+  }
+
+  return derivedJudgementVerified;
+}
+
+function verifyStatedJudgement(judgementNode, assignments, derived, localContext) {
+  let statedJudgementVerified = false;
+
+  if (!derived) {
+    const judgementString = localContext.nodeAsString(judgementNode);
+
+    localContext.trace(`Verifying the '${judgementString}' stated judgement...`, judgementNode);
+
+    const metavariableNode = metavariableNodeQuery(judgementNode),
+          metavariableVerified = verifyMetavariable(metavariableNode, localContext);
+
+    if (metavariableVerified) {
+      const frames = [],
+            frameNode = frameNodeQuery(judgementNode),
+            frameVerified = verifyFrame(frameNode, frames, assignments, derived, localContext);
+
+      if (frameVerified) {
+        const firstFrame = first(frames),
+              frame = firstFrame, ///
+              judgement = Judgement.fromJudgementNodeFrameAndMetavariableNode(judgementNode, frame, metavariableNode),
+              judgementAssignment = JudgementAssignment.fromJudgement(judgement),
+              assignment = judgementAssignment;
+
+        assignments.push(assignment);
+
+        statedJudgementVerified = true;
+      }
+    }
+
+    if (statedJudgementVerified) {
+      localContext.debug(`...verified the '${judgementString}' stated judgement.`, judgementNode);
+    }
+  }
+
+  return statedJudgementVerified;
+}
+
+function verifyMetavariable(metavariableNode, localContext) {
+  let metavariableVerified = false;
+
+  const metavariableString = localContext.nodeAsString(metavariableNode);
+
+  localContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
+
+  const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode, localContext);
+
+  if (metavariable !== null) {
+    const metaType = metavariable.getMetaType();
+
+    if (metaType === frameMetaType) {
+      metavariableVerified = true;
+    } else {
+      const frameMetaTypeName = frameMetaType.getName(),
+            metaTypeString = metaType.asString();
+
+      localContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metaTypeString}' when it should be '${frameMetaTypeName}'.`, metavariableNode);
+    }
+  } else {
+    localContext.debug(`The '${metavariableString}' metavariable is not present'.`, metavariableNode);
+  }
+
+  if (metavariableVerified) {
+    localContext.debug(`...verified the '${metavariableString}' metavariable.`, metavariableNode);
+  }
+
+  return metavariableVerified;
+}

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,7 +58,7 @@ export default function verifyMetaproofStep(metaproofStepNode, substitutions, lo
       const statementNode = statementNodeQuery(qualifiedStatementNode),
             metaproofStep = MetaproofStep.fromStatementNode(statementNode);
 
-      localMetaContext.addMetaproofStep(metaproofStep);
+      localContext.addMetaproofStep(metaproofStep);
 
       metaproofStepVerified = true;
     }
@@ -67,8 +66,7 @@ export default function verifyMetaproofStep(metaproofStepNode, substitutions, lo
     let unqualifiedStatementVerified;
 
     const derived = true,
-          assignments = [],
-          localContext = localMetaContext;
+          assignments = [];
 
     unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
 
@@ -82,7 +80,7 @@ export default function verifyMetaproofStep(metaproofStepNode, substitutions, lo
       const statementNode = statementNodeQuery(unqualifiedStatementNode),
             metaproofStep = MetaproofStep.fromStatementNode(statementNode);
 
-      localMetaContext.addMetaproofStep(metaproofStep);
+      localContext.addMetaproofStep(metaproofStep);
 
       metaproofStepVerified = unqualifiedStatementVerified; ///
     }
@@ -91,11 +89,10 @@ export default function verifyMetaproofStep(metaproofStepNode, substitutions, lo
 
     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;
     }