occam-verify-cli 0.0.682 → 0.0.684

package/src/verify/axiom.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import Axiom from "../axiom";
-import ProofContext from "../context/proof";
+import LocalContext from "../context/local";
 import verifyLabels from "../verify/labels";
 import verifyConsequent from "../verify/consequent";
 import verifySupposition from "../verify/supposition";
@@ -18,7 +18,7 @@ export default function verifyAxiom(axiomNode, fileContext) {
 
   const labelNodes = labelNodesQuery(axiomNode),
         labelsString = fileContext.nodesAsString(labelNodes),
-        proofContext = ProofContext.fromFileContext(fileContext);
+        localContext = LocalContext.fromFileContext(fileContext);
 
   fileContext.trace(`Verifying the '${labelsString}' axiom...`, axiomNode);
 
@@ -29,7 +29,7 @@ export default function verifyAxiom(axiomNode, fileContext) {
     const suppositions = [],
           suppositionNodes = suppositionsNodeQuery(axiomNode),
           suppositionsVerified = suppositionNodes.every((suppositionNode) => {
-            const suppositionVerified = verifySupposition(suppositionNode, suppositions, proofContext);
+            const suppositionVerified = verifySupposition(suppositionNode, suppositions, localContext);
 
             if (suppositionVerified) {
               return true;
@@ -39,12 +39,12 @@ export default function verifyAxiom(axiomNode, fileContext) {
     if (suppositionsVerified) {
       const consequents = [],
             consequentNode = consequentNodeQuery(axiomNode),
-            consequentVerified = verifyConsequent(consequentNode, consequents, proofContext);
+            consequentVerified = verifyConsequent(consequentNode, consequents, localContext);
 
       if (consequentVerified) {
         const firstConsequent = first(consequents),
               consequent = firstConsequent, ///
-              axiom = Axiom.fromLabelsSuppositionsConsequentAndProofContext(labels, suppositions, consequent, proofContext);
+              axiom = Axiom.fromLabelsSuppositionsConsequentAndLocalContext(labels, suppositions, consequent, localContext);
 
         fileContext.addAxiom(axiom);
 

package/src/verify/conclusion.js

@@ -8,16 +8,16 @@ import { nodeQuery } from "../utilities/query";
 const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/conclusion/unqualifiedMetastatement!");
 
-export default function verifyConclusion(conclusionNode, conclusions, metaproofContext) {
+export default function verifyConclusion(conclusionNode, conclusions, localMetaContext) {
   let conclusionVerified = false;
 
-  const conclusionString = metaproofContext.nodeAsString(conclusionNode);
+  const conclusionString = localMetaContext.nodeAsString(conclusionNode);
 
-  metaproofContext.trace(`Verifying the '${conclusionString}' conclusion...`, conclusionNode);
+  localMetaContext.trace(`Verifying the '${conclusionString}' conclusion...`, conclusionNode);
 
   const derived = false,
         unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(conclusionNode),
-        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, derived, metaproofContext);
+        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, derived, localMetaContext);
 
   if (unqualifiedMetastatementVerified) {
     const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
@@ -29,7 +29,7 @@ export default function verifyConclusion(conclusionNode, conclusions, metaproofC
   }
 
   if (conclusionVerified) {
-    metaproofContext.debug(`...verified the '${conclusionString}' conclusion.`, conclusionNode);
+    localMetaContext.debug(`...verified the '${conclusionString}' conclusion.`, conclusionNode);
   }
 
   return conclusionVerified;

package/src/verify/conjecture.js

@@ -2,7 +2,7 @@
 
 import Conjecture from "../conjecture";
 import verifyProof from "../verify/proof";
-import ProofContext from "../context/proof";
+import LocalContext from "../context/local";
 import verifyLabels from "../verify/labels";
 import verifyConsequent from "./consequent";
 import verifySupposition from "./supposition";
@@ -20,7 +20,7 @@ export default function verifyConjecture(conjectureNode, fileContext) {
 
   const labelNodes = labelNodesQuery(conjectureNode),
         labelsString = fileContext.nodesAsString(labelNodes),
-        proofContext = ProofContext.fromFileContext(fileContext);
+        localContext = LocalContext.fromFileContext(fileContext);
 
   fileContext.trace(`Verifying the '${labelsString}' conjecture...`, conjectureNode);
 
@@ -31,7 +31,7 @@ export default function verifyConjecture(conjectureNode, fileContext) {
     const suppositions = [],
           suppositionNodes = suppositionsNodeQuery(conjectureNode),
           suppositionsVerified = suppositionNodes.every((suppositionNode) => {
-            const suppositionVerified = verifySupposition(suppositionNode, suppositions, proofContext);
+            const suppositionVerified = verifySupposition(suppositionNode, suppositions, localContext);
 
             if (suppositionVerified) {
               return true;
@@ -41,16 +41,16 @@ export default function verifyConjecture(conjectureNode, fileContext) {
     if (suppositionsVerified) {
       const consequents = [],
             consequentNode = consequentNodeQuery(conjectureNode),
-            consequentVerified = verifyConsequent(consequentNode, consequents, proofContext);
+            consequentVerified = verifyConsequent(consequentNode, consequents, localContext);
 
       if (consequentVerified) {
         const proofNode = proofNodeQuery(conjectureNode),
               firstConsequent = first(consequents),
               consequent = firstConsequent; ///
 
-        verifyProof(proofNode, consequent, proofContext);
+        verifyProof(proofNode, consequent, localContext);
 
-        const conjecture = Conjecture.fromLabelsSuppositionsConsequentAndProofContext(labels, suppositions, consequent, proofContext);
+        const conjecture = Conjecture.fromLabelsSuppositionsConsequentAndLocalContext(labels, suppositions, consequent, localContext);
 
         fileContext.addConjecture(conjecture);
 

package/src/verify/consequent.js

@@ -8,17 +8,17 @@ import { nodeQuery } from "../utilities/query";
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
       unqualifiedStatementNodeQuery = nodeQuery("/consequent/unqualifiedStatement!");
 
-export default function verifyConsequent(consequentNode, consequents, proofContext) {
+export default function verifyConsequent(consequentNode, consequents, localContext) {
   let consequentVerified = false;
 
-  const consequentString = proofContext.nodeAsString(consequentNode);
+  const consequentString = localContext.nodeAsString(consequentNode);
 
-  proofContext.trace(`Verifying the '${consequentString}' consequent...`, consequentNode);
+  localContext.trace(`Verifying the '${consequentString}' consequent...`, consequentNode);
 
   const derived = false,
         assignments = [],
         unqualifiedStatementNode = unqualifiedStatementNodeQuery(consequentNode),
-        unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, proofContext);
+        unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
 
   if (unqualifiedStatementVerified) {
     const statementNode = statementNodeQuery(unqualifiedStatementNode),
@@ -30,7 +30,7 @@ export default function verifyConsequent(consequentNode, consequents, proofConte
   }
 
   if (consequentVerified) {
-    proofContext.debug(`...verified the '${consequentString}' consequent.`, consequentNode);
+    localContext.debug(`...verified the '${consequentString}' consequent.`, consequentNode);
   }
 
   return consequentVerified;

package/src/verify/derivation.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import ProofStep from "../step/proof";
-import ProofContext from "../context/proof";
+import LocalContext from "../context/local";
 import verifySupposition from "./supposition";
 import verifyQualifiedStatement from "../verify/statement/qualified";
 import verifyUnqualifiedStatement from "../verify/statement/unqualified";
@@ -14,13 +14,13 @@ const childNodesQuery = nodesQuery("/derivation|subDerivation/*"),
       suppositionNodesQuery = nodesQuery("/subproof/supposition"),
       subDerivationNodeQuery = nodeQuery("/subproof/subDerivation");
 
-export default function verifyDerivation(derivationNode, proofContext) {
+export default function verifyDerivation(derivationNode, localContext) {
   let derivationVerified;
 
   const childNodes = childNodesQuery(derivationNode);
 
   derivationVerified = childNodes.every((childNode) => {
-    const childVerified = verifyChild(childNode, proofContext);
+    const childVerified = verifyChild(childNode, localContext);
 
     if (childVerified) {
       return true;
@@ -30,13 +30,13 @@ export default function verifyDerivation(derivationNode, proofContext) {
   return derivationVerified;
 }
 
-function verifySubDerivation(subDerivationNode, proofContext) {
+function verifySubDerivation(subDerivationNode, localContext) {
   let subDerivationVerified;
 
   const childNodes = childNodesQuery(subDerivationNode);
 
   subDerivationVerified = childNodes.every((childNode) => {
-    const childVerified = verifyChild(childNode, proofContext);
+    const childVerified = verifyChild(childNode, localContext);
 
     if (childVerified) {
       return true;
@@ -46,15 +46,15 @@ function verifySubDerivation(subDerivationNode, proofContext) {
   return subDerivationVerified;
 }
 
-function verifySubproof(subproofNode, proofContext) {
+function verifySubproof(subproofNode, localContext) {
   let subproofVerified = false;
 
-  proofContext = ProofContext.fromProofContext(proofContext); ///
+  localContext = LocalContext.fromLocalContext(localContext); ///
 
   const suppositions = [],
         suppositionNodes = suppositionNodesQuery(subproofNode),
         suppositionsVerified = suppositionNodes.every((suppositionNode) => {
-          const suppositionVerified = verifySupposition(suppositionNode, suppositions, proofContext);
+          const suppositionVerified = verifySupposition(suppositionNode, suppositions, localContext);
 
           if (suppositionVerified) {
             return true;
@@ -63,7 +63,7 @@ function verifySubproof(subproofNode, proofContext) {
 
   if (suppositionsVerified) {
     const subDerivationNode = subDerivationNodeQuery(subproofNode),
-          subDerivationVerified = verifySubDerivation(subDerivationNode, proofContext);
+          subDerivationVerified = verifySubDerivation(subDerivationNode, localContext);
 
     if (subDerivationVerified) {
       subproofVerified = true;
@@ -73,7 +73,7 @@ function verifySubproof(subproofNode, proofContext) {
   return subproofVerified;
 }
 
-function verifyChild(childNode, proofContext) {
+function verifyChild(childNode, localContext) {
   let childVerified;
 
   const childNodeRuleName = childNode.getRuleName();
@@ -81,12 +81,12 @@ function verifyChild(childNode, proofContext) {
   switch (childNodeRuleName) {
     case SUBPROOF_RULE_NAME: {
       const subproofNode = childNode,  ///
-            subproofVerified = verifySubproof(subproofNode, proofContext);
+            subproofVerified = verifySubproof(subproofNode, localContext);
 
       if (subproofVerified) {
         const proofStep = ProofStep.fromSubproofNode(subproofNode);
 
-        proofContext.addProofStep(proofStep);
+        localContext.addProofStep(proofStep);
 
         childVerified = true;
       }
@@ -98,13 +98,13 @@ function verifyChild(childNode, proofContext) {
       const derived = true,
             assignments = [],
             qualifiedStatementNode = childNode,  ///
-            qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, assignments, derived, proofContext);
+            qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, assignments, derived, localContext);
 
       if (qualifiedStatementVerified) {
         const statementNode = statementNodeQuery(qualifiedStatementNode),
               proofStep = ProofStep.fromStatementNode(statementNode);
 
-        proofContext.addProofStep(proofStep);
+        localContext.addProofStep(proofStep);
 
         childVerified = qualifiedStatementVerified; ///
       }
@@ -116,13 +116,13 @@ function verifyChild(childNode, proofContext) {
       const derived = true,
             assignments = [],
             unqualifiedStatementNode = childNode,  ///
-            unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, proofContext);
+            unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
 
       if (unqualifiedStatementVerified) {
         const statementNode = statementNodeQuery(unqualifiedStatementNode),
               proofStep = ProofStep.fromStatementNode(statementNode);
 
-        proofContext.addProofStep(proofStep);
+        localContext.addProofStep(proofStep);
 
         childVerified = true;
       }

package/src/verify/equality.js

@@ -2,6 +2,13 @@
 
 import Equality from "../equality";
 import verifyTerms from "../verify/terms";
+import EqualityAssignment from "../assignment/equality";
+
+import { nodeQuery } from "../utilities/query";
+import { first, second } from "../utilities/array";
+
+const leftTermNodeQuery = nodeQuery("/equality/argument[0]/term!"),
+      rightTermNodeQuery = nodeQuery("/equality/argument[1]/term!");
 
 export default function verifyEquality(equalityNode, assignments, derived, context, verifyAhead) {
   let equalityVerified;
@@ -10,15 +17,15 @@ export default function verifyEquality(equalityNode, assignments, derived, conte
 
   context.trace(`Verifying the '${equalityString}' equality...`, equalityNode);
 
-  const verifyStatementAsEqualityFunctions = [
+  const verifyEqualityFunctions = [
     verifyDerivedEquality,
     verifyStandaloneEquality
   ];
 
-  equalityVerified = verifyStatementAsEqualityFunctions.some((verifyStatementAsEqualityFunction) => {
-    const statementVerified = verifyStatementAsEqualityFunction(equalityNode, derived, context, verifyAhead);
+  equalityVerified = verifyEqualityFunctions.some((verifyEqualityFunction) => {
+    const equalityVerified = verifyEqualityFunction(equalityNode, assignments, derived, context, verifyAhead);
 
-    if (statementVerified) {
+    if (equalityVerified) {
       return true;
     }
   });
@@ -30,47 +37,97 @@ export default function verifyEquality(equalityNode, assignments, derived, conte
   return equalityVerified;
 }
 
-function verifyDerivedEquality(equalityNode, derived, context, verifyAhead) {
-  let verifiedStatementAsDerivedEquality = false;
+function verifyDerivedEquality(equalityNode, assignments, derived, context, verifyAhead) {
+  let derivedEqualityVerified = false;
 
   if (derived) {
     const equalityString = context.nodeAsString(equalityNode);
 
     context.trace(`Verifying the '${equalityString}' derived equality...`, equalityNode);
 
-    const equality = Equality.fromEqualityNode(equalityNode),
-          equalities = context.getEqualities(),
-          equalityVerified = equality.verify(equalities, context, verifyAhead);
-
-    verifiedStatementAsDerivedEquality = equalityVerified;  ///
-
-    if (verifiedStatementAsDerivedEquality) {
-      context.debug(`...verified the '${equalityString}' derived equality.`, equalityNode);
+    const terms = [],
+          leftTermNode = leftTermNodeQuery(equalityNode),
+          rightTermNode = rightTermNodeQuery(equalityNode),
+          termNodes = [
+            leftTermNode,
+            rightTermNode
+          ],
+          termsVerified = verifyTerms(termNodes, terms, context, () => {
+            let verifiedAhead = false;
+
+            const firstTerm = first(terms),
+                  secondTerm = second(terms),
+                  leftTerm = firstTerm, ///
+                  rightTerm = secondTerm, ///
+                  equality = Equality.fromLeftTermAndRightTerm(leftTerm, rightTerm);
+
+            if (equality !== null) {
+              const equalityEqual = context.isEqualityEqual(equality);
+
+              if (equalityEqual) {
+                verifiedAhead = verifyAhead();
+              }
+            }
+
+            return verifiedAhead;
+          });
+
+    derivedEqualityVerified = termsVerified; ///
+
+    if (derivedEqualityVerified) {
+      context.trace(`...verified the '${equalityString}' derived equality.`, equalityNode);
     }
   }
 
-  return verifiedStatementAsDerivedEquality;
+  return derivedEqualityVerified;
 }
 
-function verifyStandaloneEquality(equalityNode, derived, context, verifyAhead) {
-  let statementVerifiedAsStandaloneEquality = false;
+function verifyStandaloneEquality(equalityNode, assignments, derived, context, verifyAhead) {
+  let standaloneEqualityVerified = false;
 
   if (!derived) {
     const equalityString = context.nodeAsString(equalityNode);
 
     context.trace(`Verifying the '${equalityString}' standalone equality...`, equalityNode);
 
-    const equality = Equality.fromEqualityNode(equalityNode),
-          leftTermNode = equality.getLeftTermNode(),
-          rightTermNode = equality.getRightTermNode(),
-          termsVerified = verifyTerms(leftTermNode, rightTermNode, context, verifyAhead);
+    const terms = [],
+          leftTermNode = leftTermNodeQuery(equalityNode),
+          rightTermNode = rightTermNodeQuery(equalityNode),
+          termNodes = [
+            leftTermNode,
+            rightTermNode
+          ],
+          termsVerified = verifyTerms(termNodes, terms, context, () => {
+            let verifiedAhead = false;
+
+            const firstTerm = first(terms),
+                  secondTerm = second(terms),
+                  leftTerm = firstTerm, ///
+                  rightTerm = secondTerm, ///
+                  equality = Equality.fromLeftTermAndRightTerm(leftTerm, rightTerm);
+
+            if (equality !== null) {
+              const equalityAssignment = EqualityAssignment.fromEquality(equality),
+                    assignment = equalityAssignment; ///
+
+              assignments.push(assignment);
+
+              verifiedAhead = verifyAhead();
+
+              if (!verifiedAhead) {
+                assignments.pop();
+              }
+            }
+
+            return verifiedAhead;
+          });
 
-    statementVerifiedAsStandaloneEquality = termsVerified; ///
+    standaloneEqualityVerified = termsVerified; ///
 
-    if (statementVerifiedAsStandaloneEquality) {
+    if (standaloneEqualityVerified) {
       context.trace(`...verified the '${equalityString}' standalone equality.`, equalityNode);
     }
   }
 
-  return statementVerifiedAsStandaloneEquality;
+  return standaloneEqualityVerified;
 }

package/src/verify/lemma.js

@@ -2,7 +2,7 @@
 
 import Lemma from "../lemma";
 import verifyProof from "../verify/proof";
-import ProofContext from "../context/proof";
+import LocalContext from "../context/local";
 import verifyLabels from "../verify/labels";
 import verifyConsequent from "./consequent";
 import verifySupposition from "./supposition";
@@ -21,7 +21,7 @@ export default function verifyLemma(lemmaNode, fileContext) {
 
   const labelNodes = labelNodesQuery(lemmaNode),
         labelsString = fileContext.nodesAsString(labelNodes),
-        proofContext = ProofContext.fromFileContext(fileContext);
+        localContext = LocalContext.fromFileContext(fileContext);
 
   (labelsString === EMPTY_STRING) ?
     fileContext.trace(`Verifying a lemma...`, lemmaNode) :
@@ -34,7 +34,7 @@ export default function verifyLemma(lemmaNode, fileContext) {
     const suppositions = [],
           suppositionNodes = suppositionsNodeQuery(lemmaNode),
           suppositionsVerified = suppositionNodes.every((suppositionNode) => {
-            const suppositionVerified = verifySupposition(suppositionNode, suppositions, proofContext);
+            const suppositionVerified = verifySupposition(suppositionNode, suppositions, localContext);
 
             if (suppositionVerified) {
               return true;
@@ -44,16 +44,16 @@ export default function verifyLemma(lemmaNode, fileContext) {
     if (suppositionsVerified) {
       const consequents = [],
             consequentNode = consequentNodeQuery(lemmaNode),
-            consequentVerified = verifyConsequent(consequentNode, consequents, proofContext);
+            consequentVerified = verifyConsequent(consequentNode, consequents, localContext);
 
       if (consequentVerified) {
         const proofNode = proofNodeQuery(lemmaNode),
               firstConsequent = first(consequents),
               consequent = firstConsequent, ///
-              proofVerified = verifyProof(proofNode, consequent, proofContext);
+              proofVerified = verifyProof(proofNode, consequent, localContext);
 
         if (proofVerified) {
-          const lemma = Lemma.fromLabelsSuppositionsConsequentAndProofContext(labels, suppositions, consequent, proofContext);
+          const lemma = Lemma.fromLabelsSuppositionsConsequentAndLocalContext(labels, suppositions, consequent, localContext);
 
           fileContext.addLemma(lemma);
 

package/src/verify/metastatement/qualified.js

@@ -5,29 +5,29 @@ import { nodeQuery, referenceNameFromReferenceNode } from "../../utilities/query
 const referenceNodeQuery = nodeQuery("/qualifiedMetastatement/qualification!/reference!"),
       metastatementNodeQuery = nodeQuery("/qualifiedMetastatement/metastatement!");
 
-export default function verifyQualifiedMetastatement(qualifiedMetastatementNode, assignments, derived, metaproofContext) {
+export default function verifyQualifiedMetastatement(qualifiedMetastatementNode, assignments, derived, localMetaContext) {
   let qualifiedMetastatementVerified = false;
 
   const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode);
 
   if (metastatementNode !== null) {
-    const metastatementString = metaproofContext.nodeAsString(metastatementNode),
-          metastatementMetaproofContext = metaproofContext; ///
+    const metastatementString = localMetaContext.nodeAsString(metastatementNode),
+          metastatementLocalMetaContext = localMetaContext; ///
 
-    metaproofContext.trace(`Verifying the '${metastatementString}' qualified metastatement...`, qualifiedMetastatementNode);
+    localMetaContext.trace(`Verifying the '${metastatementString}' qualified metastatement...`, qualifiedMetastatementNode);
 
     const referenceNode = referenceNodeQuery(qualifiedMetastatementNode),
           referenceName = referenceNameFromReferenceNode(referenceNode),
-          rule = metaproofContext.findRuleByReferenceName(referenceName);
+          rule = localMetaContext.findRuleByReferenceName(referenceName);
 
     if (rule !== null) {
-      const ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, metastatementMetaproofContext);
+      const ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, metastatementLocalMetaContext);
 
       qualifiedMetastatementVerified = ruleMatchesMetastatement;  ///
     }
 
     if (qualifiedMetastatementVerified) {
-      metaproofContext.debug(`...verified the '${metastatementString}' qualified metastatement.`, qualifiedMetastatementNode);
+      localMetaContext.debug(`...verified the '${metastatementString}' qualified metastatement.`, qualifiedMetastatementNode);
     }
   }
 

package/src/verify/metastatement/unqualified.js

@@ -6,24 +6,24 @@ import { nodeQuery } from "../../utilities/query";
 
 const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
 
-export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, derived, metaproofContext) {
+export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, derived, localMetaContext) {
   let unqualifiedMetastatementVerified = false;
 
   const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
 
   if (metastatementNode !== null) {
-    const metastatementString = metaproofContext.nodeAsString(metastatementNode);
+    const metastatementString = localMetaContext.nodeAsString(metastatementNode);
 
-    metaproofContext.trace(`Verifying the '${metastatementString}' unqualified metastatement...`, unqualifiedMetastatementNode);
+    localMetaContext.trace(`Verifying the '${metastatementString}' unqualified metastatement...`, unqualifiedMetastatementNode);
 
     if (derived) {
-      const metastatementMatches = metaproofContext.matchMetastatement(metastatementNode);
+      const metastatementMatches = localMetaContext.matchMetastatement(metastatementNode);
 
       unqualifiedMetastatementVerified = metastatementMatches;  ///
     }
 
     if (!unqualifiedMetastatementVerified) {
-      const metastatementVerified = verifyMetastatement(metastatementNode, derived, metaproofContext, () => {
+      const metastatementVerified = verifyMetastatement(metastatementNode, derived, localMetaContext, () => {
         const verifiedAhead = true;
 
         return verifiedAhead;
@@ -33,7 +33,7 @@ export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementN
     }
 
     if (unqualifiedMetastatementVerified) {
-      metaproofContext.debug(`...verified the '${metastatementString}' unqualified metastatement.`, unqualifiedMetastatementNode);
+      localMetaContext.debug(`...verified the '${metastatementString}' unqualified metastatement.`, unqualifiedMetastatementNode);
     }
   }
 

package/src/verify/metastatement.js

@@ -2,19 +2,19 @@
 
 import metastatementNodeVerifier from "../verifier/node/metastatement";
 
-function verifyMetastatement(metastatementNode, derived, metaproofContext) {
+function verifyMetastatement(metastatementNode, derived, localMetaContext) {
   let metastatementVerified;
 
-  const metastatementString = metaproofContext.nodeAsString(metastatementNode);
+  const metastatementString = localMetaContext.nodeAsString(metastatementNode);
 
-  metaproofContext.trace(`Verifying the '${metastatementString}' metastatement...`, metastatementNode);
+  localMetaContext.trace(`Verifying the '${metastatementString}' metastatement...`, metastatementNode);
 
   const verifyMetastatementFunctions = [
     verifyStandaloneMetastatement
   ];
 
-  metastatementVerified = verifyMetastatementFunctions.some((verifyStatementFunction) => {
-    const metastatementVerified = verifyStatementFunction(metastatementNode, derived, metaproofContext);
+  metastatementVerified = verifyMetastatementFunctions.some((verifyMetastatementFunction) => {
+    const metastatementVerified = verifyMetastatementFunction(metastatementNode, derived, localMetaContext);
 
     if (metastatementVerified) {
       return true;
@@ -22,7 +22,7 @@ function verifyMetastatement(metastatementNode, derived, metaproofContext) {
   });
 
   if (metastatementVerified) {
-    metaproofContext.debug(`...verified the '${metastatementString}' metastatement.`, metastatementNode);
+    localMetaContext.debug(`...verified the '${metastatementString}' metastatement.`, metastatementNode);
   }
 
   return metastatementVerified;
@@ -34,15 +34,15 @@ Object.assign(verifyMetastatement, {
 
 export default verifyMetastatement;
 
-function verifyStandaloneMetastatement(metastatementNode, derived, metaproofContext) {
+function verifyStandaloneMetastatement(metastatementNode, derived, localMetaContext) {
   let standaloneMetastatementVerified;
 
-  const metastatementString = metaproofContext.nodeAsString(metastatementNode);
+  const metastatementString = localMetaContext.nodeAsString(metastatementNode);
 
-  metaproofContext.trace(`Verifying the '${metastatementString}' standalone metastatement...`, metastatementNode);
+  localMetaContext.trace(`Verifying the '${metastatementString}' standalone metastatement...`, metastatementNode);
 
   const nonTerminalNode = metastatementNode, ///
-        nonTerminalNodeVerified = metastatementNodeVerifier.verifyNonTerminalNode(nonTerminalNode, metaproofContext, () => {
+        nonTerminalNodeVerified = metastatementNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localMetaContext, () => {
           const verifiedAhead = true;
 
           return verifiedAhead;
@@ -51,7 +51,7 @@ function verifyStandaloneMetastatement(metastatementNode, derived, metaproofCont
   standaloneMetastatementVerified = nonTerminalNodeVerified;  ///
 
   if (standaloneMetastatementVerified) {
-    metaproofContext.debug(`...verified the '${metastatementString}' standalone metastatement.`, metastatementNode);
+    localMetaContext.debug(`...verified the '${metastatementString}' standalone metastatement.`, metastatementNode);
   }
 
   return standaloneMetastatementVerified;

package/src/verify/premise.js

@@ -9,16 +9,16 @@ import { nodeQuery } from "../utilities/query";
 const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/premise/unqualifiedMetastatement!");
 
-export default function verifyPremise(premiseNode, premises, metaproofContext) {
+export default function verifyPremise(premiseNode, premises, localMetaContext) {
   let premiseVerified;
 
-  const premiseString = metaproofContext.nodeAsString(premiseNode);
+  const premiseString = localMetaContext.nodeAsString(premiseNode);
 
-  metaproofContext.trace(`Verifying the '${premiseString}' premise...`, premiseNode);
+  localMetaContext.trace(`Verifying the '${premiseString}' premise...`, premiseNode);
 
   const derived = false,
         unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(premiseNode),
-        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, derived, metaproofContext);
+        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, derived, localMetaContext);
 
   if (unqualifiedMetastatementVerified) {
     const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
@@ -27,13 +27,13 @@ export default function verifyPremise(premiseNode, premises, metaproofContext) {
 
     premises.push(premise);
 
-    metaproofContext.addMetaproofStep(metaproofStep);
+    localMetaContext.addMetaproofStep(metaproofStep);
 
     premiseVerified = true;
   }
 
   if (premiseVerified) {
-    metaproofContext.debug(`...verified the '${premiseString}' premise.`, premiseNode);
+    localMetaContext.debug(`...verified the '${premiseString}' premise.`, premiseNode);
   }
 
   return premiseVerified;