occam-verify-cli 0.0.913 → 0.0.915

package/src/verify/metastatement.js

@@ -1,18 +1,18 @@
 "use strict";
 
 import verifyFrameAssertion from "../verify/frameAssertion";
-import metastatementNodeVerifier from "../verifier/node/metastatement";
+import metaLevelNodeVerifier from "../verifier/node/metaLevel";
 
 import { nodeQuery } from "../utilities/query";
 
 const frameAssertionNodeQuery = nodeQuery("/metastatement/frameAssertion!");
 
-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 = [
     verifyMetastatementAsFrameAssertion,
@@ -20,7 +20,7 @@ function verifyMetastatement(metastatementNode, assignments, derived, localMetaC
   ];
 
   metastatementVerified = verifyMetaStatementFunctions.some((verifyStatementFunction) => {
-    const metastatementVerified = verifyStatementFunction(metastatementNode, assignments, derived, localMetaContext);
+    const metastatementVerified = verifyStatementFunction(metastatementNode, assignments, derived, localContext);
 
     if (metastatementVerified) {
       return true;
@@ -28,49 +28,49 @@ function verifyMetastatement(metastatementNode, assignments, derived, localMetaC
   });
 
   if (metastatementVerified) {
-    localMetaContext.debug(`...verified the '${metastatementString}' metastatement.`, metastatementNode);
+    localContext.debug(`...verified the '${metastatementString}' metastatement.`, metastatementNode);
   }
 
   return metastatementVerified;
 }
 
-Object.assign(metastatementNodeVerifier, {
+Object.assign(metaLevelNodeVerifier, {
   verifyMetastatement
 });
 
 export default verifyMetastatement;
 
-function verifyMetastatementAsFrameAssertion(metastatementNode, assignments, derived, localMetaContext) {
+function verifyMetastatementAsFrameAssertion(metastatementNode, assignments, derived, localContext) {
   let metastatementVerifiedAsFrameAssertion = false;
 
   const frameAssertionNode = frameAssertionNodeQuery(metastatementNode);
 
   if (frameAssertionNode !== null) {
-    const metastatementString = localMetaContext.nodeAsString(metastatementNode);
+    const metastatementString = localContext.nodeAsString(metastatementNode);
 
-    localMetaContext.trace(`Verifying the '${metastatementString}' metastatement as a frame assertion...`, metastatementNode);
+    localContext.trace(`Verifying the '${metastatementString}' metastatement as a frame assertion...`, metastatementNode);
 
-    const frameAssertionVerified = verifyFrameAssertion(frameAssertionNode, assignments, derived, localMetaContext);
+    const frameAssertionVerified = verifyFrameAssertion(frameAssertionNode, assignments, derived, localContext);
 
     metastatementVerifiedAsFrameAssertion = frameAssertionVerified;  ///
 
     if (metastatementVerifiedAsFrameAssertion) {
-      localMetaContext.debug(`...verified the '${metastatementString}' metastatement as a frame assertion.`, metastatementNode);
+      localContext.debug(`...verified the '${metastatementString}' metastatement as a frame assertion.`, metastatementNode);
     }
   }
 
   return metastatementVerifiedAsFrameAssertion;
 }
 
-function verifyMetastatementAsIs(metastatementNode, assignments, derived, localMetaContext) {
+function verifyMetastatementAsIs(metastatementNode, assignments, derived, localContext) {
   let metastatementVerifiedAsIs;
 
   const frameAssertionNode = frameAssertionNodeQuery(metastatementNode);
 
   if (frameAssertionNode === null) {
-    const metastatementString = localMetaContext.nodeAsString(metastatementNode);
+    const metastatementString = localContext.nodeAsString(metastatementNode);
 
-    localMetaContext.trace(`Verifying the '${metastatementString}' metastatement as is...`, metastatementNode);
+    localContext.trace(`Verifying the '${metastatementString}' metastatement as is...`, metastatementNode);
 
     const verifyMetastatementAsIsFunctions = [
       verifyDerivedMetastatementAsIs,
@@ -78,7 +78,7 @@ function verifyMetastatementAsIs(metastatementNode, assignments, derived, localM
     ];
 
     metastatementVerifiedAsIs = verifyMetastatementAsIsFunctions.some((verifyMetastatementAsIsFunction) => {
-      const metastatementVerifiedAsIs = verifyMetastatementAsIsFunction(metastatementNode, assignments, derived, localMetaContext);
+      const metastatementVerifiedAsIs = verifyMetastatementAsIsFunction(metastatementNode, assignments, derived, localContext);
 
       if (metastatementVerifiedAsIs) {
         return true;
@@ -86,35 +86,35 @@ function verifyMetastatementAsIs(metastatementNode, assignments, derived, localM
     });
 
     if (metastatementVerifiedAsIs) {
-      localMetaContext.debug(`...verified the '${metastatementString}' metastatement as is.`, metastatementNode);
+      localContext.debug(`...verified the '${metastatementString}' metastatement as is.`, metastatementNode);
     }
   }
 
   return metastatementVerifiedAsIs;
 }
 
-function verifyDerivedMetastatementAsIs(metastatementNode, assignments, derived, localMetaContext) {
+function verifyDerivedMetastatementAsIs(metastatementNode, assignments, derived, localContext) {
   let derivedMetastatementVerifiedAsIs = false;
 
   if (derived) {
-    const metastatementString = localMetaContext.nodeAsString(metastatementNode);
+    const metastatementString = localContext.nodeAsString(metastatementNode);
 
-    localMetaContext.debug(`Cannot verify the derived '${metastatementString}' metastatement as is.`, metastatementNode);
+    localContext.debug(`Cannot verify the derived '${metastatementString}' metastatement as is.`, metastatementNode);
   }
 
   return derivedMetastatementVerifiedAsIs;
 }
 
-function verifyStatedMetastatementAsIs(metastatementNode, assignments, derived, localMetaContext) {
+function verifyStatedMetastatementAsIs(metastatementNode, assignments, derived, localContext) {
   let statedMetastatementVerifiedAsIs = false;
 
   if (!derived) {
-    const metastatementString = localMetaContext.nodeAsString(metastatementNode);
+    const metastatementString = localContext.nodeAsString(metastatementNode);
 
-    localMetaContext.trace(`Verifying the stated '${metastatementString}' metastatement as is...`, metastatementNode);
+    localContext.trace(`Verifying the stated '${metastatementString}' metastatement as is...`, metastatementNode);
 
     const nonTerminalNode = metastatementNode, ///
-          nonTerminalNodeVerified = metastatementNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localMetaContext, () => {
+          nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;
@@ -123,7 +123,7 @@ function verifyStatedMetastatementAsIs(metastatementNode, assignments, derived,
     statedMetastatementVerifiedAsIs = nonTerminalNodeVerified;  ///
 
     if (statedMetastatementVerifiedAsIs) {
-      localMetaContext.debug(`...verified the stated '${metastatementString}' metastatement as is.`, metastatementNode);
+      localContext.debug(`...verified the stated '${metastatementString}' metastatement as is.`, metastatementNode);
     }
   }
 

package/src/verify/metatheorem.js

@@ -3,8 +3,8 @@
 import Metatheorem from "../metatheorem";
 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";
@@ -19,8 +19,7 @@ export default function verifyMetatheorem(metatheoremNode, fileContext) {
   let metatheoremVerified = false;
 
   const labelNodes = labelNodesQuery(metatheoremNode),
-        labelsString = fileContext.nodesAsString(labelNodes),
-        localMetaContext = LocalMetaContext.fromFileContext(fileContext);
+        labelsString = fileContext.nodesAsString(labelNodes);
 
   fileContext.trace(`Verifying the '${labelsString}' metatheorem...`, metatheoremNode);
 
@@ -28,21 +27,23 @@ export default function verifyMetatheorem(metatheoremNode, fileContext) {
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
-    const substitutions = [],
+    const metaLevelLocalContext = MetaLevelLocalContext.fromFileContext(fileContext),
+          localContext = metaLevelLocalContext, ///
+          substitutions = [],
           metaSuppositions = [],
           metaSuppositionNodes = metaSuppositionsNodeQuery(metatheoremNode),
-          metaSuppositionsVerified = verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, substitutions, localMetaContext);
+          metaSuppositionsVerified = verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, substitutions, localContext);
 
     if (metaSuppositionsVerified) {
       const metaConsequents = [],
             metaConsequentNode = metaConsequentNodeQuery(metatheoremNode),
-            metaConsequentVerified = verifyMetaConsequent(metaConsequentNode, metaConsequents, substitutions, localMetaContext);
+            metaConsequentVerified = verifyMetaConsequent(metaConsequentNode, metaConsequents, substitutions, localContext);
 
       if (metaConsequentVerified) {
         const metaproofNode = metaproofNodeQuery(metatheoremNode),
               firstMetaConsequent = first(metaConsequents),
               metaConsequent = firstMetaConsequent, ///
-              metaproofVerified = verifyMetaproof(metaproofNode, metaConsequent, substitutions, localMetaContext);
+              metaproofVerified = verifyMetaproof(metaproofNode, metaConsequent, substitutions, localContext);
 
         if (metaproofVerified) {
           const metatheorem = Metatheorem.fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(labels, metaSuppositions, metaConsequent, substitutions, fileContext);

package/src/verify/metavariable.js

@@ -66,14 +66,14 @@ export default function verifyMetavariable(metavariableNode, metaTypeNode, fileC
   return metavariableVerified;
 }
 
-export function verifyStandaloneMetavariable(metavariableNode, localMetaContext, verifyAhead) {
+export function verifyStandaloneMetavariable(metavariableNode, localContext, verifyAhead) {
   let standaloneMetavariableVerified = false;
 
-  const metavariableString = localMetaContext.nodeAsString(metavariableNode);
+  const metavariableString = localContext.nodeAsString(metavariableNode);
 
-  localMetaContext.trace(`Verifying the '${metavariableString}' standalone metavariable...`, metavariableNode);
+  localContext.trace(`Verifying the '${metavariableString}' standalone metavariable...`, metavariableNode);
 
-  const metavariablePresent = localMetaContext.isMetavariablePresentByMetavariableNode(metavariableNode, localMetaContext);
+  const metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode, localContext);
 
   if (metavariablePresent) {
     const verifiedAhead = verifyAhead();
@@ -82,7 +82,7 @@ export function verifyStandaloneMetavariable(metavariableNode, localMetaContext,
   }
 
   if (standaloneMetavariableVerified) {
-    localMetaContext.debug(`...verified the '${metavariableString}' standalone metavariable.`, metavariableNode);
+    localContext.debug(`...verified the '${metavariableString}' standalone metavariable.`, metavariableNode);
   }
 
   return standaloneMetavariableVerified;

package/src/verify/premise.js

@@ -13,12 +13,12 @@ const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
       unqualifiedStatementNodeQuery = nodeQuery("/premise/unqualifiedStatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/premise/unqualifiedMetastatement!");
 
-export default function verifyPremise(premiseNode, premises, localMetaContext) {
+export default function verifyPremise(premiseNode, premises, localContext) {
   let premiseVerified;
 
-  const premiseString = localMetaContext.nodeAsString(premiseNode);
+  const premiseString = localContext.nodeAsString(premiseNode);
 
-  localMetaContext.trace(`Verifying the '${premiseString}' premise...`, premiseNode);
+  localContext.trace(`Verifying the '${premiseString}' premise...`, premiseNode);
 
   const unqualifiedStatementNode = unqualifiedStatementNodeQuery(premiseNode),
         unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(premiseNode);
@@ -26,7 +26,6 @@ export default function verifyPremise(premiseNode, premises, localMetaContext) {
   if (unqualifiedStatementNode !== null) {
     const derived = false,
           assignments = [],
-          localContext = localMetaContext,  ///
           unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
 
     if (unqualifiedStatementVerified) {
@@ -39,10 +38,10 @@ export default function verifyPremise(premiseNode, premises, localMetaContext) {
   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);
 
       premiseVerified = assignmentAssigned; ///
@@ -71,9 +70,9 @@ export default function verifyPremise(premiseNode, premises, localMetaContext) {
 
     premises.push(premise);
 
-    localMetaContext.addMetaproofStep(metaproofStep);
+    localContext.addMetaproofStep(metaproofStep);
 
-    localMetaContext.debug(`...verified the '${premiseString}' premise.`, premiseNode);
+    localContext.debug(`...verified the '${premiseString}' premise.`, premiseNode);
   }
 
   return premiseVerified;

package/src/verify/premises.js

@@ -2,11 +2,11 @@
 
 import verifyPremise from "../verify/premise";
 
-export default function verifyPremises(premiseNodes, premises, localMetaContext) {
+export default function verifyPremises(premiseNodes, premises, localContext) {
   let premisesVerified;
 
   premisesVerified = premiseNodes.every((premiseNode) => {
-    const premiseVerified = verifyPremise(premiseNode, premises, localMetaContext);
+    const premiseVerified = verifyPremise(premiseNode, premises, localContext);
 
     if (premiseVerified) {
       return true;

package/src/verify/proof.js

@@ -1,7 +1,7 @@
 "use strict";
 
-import LocalContext from "../context/local";
 import verifyDerivation from "../verify/derivation";
+import IntrinsicLevelLocalContext from "../context/local/intrinsicLevel";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -10,7 +10,9 @@ const derivationNodeQuery = nodeQuery("/proof/derivation!");
 export default function verifyProof(proofNode, conclusion, localContext) {
   let proofVerified = false;
 
-  localContext = LocalContext.fromLocalContext(localContext); ///
+  const intrinsicLevelLocalContext = IntrinsicLevelLocalContext.fromLocalContext(localContext); ///
+
+  localContext = intrinsicLevelLocalContext;  ///
 
   const derivationNode = derivationNodeQuery(proofNode),
         derivationVerified = verifyDerivation(derivationNode, localContext);

package/src/verify/rule.js

@@ -4,8 +4,8 @@ import Rule from "../rule";
 import verifyLabels from "../verify/labels";
 import verifyPremises from "../verify/premises";
 import verifyRuleProof from "../verify/ruleProof";
-import LocalMetaContext from "../context/localMeta";
 import verifyConclusion from "../verify/conclusion";
+import MetaLevelLocalContext from "../context/local/metaLevel";
 
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
@@ -19,8 +19,7 @@ export default function verifyRule(ruleNode, fileContext) {
   let ruleVerified = false;
 
   const labelNodes = labelNodesQuery(ruleNode),
-        labelsString = fileContext.nodesAsString(labelNodes),
-        localMetaContext = LocalMetaContext.fromFileContext(fileContext);
+        labelsString = fileContext.nodesAsString(labelNodes);
 
   fileContext.trace(`Verifying the '${labelsString}' rule...`, ruleNode);
 
@@ -28,14 +27,16 @@ export default function verifyRule(ruleNode, fileContext) {
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
-    const premises = [],
+    const metaLevelLocalContext = MetaLevelLocalContext.fromFileContext(fileContext),
+          premises = [],
+          localContext = metaLevelLocalContext, ///
           premiseNodes = premisesNodeQuery(ruleNode),
-          premisesVerified = verifyPremises(premiseNodes, premises, localMetaContext);
+          premisesVerified = verifyPremises(premiseNodes, premises, localContext);
 
     if (premisesVerified) {
       const conclusions = [],
             conclusionNode = conclusionNodeQuery(ruleNode),
-            conclusionVerified = verifyConclusion(conclusionNode, conclusions, localMetaContext);
+            conclusionVerified = verifyConclusion(conclusionNode, conclusions, localContext);
 
       if (conclusionVerified) {
         const ruleProofNode = ruleProofNodeQuery(ruleNode),
@@ -45,7 +46,7 @@ export default function verifyRule(ruleNode, fileContext) {
         let ruleProofVerified = true; ///
 
         if (ruleProofNode !== null) {
-          ruleProofVerified = verifyRuleProof(ruleProofNode, conclusion, localMetaContext);
+          ruleProofVerified = verifyRuleProof(ruleProofNode, conclusion, localContext);
         }
 
         if (ruleProofVerified) {

package/src/verify/ruleDerivation.js

@@ -6,13 +6,13 @@ import { nodesQuery } from "../utilities/query";
 
 const ruleProofStepNodesQuery = nodesQuery("/ruleDerivation/ruleProofStep|lastRuleProofStep");
 
-export default function verifyRuleDerivation(ruleDerivationNode, localMetaContext) {
+export default function verifyRuleDerivation(ruleDerivationNode, localContext) {
   let ruleDerivationVerified;
 
   const ruleProofStepNodes = ruleProofStepNodesQuery(ruleDerivationNode);
 
   ruleDerivationVerified = ruleProofStepNodes.every((ruleProofStepNode) => {
-    const ruleProofStepVerified = verifyRuleProofStep(ruleProofStepNode, localMetaContext);
+    const ruleProofStepVerified = verifyRuleProofStep(ruleProofStepNode, localContext);
 
     if (ruleProofStepVerified) {
       return true;

package/src/verify/ruleProof.js

@@ -1,22 +1,24 @@
 "use strict";
 
-import LocalMetaContext from "../context/localMeta";
 import verifyRuleDerivation from "../verify/ruleDerivation";
+import MetaLevelLocalContext from "../context/local/metaLevel";
 
 import { nodeQuery } from "../utilities/query";
 
 const ruleDerivationNodeQuery = nodeQuery("/ruleProof/ruleDerivation!");
 
-export default function verifyRuleProof(ruleProofNode, conclusion, localMetaContext) {
+export default function verifyRuleProof(ruleProofNode, conclusion, localContext) {
   let ruleProofVerified = false;
 
-  localMetaContext = LocalMetaContext.fromLocalMetaContext(localMetaContext); ///
+  const metaLevelLocalContext = MetaLevelLocalContext.fromLocalContext(localContext);
+
+  localContext = metaLevelLocalContext; ///
 
   const ruleDerivationNode = ruleDerivationNodeQuery(ruleProofNode),
-        ruleDerivationVerified = verifyRuleDerivation(ruleDerivationNode, localMetaContext);
+        ruleDerivationVerified = verifyRuleDerivation(ruleDerivationNode, localContext);
 
   if (ruleDerivationVerified) {
-    const lastMetaproofStep = localMetaContext.getLastMetaproofStep(),
+    const lastMetaproofStep = localContext.getLastMetaproofStep(),
           metaproofStep = lastMetaproofStep, ///
           metastatementNode = metaproofStep.getMetastatementNode(),
           conclusionMetastatementNode = conclusion.getMetastatementNode(),

package/src/verify/ruleProofStep.js

@@ -4,6 +4,7 @@ import MetaproofStep from "../step/metaproof";
 import verifyRuleSubproof from "../verify/ruleSubproof";
 import verifyRuleSubDerivation from "../verify/ruleSubDerivation";
 import verifyQualifiedStatement from "../verify/statement/qualified";
+import verifyUnqualifiedStatement from "../verify/statement/unqualified";
 import verifyQualifiedMetastatement from "../verify/metastatement/qualified";
 import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
 
@@ -18,7 +19,7 @@ const statementNodeQuery = nodeQuery("/qualifiedStatement|unqualifiedStatement/s
       qualifiedMetastatementNodeQuery = nodeQuery("/ruleProofStep|lastRuleProofStep/qualifiedMetastatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/ruleProofStep|lastRuleProofStep/unqualifiedMetastatement!");
 
-export default function verifyRuleProofStep(ruleProofStepNode, localMetaContext) {
+export default function verifyRuleProofStep(ruleProofStepNode, localContext) {
   let ruleProofStepVerified = false;
 
   const ruleSubproofNode = ruleSubproofNodeQuery(ruleProofStepNode),
@@ -32,20 +33,19 @@ export default function verifyRuleProofStep(ruleProofStepNode, localMetaContext)
   } else if (ruleSubproofNode !== null) {
     let ruleSubproofVerified;
 
-    ruleSubproofVerified = verifyRuleSubproof(ruleSubproofNode, localMetaContext);
+    ruleSubproofVerified = verifyRuleSubproof(ruleSubproofNode, localContext);
 
     if (ruleSubproofVerified) {
       const metaproofStep = MetaproofStep.fromRuleSubproofNode(ruleSubproofNode);
 
-      localMetaContext.addMetaproofStep(metaproofStep);
+      localContext.addMetaproofStep(metaproofStep);
 
       ruleProofStepVerified = true;
     }
   } else if (qualifiedStatementNode !== null) {
     let qualifiedStatementVerified;
 
-    const assignments = [],
-          localContext = localMetaContext;  ///
+    const assignments = [];
 
     qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, assignments, localContext);
 
@@ -59,32 +59,31 @@ export default function verifyRuleProofStep(ruleProofStepNode, localMetaContext)
       const statementNode = statementNodeQuery(qualifiedStatementNode),
             metaproofStep = MetaproofStep.fromStatementNode(statementNode);
 
-      localMetaContext.addMetaproofStep(metaproofStep);
+      localContext.addMetaproofStep(metaproofStep);
 
       ruleProofStepVerified = 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);
 
-      ruleProofStepVerified = qualifiedStatementVerified; ///
+      ruleProofStepVerified = unqualifiedStatementVerified; ///
     }
   } else if (qualifiedMetastatementNode !== null) {
     let qualifiedMetastatementVerified;
@@ -92,11 +91,10 @@ export default function verifyRuleProofStep(ruleProofStepNode, localMetaContext)
     const assignments = [],
           substitutions = null;
 
-    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; ///
     }
@@ -105,7 +103,7 @@ export default function verifyRuleProofStep(ruleProofStepNode, localMetaContext)
       const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
             metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
 
-      localMetaContext.addMetaproofStep(metaproofStep);
+      localContext.addMetaproofStep(metaproofStep);
 
       ruleProofStepVerified = qualifiedMetastatementVerified; ///
     }
@@ -115,11 +113,10 @@ export default function verifyRuleProofStep(ruleProofStepNode, localMetaContext)
     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; ///
     }
@@ -128,7 +125,7 @@ export default function verifyRuleProofStep(ruleProofStepNode, localMetaContext)
       const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
             metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
 
-      localMetaContext.addMetaproofStep(metaproofStep);
+      localContext.addMetaproofStep(metaproofStep);
 
       ruleProofStepVerified = true;
     }

package/src/verify/ruleSubDerivation.js

@@ -4,14 +4,14 @@ import { nodesQuery } from "../utilities/query";
 
 const ruleProofStepNodesQuery = nodesQuery("/ruleSubDerivation/ruleProofStep|lastRuleProofStep");
 
-export default function verifyRuleSubDerivation(ruleSubDerivationNode, localMetaContext) {
+export default function verifyRuleSubDerivation(ruleSubDerivationNode, localContext) {
   let ruleSubDerivationVerified;
 
   const ruleProofStepNodes = ruleProofStepNodesQuery(ruleSubDerivationNode);
 
   ruleSubDerivationVerified = ruleProofStepNodes.every((ruleProofStepNode) => {
     const { verifyRuleProofStep } = verifyRuleSubDerivation,
-          ruleProofStepVerified = verifyRuleProofStep(ruleProofStepNode, localMetaContext);
+          ruleProofStepVerified = verifyRuleProofStep(ruleProofStepNode, localContext);
 
     if (ruleProofStepVerified) {
       return true;

package/src/verify/ruleSubproof.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import verifyPremises from "../verify/premises";
-import LocalMetaContext from "../context/localMeta";
+import MetaLevelLocalContext from "../context/local/metaLevel";
 import verifyRuleSubDerivation from "../verify/ruleSubDerivation";
 
 import { nodeQuery, nodesQuery } from "../utilities/query";
@@ -9,18 +9,20 @@ import { nodeQuery, nodesQuery } from "../utilities/query";
 const premiseNodesQuery = nodesQuery("/ruleSubproof/premise"),
       ruleSubDerivationNodeQuery = nodeQuery("/ruleSubproof/ruleSubDerivation");
 
-export default function verifyRuleSubproof(ruleSubproofNode, localMetaContext) {
+export default function verifyRuleSubproof(ruleSubproofNode, localContext) {
   let ruleSubproofVerified = false;
 
-  localMetaContext = LocalMetaContext.fromLocalMetaContext(localMetaContext); ///
+  const metaLevelLocalContext = MetaLevelLocalContext.fromLocalContext(localContext);
+
+  localContext = metaLevelLocalContext; ///
 
   const premises = [],
         premiseNodes = premiseNodesQuery(ruleSubproofNode),
-        premisesVerified = verifyPremises(premiseNodes, premises, localMetaContext);
+        premisesVerified = verifyPremises(premiseNodes, premises, localContext);
 
   if (premisesVerified) {
     const ruleSubDerivationNode = ruleSubDerivationNodeQuery(ruleSubproofNode),
-          ruleSubDerivationVerified = verifyRuleSubDerivation(ruleSubDerivationNode, localMetaContext);
+          ruleSubDerivationVerified = verifyRuleSubDerivation(ruleSubDerivationNode, localContext);
 
     if (ruleSubDerivationVerified) {
       ruleSubproofVerified = true;

package/src/verify/statement.js

@@ -10,7 +10,6 @@ import statementAgainstCombinatorNodesVerifier from "../verifier/nodes/statement
 import { nodeQuery } from "../utilities/query";
 
 const equalityNodeQuery = nodeQuery("/statement/equality!"),
-      statementNodeQuery = nodeQuery("/containedAssertion/statement!"),
       typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!"),
       definedAssertionNodeQuery = nodeQuery("/statement/definedAssertion!"),
       containedAssertionNodeQuery = nodeQuery("/statement/containedAssertion!");
@@ -159,28 +158,9 @@ function verifyStatementAsContainedAssertion(statementNode, assignments, derived
 
     localContext.trace(`Verifying the '${statementString}' statement as a contained assertion...`, containedAssertionNode);
 
-    const containedVerified = verifyContainedAssertion(containedAssertionNode, assignments, derived, localContext);
+    const containedAssertionVerified = verifyContainedAssertion(containedAssertionNode, assignments, derived, localContext);
 
-    if (containedVerified) {
-      statementNode = statementNodeQuery(containedAssertionNode); ///
-
-      const verifyStatementFunctions = [
-        verifyStatementAsEquality,
-        verifyStatementAgainstCombinators
-      ];
-
-      const statementVerified = verifyStatementFunctions.some((verifyStatementFunction) => {
-        const derived = false,
-              assignments = [],
-              statementVerified = verifyStatementFunction(statementNode, assignments, derived, localContext);
-
-        if (statementVerified) {
-          return true;
-        }
-      });
-
-      statementVerifiedAsContainedAssertion = statementVerified; ///
-    }
+    statementVerifiedAsContainedAssertion = containedAssertionVerified; ///
 
     if (statementVerifiedAsContainedAssertion) {
       localContext.debug(`...verified the '${statementString}' statement as a contained assertion.`, containedAssertionNode);

package/src/verify/subDerivation.js

@@ -4,14 +4,14 @@ import { nodesQuery } from "../utilities/query";
 
 const proofStepNodesQuery = nodesQuery("/subDerivation/proofStep|lastProofStep");
 
-export default function verifySubDerivation(subDerivationNode, localMetaContext) {
+export default function verifySubDerivation(subDerivationNode, localContext) {
   let subDerivationVerified;
 
   const proofStepNodes = proofStepNodesQuery(subDerivationNode);
 
   subDerivationVerified = proofStepNodes.every((proofStepNode) => {
     const { verifyProofStep } = verifySubDerivation,
-          proofStepVerified = verifyProofStep(proofStepNode, localMetaContext);
+          proofStepVerified = verifyProofStep(proofStepNode, localContext);
 
     if (proofStepVerified) {
       return true;