occam-verify-cli 0.0.1089 → 0.0.1091

package/src/mixins/statement/unify.js

@@ -3,7 +3,7 @@
 import BracketedCombinator from "../../combinator/bracketed";
 import statementWithCombinatorUnifier from "../../unifier/statementWithCombinator";
 
-function unifyWithBracketedCombinator(statement, assignments, stated, localContext) {
+function unifyWithBracketedCombinator(statement, assignments, stated, context) {
   let unifiedWithBracketedCombinator;
 
   const statementNode = statement.getNode(),
@@ -12,28 +12,28 @@ function unifyWithBracketedCombinator(statement, assignments, stated, localConte
         bracketedCombinatorStatementNode = bracketedCombinator.getStatementNode(),
         combinatorStatementNode = bracketedCombinatorStatementNode; ///
 
-  localContext.trace(`Unifying the '${statementString}' statement with the bracketed combinator...`);
+  context.trace(`Unifying the '${statementString}' statement with the bracketed combinator...`);
 
-  unifiedWithBracketedCombinator = statementWithCombinatorUnifier.unify(combinatorStatementNode, statementNode, assignments, stated, localContext);
+  unifiedWithBracketedCombinator = statementWithCombinatorUnifier.unify(combinatorStatementNode, statementNode, assignments, stated, context);
 
   if (unifiedWithBracketedCombinator) {
-    localContext.debug(`...unified the '${statementString}' statement with the bracketed combinator.`);
+    context.debug(`...unified the '${statementString}' statement with the bracketed combinator.`);
   }
 
   return unifiedWithBracketedCombinator;
 }
 
-function unifyWithCombinators(statement, assignments, stated, localContext) {
+function unifyWithCombinators(statement, assignments, stated, context) {
   let unifiedWithCombinators;
 
-  const combinators = localContext.getCombinators();
+  const combinators = context.getCombinators();
 
   stated = true;  ///
 
   assignments = null; ///
 
   unifiedWithCombinators = combinators.some((combinator) => {
-    const unifiedWithCombinator = unifyStatementWithCombinator(statement, combinator, assignments, stated, localContext);
+    const unifiedWithCombinator = unifyStatementWithCombinator(statement, combinator, assignments, stated, context);
 
     if (unifiedWithCombinator) {
       return true;
@@ -51,7 +51,7 @@ const unifyMixins = [
 
 export default unifyMixins;
 
-function unifyStatementWithCombinator(statement, combinator, assignments, stated, localContext) {
+function unifyStatementWithCombinator(statement, combinator, assignments, stated, context) {
   let unifiedWithCombinator;
 
   const statementNode = statement.getNode(),
@@ -59,12 +59,12 @@ function unifyStatementWithCombinator(statement, combinator, assignments, stated
         combinatorString = combinator.getString(),
         combinatorStatementNode = combinator.getStatementNode();
 
-  localContext.trace(`Unifying the '${statementString}' statement with the '${combinatorString}' combinator...`);
+  context.trace(`Unifying the '${statementString}' statement with the '${combinatorString}' combinator...`);
 
-  unifiedWithCombinator = statementWithCombinatorUnifier.unify(combinatorStatementNode, statementNode, assignments, stated, localContext);
+  unifiedWithCombinator = statementWithCombinatorUnifier.unify(combinatorStatementNode, statementNode, assignments, stated, context);
 
   if (unifiedWithCombinator) {
-    localContext.debug(`...unified the '${statementString}' statement with the '${combinatorString}' combinator.`);
+    context.debug(`...unified the '${statementString}' statement with the '${combinatorString}' combinator.`);
   }
 
   return unifiedWithCombinator;

package/src/mixins/statement/verify.js

@@ -16,171 +16,171 @@ const equalityNodeQuery = nodeQuery("/statement/equality"),
       subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion"),
       containedAssertionNodeQuery = nodeQuery("/statement/containedAssertion");
 
-function verifyAsMetavariable(statement, assignments, stated, localContext) {
+function verifyAsMetavariable(statement, assignments, stated, context) {
   let verifiedAsMetavariable = false;
 
   const { Metavariable } = shim,
         statementNode = statement.getNode(),
         metavariableNode = metavariableNodeQuery(statementNode),
-        metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext);
+        metavariable = Metavariable.fromMetavariableNode(metavariableNode, context);
 
   if (metavariable !== null) {
     const statementString = statement.getString();
 
-    localContext.trace(`Verifying the '${statementString}' statement as a metavariable...`);
+    context.trace(`Verifying the '${statementString}' statement as a metavariable...`);
 
-    const metavariableVerified = metavariable.verify(localContext);
+    const metavariableVerified = metavariable.verify(context);
 
     verifiedAsMetavariable = metavariableVerified; ///
 
     if (verifiedAsMetavariable) {
-      localContext.debug(`...verified the '${statementString}' statement as a metavariable.`);
+      context.debug(`...verified the '${statementString}' statement as a metavariable.`);
     }
   }
 
   return verifiedAsMetavariable;
 }
 
-function verifyAsEquality(statement, assignments, stated, localContext) {
+function verifyAsEquality(statement, assignments, stated, context) {
   let verifiedAsEquality = false;
 
   const { Equality } = shim,
         statementNode = statement.getNode(),
         equalityNode = equalityNodeQuery(statementNode),
-        equality = Equality.fromEqualityNode(equalityNode, localContext);
+        equality = Equality.fromEqualityNode(equalityNode, context);
 
   if (equality !== null) {
     const statementString = statement.getString();
 
-    localContext.trace(`Verifying the '${statementString}' statement as an equality...`);
+    context.trace(`Verifying the '${statementString}' statement as an equality...`);
 
-    const equalityVerified = equality.verify(assignments, stated, localContext);
+    const equalityVerified = equality.verify(assignments, stated, context);
 
     verifiedAsEquality = equalityVerified; ///
 
     if (verifiedAsEquality) {
-      localContext.debug(`...verified the '${statementString}' statement as an equality.`);
+      context.debug(`...verified the '${statementString}' statement as an equality.`);
     }
   }
 
   return verifiedAsEquality;
 }
 
-function verifyAsJudgement(statement, assignments, stated, localContext) {
+function verifyAsJudgement(statement, assignments, stated, context) {
   let verifiedAsJudgement = false;
 
   const { Judgement } = shim,
         statementNode = statement.getNode(),
         judgementNode = judgementNodeQuery(statementNode),
-        judgement = Judgement.fromJudgementNode(judgementNode, localContext);
+        judgement = Judgement.fromJudgementNode(judgementNode, context);
 
   if (judgement !== null) {
     const statementString = statement.getString();
 
-    localContext.trace(`Verifying the '${statementString}' statement as a judgement...`);
+    context.trace(`Verifying the '${statementString}' statement as a judgement...`);
 
-    const judgementVerified = judgement.verify(assignments, stated, localContext);
+    const judgementVerified = judgement.verify(assignments, stated, context);
 
     verifiedAsJudgement = judgementVerified;  ///
 
     if (verifiedAsJudgement) {
-      localContext.debug(`...verified the '${statementString}' statement as a judgement.`);
+      context.debug(`...verified the '${statementString}' statement as a judgement.`);
     }
   }
 
   return verifiedAsJudgement;
 }
 
-function verifyAsTypeAssertion(statement, assignments, stated, localContext) {
+function verifyAsTypeAssertion(statement, assignments, stated, context) {
   let verifiedAsTypeAssertion = false;
 
   const statementNode = statement.getNode(),
         typeAssertionNode = typeAssertionNodeQuery(statementNode),
-        typeAssertion = TypeAssertion.fromTypeAssertionNode(typeAssertionNode, localContext);
+        typeAssertion = TypeAssertion.fromTypeAssertionNode(typeAssertionNode, context);
 
   if (typeAssertion !== null) {
     const statementString = statement.getString();
 
-    localContext.trace(`Verifying the '${statementString}' statement as a type assertion...`);
+    context.trace(`Verifying the '${statementString}' statement as a type assertion...`);
 
-    const typeAssertionVerified = typeAssertion.verify(assignments, stated, localContext);
+    const typeAssertionVerified = typeAssertion.verify(assignments, stated, context);
 
     verifiedAsTypeAssertion = typeAssertionVerified; ///
 
     if (verifiedAsTypeAssertion) {
-      localContext.debug(`...verified the '${statementString}' statement as a type assertion.`);
+      context.debug(`...verified the '${statementString}' statement as a type assertion.`);
     }
   }
 
   return verifiedAsTypeAssertion;
 }
 
-function verifyAsDefinedAssertion(statement, assignments, stated, localContext) {
+function verifyAsDefinedAssertion(statement, assignments, stated, context) {
   let verifiedAsDefinedAssertion = false;
 
   const statementNode = statement.getNode(),
         definedAssertionNode = definedAssertionNodeQuery(statementNode),
-        definedAssertion = DefinedAssertion.fromDefinedAssertionNode(definedAssertionNode, localContext);
+        definedAssertion = DefinedAssertion.fromDefinedAssertionNode(definedAssertionNode, context);
 
   if (definedAssertion !== null) {
     const statementString = statement.getString();
 
-    localContext.trace(`Verifying the '${statementString}' statement as a defined assertion...`);
+    context.trace(`Verifying the '${statementString}' statement as a defined assertion...`);
 
-    const definedAssertionVerified = definedAssertion.verify(assignments, stated, localContext);
+    const definedAssertionVerified = definedAssertion.verify(assignments, stated, context);
 
     verifiedAsDefinedAssertion = definedAssertionVerified; ///
 
     if (verifiedAsDefinedAssertion) {
-      localContext.debug(`...verified the '${statementString}' statement as a defined assertion.`);
+      context.debug(`...verified the '${statementString}' statement as a defined assertion.`);
     }
   }
 
   return verifiedAsDefinedAssertion;
 }
 
-function verifyAsContainedAssertion(statement, assignments, stated, localContext) {
+function verifyAsContainedAssertion(statement, assignments, stated, context) {
   let verifiedAsContainedAssertion = false;
 
   const statementNode = statement.getNode(),
         containedAssertionNode = containedAssertionNodeQuery(statementNode),
-        containedAssertion = ContainedAssertion.fromContainedAssertionNode(containedAssertionNode, localContext);
+        containedAssertion = ContainedAssertion.fromContainedAssertionNode(containedAssertionNode, context);
 
   if (containedAssertion !== null) {
     const statementString = statement.getString();
 
-    localContext.trace(`Verifying the '${statementString}' statement as a contained assertion...`);
+    context.trace(`Verifying the '${statementString}' statement as a contained assertion...`);
 
-    const containedAssertionVerified = containedAssertion.verify(assignments, stated, localContext);
+    const containedAssertionVerified = containedAssertion.verify(assignments, stated, context);
 
     verifiedAsContainedAssertion = containedAssertionVerified; ///
 
     if (verifiedAsContainedAssertion) {
-      localContext.debug(`...verified the '${statementString}' statement as a contained assertion.`);
+      context.debug(`...verified the '${statementString}' statement as a contained assertion.`);
     }
   }
 
   return verifiedAsContainedAssertion;
 }
 
-function verifyAsSubproofAssertion(statement, assignments, stated, localContext) {
+function verifyAsSubproofAssertion(statement, assignments, stated, context) {
   let verifiedAsSubproofAssertion = false;
 
   const statementNode = statement.getNode(),
         subproofAssertionNode = subproofAssertionNodeQuery(statementNode),
-        subproofAssertion = SubproofAssertion.fromSubproofAssertionNode(subproofAssertionNode, localContext);
+        subproofAssertion = SubproofAssertion.fromSubproofAssertionNode(subproofAssertionNode, context);
 
   if (subproofAssertionNode !== null) {
     const statementString = statement.getString();
 
-    localContext.trace(`Verifying the '${statementString}' statement as a subproof assertion...`);
+    context.trace(`Verifying the '${statementString}' statement as a subproof assertion...`);
 
-    const subproofAssertionVerified = subproofAssertion.verify(assignments, stated, localContext);
+    const subproofAssertionVerified = subproofAssertion.verify(assignments, stated, context);
 
     verifiedAsSubproofAssertion = subproofAssertionVerified; ///
 
     if (verifiedAsSubproofAssertion) {
-      localContext.debug(`...verified the '${statementString}' statement as a subproof assertion.`);
+      context.debug(`...verified the '${statementString}' statement as a subproof assertion.`);
     }
   }
 

package/src/mixins/term/verify.js

@@ -15,7 +15,7 @@ function verifyTermAsVariable(term, localContext, verifyAhead) {
         variable = Variable.fromVariableNode(variableNode, localContext);
 
   if (variable !== null) {
-    const termString = localContext.nodeAsString(termNode);
+    const termString = term.getString();
 
     localContext.trace(`Verifying the '${termString}' term as a variable...`);
 

package/src/premise.js

@@ -7,6 +7,7 @@ import SubproofAssertion from "./assertion/subproof";
 import { nodeQuery } from "./utilities/query";
 import { assignAssignments } from "./utilities/assignments";
 import { unqualifiedStatementFromJSON, unqualifiedStatementToUnqualifiedStatementJSON } from "./utilities/json";
+import local from "./context/local";
 
 const unqualifiedStatementNodeQuery = nodeQuery("/premise/unqualifiedStatement");
 
@@ -28,33 +29,36 @@ class Premise {
 
   getStatement() { return this.unqualifiedStatement.getStatement(); }
 
-  resolveIndependently(substitutions, localContext) {
+  resolveIndependently(substitutions, context) {
     let resolvedIndependently;
 
-    const premiseString = this.getString();
+    const localContext = LocalContext.fromFileContext(this.fileContext),
+          generalContext = localContext,  ///
+          specificContext = context; ///
 
-    const localContextB = localContext; ///
-
-    localContext = LocalContext.fromFileContext(this.fileContext);
-
-    const localContextA = localContext; ///
+    const premise = this, ///
+          premiseString = premise.getString();
 
-    localContextB.trace(`Resolving the '${premiseString}' premise independently...`);
+    specificContext.trace(`Resolving the '${premiseString}' premise independently...`);
 
-    const unqualifiedStatementResolvedIndependently = this.unqualifiedStatement.resolveIndependently(substitutions, localContextA, localContextB);
+    const unqualifiedStatementResolvedIndependently = this.unqualifiedStatement.resolveIndependently(substitutions, generalContext, specificContext);
 
     resolvedIndependently = unqualifiedStatementResolvedIndependently;  ///
 
     if (resolvedIndependently) {
-      localContextB.trace(`...resolved the '${premiseString}' premise independently.`);
+      specificContext.trace(`...resolved the '${premiseString}' premise independently.`);
     }
 
     return resolvedIndependently;
   }
 
-  unifyProofStep(proofStep, substitutions, localContext) {
+  unifyProofStep(proofStep, substitutions, context) {
     let proofStepUnified = false;
 
+    const localContext = LocalContext.fromFileContext(this.fileContext),
+          generalContext = localContext,  ///
+          specificContext = context; ///
+
     const subproof = proofStep.getSubproof(),
           statement = proofStep.getStatement();
 
@@ -66,54 +70,47 @@ class Premise {
     if (false) {
       ///
     } else if (subproof !== null) {
-      subproofUnified = this.unifySubproof(subproof, substitutions, localContext);
+      subproofUnified = this.unifySubproof(subproof, substitutions, generalContext, specificContext);
     } else if (statement !== null) {
-      statementUnified = this.unifyStatement(statement, substitutions, localContext);
+      statementUnified = this.unifyStatement(statement, substitutions, generalContext, specificContext);
     }
 
     if (subproofUnified || statementUnified) {
-      const localContextB = localContext; ///
+      const localContext = LocalContext.fromFileContext(this.fileContext),
+            generalContext = localContext,  ///
+            specificContext = context; ///
 
-      localContext = LocalContext.fromFileContext(this.fileContext);
-
-      const localContextA = localContext; ///
-
-      substitutions.resolve(localContextA, localContextB);
+      substitutions.resolve(generalContext, specificContext);
 
       proofStepUnified = true;
     }
 
     proofStepUnified ?
       substitutions.continue() :
-        substitutions.rollback(localContext);
+        substitutions.rollback(context);
 
     return proofStepUnified;
   }
 
-  unifyStatement(statement, substitutions, localContext) {
+  unifyStatement(statement, substitutions, generalContext, specificContext) {
     let statementUnified;
 
-    const statementString = statement.getString(),
-          premiseString = this.getString();
-
-    const localContextB = localContext; ///
-
-    localContext = LocalContext.fromFileContext(this.fileContext);
-
-    const localContextA = localContext; ///
+    const premise = this, ///
+          premiseString = premise.getString(),
+          statementString = statement.getString();
 
-    localContextB.trace(`Unifying the '${statementString}' statement with the '${premiseString}' premise...`);
+    specificContext.trace(`Unifying the '${statementString}' statement with the '${premiseString}' premise...`);
 
-    statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, localContextA, localContextB);
+    statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, generalContext, specificContext);
 
     if (statementUnified) {
-      localContextB.debug(`...unified the '${statementString}' statement with the '${premiseString}' premise.`);
+      specificContext.debug(`...unified the '${statementString}' statement with the '${premiseString}' premise.`);
     }
 
     return statementUnified;
   }
 
-  unifySubproof(subproof, substitutions, localContext) {
+  unifySubproof(subproof, substitutions, generalContext, specificContext) {
     let subproofUnified = false;
 
     const premise = this, ///
@@ -121,59 +118,51 @@ class Premise {
           premiseStatement = premise.getStatement(),
           premiseStatementString = premiseStatement.getString();
 
-    const localContextB = localContext; ///
-
     const statement = this.unqualifiedStatement.getStatement(),
-          statementTokens = statement.getTokens(),
-          context = this.fileContext, ///
-          tokens = statementTokens; ///
-
-    localContext = LocalContext.fromContextAndTokens(context, tokens);  ///
-
-    const localContextA = localContext; ///
+          statementNode = statement.getNode();
 
-    localContextB.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement...`);
+    specificContext.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement...`);
 
-    const statementNode = statement.getNode(),
-          subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, localContext);
+    const context = specificContext,  ///
+          subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, context);
 
     if (subproofAssertion !== null) {
-      subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, localContextA, localContextB);
+      subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);
     }
 
     if (subproofUnified) {
-      localContextB.debug(`...unified the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement.`);
+      specificContext.debug(`...unified the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement.`);
     }
 
     return subproofUnified;
   }
 
-  verify(localContext) {
+  verify(context) {
     let verified = false;
 
     const premiseString = this.getString(); ///
 
-    localContext.trace(`Verifying the '${premiseString}' premise...`);
+    context.trace(`Verifying the '${premiseString}' premise...`);
 
     const stated = true,
           assignments = [],
-          unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, localContext);
+          unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, context);
 
     if (unqualifiedStatementVerified) {
-      const assignmentsAssigned = assignAssignments(assignments, localContext);
+      const assignmentsAssigned = assignAssignments(assignments, context);
 
       if (assignmentsAssigned) {
         const { ProofStep } = shim,
               proofStep = ProofStep.fromUnqualifiedStatement(this.unqualifiedStatement);
 
-        localContext.addProofStep(proofStep);
+        context.addProofStep(proofStep);
 
         verified = true;
       }
     }
 
     if (verified) {
-      localContext.debug(`...verified the '${premiseString}' premise.`);
+      context.debug(`...verified the '${premiseString}' premise.`);
     }
 
     return verified;

package/src/proof.js

@@ -26,15 +26,17 @@ class Proof {
     return statement;
   }
 
-  verify(substitutions, conclusion, localContext) {
+  verify(substitutions, conclusion, context) {
     let verified = false;
 
-    localContext = LocalContext.fromLocalContext(localContext); ///
+    const localContext = LocalContext.fromContext(context); ///
 
-    const derivationVerified = this.derivation.verify(substitutions, localContext);
+    context = localContext; ///
+
+    const derivationVerified = this.derivation.verify(substitutions, context);
 
     if (derivationVerified) {
-      const lastProofStep = localContext.getLastProofStep();
+      const lastProofStep = context.getLastProofStep();
 
       if (lastProofStep !== null) {
         const statement = this.getStatement(),

package/src/proofStep.js

@@ -47,25 +47,25 @@ class ProofStep {
     return statement;
   }
 
-  unifyStatement(statement, localContext) {
+  unifyStatement(statement, context) {
     let statementUnified = false;
 
     if ((this.qualifiedStatement !== null) || (this.unqualifiedStatement !== null !== null)) {
       const statementString = statement.getString();
 
-      localContext.trace(`Unifying the '${statementString}' statement...`);
+      context.trace(`Unifying the '${statementString}' statement...`);
 
       const { Substitutions } = shim,
-            localContextA = localContext, ///
-            localContextB = localContext, ///
+            specificContext = context, ///
+            generalContext = context, ///
             substitutions = Substitutions.fromNothing();
 
       if (this.qualifiedStatement !== null) {
-        statementUnified = this.qualifiedStatement.unifyStatement(statement, substitutions, localContextA, localContextB);
+        statementUnified = this.qualifiedStatement.unifyStatement(statement, substitutions, generalContext, specificContext);
       }
 
       if (this.unqualifiedStatement !== null) {
-        statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, localContextA, localContextB);
+        statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, generalContext, specificContext);
       }
 
       const substitutionsLength = substitutions.getLength();
@@ -75,21 +75,21 @@ class ProofStep {
       }
 
       if (statementUnified) {
-        localContext.debug(`...unified the '${statementString}' statement.`);
+        context.debug(`...unified the '${statementString}' statement.`);
       }
     }
 
     return statementUnified;
   }
 
-  unifySubproofAssertion(subproofAssertion, localContext) {
+  unifySubproofAssertion(subproofAssertion, context) {
     let subproofAssertionUnified = false;
 
     if (this.subproof !== null) {
       const subproofString = this.subproof.getString(),
             subproofAssertionString = subproofAssertion.getString();
 
-      localContext.trace(`Unifying the '${subproofAssertionString}' subproof assertion with the '${subproofString}' subproof...`);
+      context.trace(`Unifying the '${subproofAssertionString}' subproof assertion with the '${subproofString}' subproof...`);
 
       const { Substitutions } = shim,
             substitutions = Substitutions.fromNothing(),
@@ -99,11 +99,11 @@ class ProofStep {
       subproofAssertionUnified = match(subproofAssertionStatements, subproofStatements, (subproofAssertionStatement, subproofStatement) => {
         const subproofAssertionStatementNode = subproofAssertionStatement.getNode(),
               subproofStatementNode = subproofStatement.getNode(),
-              nodeA = subproofAssertionStatementNode,  ///
-              nodeB = subproofStatementNode,  ///
-              localContextA = localContext, ///
-              localContextB = localContext, ///
-              unifiedAtMetaLevel = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+              generalNode = subproofAssertionStatementNode,  ///
+              specificNode = subproofStatementNode,  ///
+              generalContext = context, ///
+              specificContext = context, ///
+              unifiedAtMetaLevel = metaLevelUnifier.unify(generalNode, specificNode, substitutions, generalContext, specificContext);
 
         if (unifiedAtMetaLevel) {
           return true;
@@ -119,14 +119,14 @@ class ProofStep {
       }
 
       if (subproofAssertionUnified) {
-        localContext.trace(`...unified the '${subproofAssertionString}' subproof assertion with the '${subproofString}' subproof.`);
+        context.trace(`...unified the '${subproofAssertionString}' subproof assertion with the '${subproofString}' subproof.`);
       }
     }
 
     return subproofAssertionUnified;
   }
 
-  verify(substitutions, localContext) {
+  verify(substitutions, context) {
     let verified = false;
 
     let stated = false;
@@ -138,23 +138,23 @@ class ProofStep {
         unqualifiedStatementVerified = false;
 
     if (this.subproof !== null) {
-      subproofVerified = this.subproof.verify(substitutions, localContext);
+      subproofVerified = this.subproof.verify(substitutions, context);
     }
 
     if (this.qualifiedStatement !== null) {
       stated = true;
 
-      qualifiedStatementVerified = this.qualifiedStatement.verify(substitutions, assignments, stated, localContext);
+      qualifiedStatementVerified = this.qualifiedStatement.verify(substitutions, assignments, stated, context);
     }
 
     if (this.unqualifiedStatement !== null) {
       stated = false;
 
-      unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, localContext);
+      unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, context);
     }
 
     if (subproofVerified || qualifiedStatementVerified || unqualifiedStatementVerified) {
-      const assignmentsAssigned = assignAssignments(assignments, localContext);
+      const assignmentsAssigned = assignAssignments(assignments, context);
 
       if (assignmentsAssigned) {
         verified = true;
@@ -164,7 +164,7 @@ class ProofStep {
     if (verified) {
       const proofStep = this; ///
 
-      localContext.addProofStep(proofStep);
+      context.addProofStep(proofStep);
     }
 
     return verified;