occam-verify-cli 0.0.905 → 0.0.907

package/src/context/localMeta.js

@@ -1,21 +1,18 @@
 "use strict";
 
-import contextMixins from "../mixins/context";
+import LocalContext from "../context/local";
 
 import { last } from "../utilities/array";
 
-class LocalMetaContext {
-  constructor(context, metavariables, metaproofSteps, frameAssertions) {
-    this.context = context;
+class LocalMetaContext extends LocalContext {
+  constructor(context, variables, proofSteps, equivalences, metavariables, metaproofSteps, frameAssertions) {
+    super(context, variables, proofSteps, equivalences);
+
     this.metavariables = metavariables;
     this.metaproofSteps = metaproofSteps;
     this.frameAssertions = frameAssertions;
   }
 
-  getContext() {
-    return this.context;
-  }
-
   getMetavariables() {
     let metavariables = this.context.getMetavariables();
 
@@ -49,18 +46,6 @@ class LocalMetaContext {
     return frameAssertions;
   }
 
-  getVariables() { return this.context.getVariables(); }
-
-  getProofSteps() { return this.context.getProofSteps(); }
-
-  getEquivalences() { return this.context.getEquivalences(); }
-
-  getTermType(term) {
-    const termType = term.getType();
-
-    return termType;
-  }
-
   getLastMetaproofStep() {
     let lastMetaproofStep = null;
 
@@ -135,18 +120,18 @@ class LocalMetaContext {
     return metastatementMatches;
   }
 
-  findVariableByVariableNode(variableNode) {
-    const node = variableNode,  ///
-          variables = this.getVariables(),
-          variable = variables.find((variable) => {
-            const matches = variable.matchNode(node);
+  findMetavariableByMetavariableNode(metavariableNode, localMetaContext) {
+    const node = metavariableNode,  ///
+          metavariables = this.getMetavariables(),
+          metavariable = metavariables.find((metavariable) => {
+            const matches = metavariable.matchNode(node, localMetaContext);
 
             if (matches) {
               return true;
             }
           }) || null;
 
-    return variable;
+    return metavariable;
   }
 
   findFrameAssertionByMetavariableNode(metavariableNode) {
@@ -162,11 +147,11 @@ class LocalMetaContext {
     return frameAssertion;
   }
 
-  isVariablePresentByVariableNode(variableNode) {
-    const variable = this.findVariableByVariableNode(variableNode),
-          variablePresent = (variable !== null);
+  isMetavariablePresentByMetavariableNode(metavariableNode, localMetaContext) {
+    const metavariable = this.findMetavariableByMetavariableNode(metavariableNode, localMetaContext),
+          metavariablePresent = (metavariable !== null);
 
-    return variablePresent;
+    return metavariablePresent;
   }
 
   isFrameAssertionPresentByMetavariableNode(metavariableNode) {
@@ -176,49 +161,32 @@ class LocalMetaContext {
     return frameAssertionPresent;
   }
 
-  findMetavariableByMetavariableNode(metavariableNode, localMetaContext) {
-    const node = metavariableNode,  ///
-          metavariables = this.getMetavariables(),
-          metavariable = metavariables.find((metavariable) => {
-            const matches = metavariable.matchNode(node, localMetaContext);
-
-            if (matches) {
-              return true;
-            }
-          }) || null;
-
-    return metavariable;
-  }
-
-  isMetavariablePresentByMetavariableNode(metavariableNode, localMetaContext) {
-    const metavariable = this.findMetavariableByMetavariableNode(metavariableNode, localMetaContext),
-          metavariablePresent = (metavariable !== null);
-
-    return metavariablePresent;
-  }
-
   static fromFileContext(fileContext) {
     const context = fileContext,  ///
+          variables = [],
+          proofSteps = [],
+          equivalences = [],
           metavariables = [],
           metaproofSteps = [],
           frameAssertions = [],
-          localMetaContext = new LocalMetaContext(context, metavariables, metaproofSteps, frameAssertions);
+          localMetaContext = new LocalMetaContext(context, variables, proofSteps, equivalences, metavariables, metaproofSteps, frameAssertions);
 
     return localMetaContext;
   }
 
   static fromLocalMetaContext(localMetaContext) {
     const context = localMetaContext,  ///
+          variables = [],
+          proofSteps = [],
+          equivalences = [],
           metavariables = [],
           metaproofSteps = [],
           frameAssertions = [];
 
-    localMetaContext = new LocalMetaContext(context, metavariables, metaproofSteps, frameAssertions);  ///
+    localMetaContext = new LocalMetaContext(context, variables, proofSteps, equivalences, metavariables, metaproofSteps, frameAssertions);  ///
 
     return localMetaContext;
   }
 }
 
-Object.assign(LocalMetaContext.prototype, contextMixins);
-
 export default LocalMetaContext;

package/src/metaConsequent.js

@@ -54,15 +54,15 @@ export default class MetaConsequent {
     return json;
   }
 
-  static fromMetastatementNode(metastatementNode) {
-    const statementNode = null,
+  static fromStatementNode(statementNode) {
+    const metastatementNode = null,
           metaConsequent = new MetaConsequent(metastatementNode, statementNode);
 
     return metaConsequent;
   }
 
-  static fromStatementNode(statementNode) {
-    const metastatementNode = null,
+  static fromMetastatementNode(metastatementNode) {
+    const statementNode = null,
           metaConsequent = new MetaConsequent(metastatementNode, statementNode);
 
     return metaConsequent;

package/src/metaSupposition.js

@@ -98,15 +98,15 @@ export default class MetaSupposition {
     return json;
   }
 
-  static fromMetastatementNode(metastatementNode) {
-    const statementNode = null,
+  static fromStatementNode(statementNode) {
+    const metastatementNode = null,
           metaSupposition = new MetaSupposition(metastatementNode, statementNode);
 
     return metaSupposition;
   }
 
-  static fromStatementNode(statementNode) {
-    const metastatementNode = null,
+  static fromMetastatementNode(metastatementNode) {
+    const statementNode = null,
           metaSupposition = new MetaSupposition(metastatementNode, statementNode);
 
     return metaSupposition;

package/src/metavariable.js

@@ -1,7 +1,6 @@
 "use strict";
 
 import verifyTerm from "./verify/term";
-import LocalContext from "./context/local";
 
 import { first } from "./utilities/array";
 import { nodeQuery } from "./utilities/query";
@@ -128,7 +127,7 @@ function verifyTermAgainstTermType(termNode, termType, localMetaContext) {
 
   const type = termType,  ///
         terms = [],
-        localContext = LocalContext.fromLocalMetaContext(localMetaContext);
+        localContext = localMetaContext;  ///
 
   termVerifiedAgainstTermType = verifyTerm(termNode, terms, localContext, () => {
     let verifiedAhead = false;

package/src/premise.js

@@ -199,14 +199,8 @@ export default class Premise {
     return json;
   }
 
-  static fromJSONAndFileContext(json, fileContext) {
-    const { metastatement, statement } = json,
-          metastatementString = metastatement,  ///
-          statementString = statement, ///
-          lexer = fileContext.getLexer(),
-          parser = fileContext.getParser(),
-          metastatementNode = metastatementNodeFromMetastatementString(metastatementString, lexer, parser),
-          statementNode = statementNodeFromStatementString(statementString, lexer, parser),
+  static fromStatementNode(statementNode) {
+    const metastatementNode = null,
           premise = new Premise(metastatementNode, statementNode);
 
     return premise;
@@ -219,8 +213,14 @@ export default class Premise {
     return premise;
   }
 
-  static fromStatementNode(statementNode) {
-    const metastatementNode = null,
+  static fromJSONAndFileContext(json, fileContext) {
+    const { metastatement, statement } = json,
+          metastatementString = metastatement,  ///
+          statementString = statement, ///
+          lexer = fileContext.getLexer(),
+          parser = fileContext.getParser(),
+          metastatementNode = metastatementNodeFromMetastatementString(metastatementString, lexer, parser),
+          statementNode = statementNodeFromStatementString(statementString, lexer, parser),
           premise = new Premise(metastatementNode, statementNode);
 
     return premise;

package/src/utilities/assignments.js

@@ -2,7 +2,7 @@
 
 import { first } from "../utilities/array";
 
-export function assignAssignment(assignments, localContextOrLocalMetaContext) {
+export function assignAssignment(assignments, localContext) {
   let assignmentAssigned = true;
 
   const assignmentsLength = assignments.length;
@@ -11,7 +11,7 @@ export function assignAssignment(assignments, localContextOrLocalMetaContext) {
     const firstAssignment = first(assignments),
           assignment = firstAssignment;
 
-    assignmentAssigned = assignment.assign(localContextOrLocalMetaContext);
+    assignmentAssigned = assignment.assign(localContext);
   }
 
   return assignmentAssigned;

package/src/verifier/node/metastatement.js

@@ -1,6 +1,5 @@
 "use strict";
 
-import LocalContext from "../../context/local";
 import NodeVerifier from "../../verifier/node";
 
 import { nodeQuery } from "../../utilities/query";
@@ -89,7 +88,7 @@ class MetastatementNodeVerifier extends NodeVerifier {
   }
 
   verifyVariableNode(variableNode, localMetaContext, verifyAhead) {
-    const localContext = LocalContext.fromLocalMetaContext(localMetaContext),
+    const localContext = localMetaContext,  ///
           standaloneVariableVerified = verifyStandaloneVariable(variableNode, localContext, verifyAhead),
           variableNodeVerified = standaloneVariableVerified;  ///
 
@@ -97,7 +96,7 @@ class MetastatementNodeVerifier extends NodeVerifier {
   }
 
   verifyTermNode(termNode, localMetaContext, verifyAhead) {
-    const localContext = LocalContext.fromLocalMetaContext(localMetaContext),
+    const localContext = localMetaContext,  ///
           standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
           termNodeVerified = standaloneTermVerified;  ///
 

package/src/verifier/nodes/intrinsicLevel.js

@@ -60,9 +60,8 @@ class IntrinsicLevelNodesVerifier extends NodesVerifier {
   verifyTermVariableNodeAgainstTermNode(termVariableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
     let termVariableNodeVerifiedAgainstTermNode;
 
-    const termNode = termNodeB, ///
-          variableNode = termVariableNodeA, ///
-          termVerifiedAgainstVariable = verifyVariableAgainstTerm(variableNode, termNode, substitutions, localContextA, localContextB, verifyAhead);
+    const variableNodeA = termVariableNodeA, ///
+          termVerifiedAgainstVariable = verifyVariableAgainstTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
     termVariableNodeVerifiedAgainstTermNode = termVerifiedAgainstVariable;  ///
 

package/src/verifier/nodes/intrinsicLevelAgainstMetaLevel.js

@@ -2,7 +2,6 @@
 
 import NodesVerifier from "../../verifier/nodes";
 import verifyVariableAgainstTerm from "../../verify/variableAgainstTerm";
-import intrinsicLevelNodesVerifier from "../../verifier/nodes/intrinsicLevel";
 import verifyMetavariableAgainstStatement from "../../verify/metavariableAgainstStatement";
 
 import { nodeQuery } from "../../utilities/query";
@@ -120,10 +119,10 @@ class IntrinsicLevelAgainstMetaLevelNodesVerifier extends NodesVerifier {
   verifyMetastatementMetavariableNodeAgainstMetaArgumentStatementNode(metastatementMetavariableNodeA, metaArgumentStatementNodeB, metastatementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead) {
     let metastatementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode;
 
-    const statementNode = metaArgumentStatementNodeB, ///
-          metavariableNode = metastatementMetavariableNodeA,  ///
+    const statementNodeB = metaArgumentStatementNodeB, ///
           substitutionNode = metastatementSubstitutionNodeA,  ///
-          metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNode, statementNode, substitutionNode, substitutions, localContextA, localContextB, verifyAhead)
+          metavariableNodeA = metastatementMetavariableNodeA,  ///
+          metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNode, substitutions, localContextA, localContextB, verifyAhead)
 
     metastatementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode = metavariableVerifiedAgainstStatement; ///
 
@@ -133,10 +132,9 @@ class IntrinsicLevelAgainstMetaLevelNodesVerifier extends NodesVerifier {
   verifyMetastatementMetavariableNodeAgainstStatementNode(metastatementMetavariableNodeA, statementNodeB, metastatementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead) {
     let metastatementMetavariableNodeVerifiedAgainstStatementNode;
 
-    const statementNode = statementNodeB, ///
-          metavariableNode = metastatementMetavariableNodeA,  ///
-          substitutionNode = metastatementSubstitutionNodeA,  ///
-          metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNode, statementNode, substitutionNode, substitutions, localContextA, localContextB, verifyAhead)
+    const substitutionNode = metastatementSubstitutionNodeA,  ///
+          metavariableNodeA = metastatementMetavariableNodeA,  ///
+          metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNode, substitutions, localContextA, localContextB, verifyAhead)
 
     metastatementMetavariableNodeVerifiedAgainstStatementNode = metavariableVerifiedAgainstStatement; ///
 
@@ -162,9 +160,8 @@ class IntrinsicLevelAgainstMetaLevelNodesVerifier extends NodesVerifier {
   verifyTermVariableNodeAgainstTermNode(termVariableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
     let termVariableNodeVerifiedAgainstTermNode;
 
-    const termNode = termNodeB, ///
-          variableNode = termVariableNodeA, ///
-          termVerifiedAgainstVariable = verifyVariableAgainstTerm(variableNode, termNode, substitutions, localContextA, localContextB, verifyAhead);
+    const variableNodeA = termVariableNodeA, ///
+          termVerifiedAgainstVariable = verifyVariableAgainstTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
     termVariableNodeVerifiedAgainstTermNode = termVerifiedAgainstVariable;  ///
 

package/src/verify/metaProofStep.js

@@ -53,7 +53,8 @@ export default function verifyMetaProofStep(metaProofStepNode, substitutions, lo
     qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, substitutions, assignments, localMetaContext);
 
     if (qualifiedMetastatementVerified) {
-      const assignmentAssigned = assignAssignment(assignments, localMetaContext);
+      const localContext = localMetaContext,  ///
+            assignmentAssigned = assignAssignment(assignments, localContext);
 
       qualifiedMetastatementVerified = assignmentAssigned; ///
     }
@@ -75,7 +76,8 @@ export default function verifyMetaProofStep(metaProofStepNode, substitutions, lo
     unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
 
     if (unqualifiedMetastatementVerified) {
-      const assignmentAssigned = assignAssignment(assignments, localMetaContext);
+      const localContext = localMetaContext,  ///
+            assignmentAssigned = assignAssignment(assignments, localContext);
 
       unqualifiedMetastatementVerified = assignmentAssigned; ///
     }

package/src/verify/metaSupposition.js

@@ -23,7 +23,8 @@ export default function verifyMetaSupposition(metaSuppositionNode, metaSuppositi
         unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
 
   if (unqualifiedMetastatementVerified) {
-    const assignmentAssigned = assignAssignment(assignments, localMetaContext);
+    const localContext = localMetaContext,  ///
+          assignmentAssigned = assignAssignment(assignments, localContext);
 
     metaSuppositionVerified = assignmentAssigned; ///
   }

package/src/verify/metavariableAgainstStatement.js

@@ -4,11 +4,11 @@ import TermForVariableSubstitution from "../substitution/termForVariable";
 import verifyStatementAgainstStatement from "../verify/statementAtainstStatement";
 import StatementForMetavariableSubstitution from "../substitution/statementForMetavariable";
 
-export default function verifyMetavariableAgainstStatement(metavariableNode, statementNode, substitutionNode, substitutions, localContextA, localContextB, verifyAhead) {
+export default function verifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNode, substitutions, localContextA, localContextB, verifyAhead) {
   let metavariableVerifiedAgainstStatement = false;
 
   const substitution = substitutions.find((substitution) => {
-    const substitutionMatchesMetavariableNodeA = substitution.matchMetavariableNode(metavariableNode);
+    const substitutionMatchesMetavariableNodeA = substitution.matchMetavariableNode(metavariableNodeA);
 
     if (substitutionMatchesMetavariableNodeA) {
       return true;
@@ -20,10 +20,10 @@ export default function verifyMetavariableAgainstStatement(metavariableNode, sta
 
     if (substitutionNode !== null) {
       const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionNode(substitutionNode),
+            localContext = localContextB,  ///
             substitution = termForVariableSubstitution, ///
             statementNodeA = substitutionStatementNode, ///
-            statementNodeB = statementNode, ///
-            statementVerifiedAgainstStatement = verifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
+            statementVerifiedAgainstStatement = verifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContext, localContext);
 
       if (statementVerifiedAgainstStatement) {
         const verifiedAhead = verifyAhead();
@@ -34,12 +34,13 @@ export default function verifyMetavariableAgainstStatement(metavariableNode, sta
       const substitutionSubstitution = substitution.getSubstitution();
 
       if (substitutionSubstitution !== null) {
-        localContextA = localContextB;  ///
+        const statementNodeA = statementNodeB; ///
 
-        const substitution = substitutionSubstitution,
-              statementNodeA = statementNode, ///
-              statementNodeB = substitutionStatementNode, ///
-              statementVerifiedAgainstStatement = verifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
+        statementNodeB = substitutionStatementNode; ///
+
+        const localContext = localContextB,  ///
+              substitution = substitutionSubstitution,
+              statementVerifiedAgainstStatement = verifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContext, localContext);
 
         if (statementVerifiedAgainstStatement) {
           const verifiedAhead = verifyAhead();
@@ -47,9 +48,9 @@ export default function verifyMetavariableAgainstStatement(metavariableNode, sta
           metavariableVerifiedAgainstStatement = verifiedAhead;  ///
         }
       } else {
-        const statementNodeMatches = substitution.matchStatementNode(statementNode);
+        const substitutionMatchesStatementNodeB = substitution.matchStatementNode(statementNodeB);
 
-        if (statementNodeMatches) {
+        if (substitutionMatchesStatementNodeB) {
           const verifiedAhead = verifyAhead();
 
           metavariableVerifiedAgainstStatement = verifiedAhead;  ///
@@ -59,7 +60,9 @@ export default function verifyMetavariableAgainstStatement(metavariableNode, sta
   } else {
     let verifiedAhead;
 
-    const statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNodeStatementNodeAndSubstitutionNode(metavariableNode, statementNode, substitutionNode),
+    const statementNode = statementNodeB, ///
+          metavariableNode = metavariableNodeA, ///
+          statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNodeStatementNodeAndSubstitutionNode(metavariableNode, statementNode, substitutionNode),
           substitution = statementForMetavariableSubstitution;  ///
 
     substitutions.push(substitution);

package/src/verify/premise.js

@@ -2,12 +2,15 @@
 
 import Premise from "../premise";
 import MetaproofStep from "../step/metaproof";
+import verifyUnqualifiedStatement from "../verify/statement/unqualified";
 import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
 import { assignAssignment } from "../utilities/assignments";
 
-const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
+const statementNodeQuery = nodeQuery("/unqualifiedMetastatement/statement!"),
+      metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
+      unqualifiedStatementNodeQuery = nodeQuery("/premise/unqualifiedStatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/premise/unqualifiedMetastatement!");
 
 export default function verifyPremise(premiseNode, premises, localMetaContext) {
@@ -17,7 +20,21 @@ export default function verifyPremise(premiseNode, premises, localMetaContext) {
 
   localMetaContext.trace(`Verifying the '${premiseString}' premise...`, premiseNode);
 
-  const unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(premiseNode);
+  const unqualifiedStatementNode = unqualifiedStatementNodeQuery(premiseNode),
+        unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(premiseNode);
+
+  if (unqualifiedStatementNode !== null) {
+    const derived = false,
+          assignments = [],
+          localContext = localMetaContext,  ///
+          unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
+
+    if (unqualifiedStatementVerified) {
+      const assignmentAssigned = assignAssignment(assignments, localContext);
+
+      premiseVerified = assignmentAssigned; ///
+    }
+  }
 
   if (unqualifiedMetastatementNode !== null) {
     const derived = false,
@@ -25,16 +42,32 @@ export default function verifyPremise(premiseNode, premises, localMetaContext) {
           unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
 
     if (unqualifiedMetastatementVerified) {
-      const assignmentAssigned = assignAssignment(assignments, localMetaContext);
+      const localContext = localMetaContext,  ///
+            assignmentAssigned = assignAssignment(assignments, localContext);
 
       premiseVerified = assignmentAssigned; ///
     }
   }
 
   if (premiseVerified) {
-    const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
-          metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode),
-          premise = Premise.fromMetastatementNode(metastatementNode);
+    let premise,
+        metaproofStep;
+
+    if (unqualifiedStatementNode !== null) {
+      const statementNode = statementNodeQuery(unqualifiedStatementNode);
+
+      metaproofStep = MetaproofStep.fromMetastatementNode(statementNode);
+
+      premise = Premise.fromStatementNode(statementNode);
+    }
+
+    if (unqualifiedMetastatementNode !== null) {
+      const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
+
+      metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
+
+      premise = Premise.fromMetastatementNode(metastatementNode);
+    }
 
     premises.push(premise);
 

package/src/verify/ruleProofStep.js

@@ -1,11 +1,9 @@
 "use strict";
 
-import LocalContext from "../context/local";
 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";
 
@@ -47,7 +45,7 @@ export default function verifyRuleProofStep(ruleProofStepNode, localMetaContext)
     let qualifiedStatementVerified;
 
     const assignments = [],
-          localContext = LocalContext.fromLocalMetaContext(localMetaContext);
+          localContext = localMetaContext;  ///
 
     qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, assignments, localContext);
 
@@ -76,7 +74,8 @@ export default function verifyRuleProofStep(ruleProofStepNode, localMetaContext)
     qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, substitutions, assignments, localMetaContext);
 
     if (qualifiedMetastatementVerified) {
-      const assignmentAssigned = assignAssignment(assignments, localMetaContext);
+      const localContext = localMetaContext,  ///
+            assignmentAssigned = assignAssignment(assignments, localContext);
 
       qualifiedMetastatementVerified = assignmentAssigned; ///
     }
@@ -98,7 +97,8 @@ export default function verifyRuleProofStep(ruleProofStepNode, localMetaContext)
     unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
 
     if (unqualifiedMetastatementVerified) {
-      const assignmentAssigned = assignAssignment(assignments, localMetaContext);
+      const localContext = localMetaContext,  ///
+            assignmentAssigned = assignAssignment(assignments, localContext);
 
       unqualifiedMetastatementVerified = assignmentAssigned; ///
     }

package/src/verify/variableAgainstTerm.js

@@ -8,11 +8,11 @@ import { nodeQuery } from "../utilities/query";
 
 const variableNodeQuery = nodeQuery("/term/variable");
 
-export default function verifyVariableAgainstTerm(variableNode, termNode, substitutions, localContextA, localContextB, verifyAhead) {
+export default function verifyVariableAgainstTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
   let variableVerifiedAgainstTerm = false;
 
   const substitution = substitutions.find((substitution) => {
-    const substitutionMatchesVariableNodeA = substitution.matchVariableNode(variableNode);
+    const substitutionMatchesVariableNodeA = substitution.matchVariableNode(variableNodeA);
 
     if (substitutionMatchesVariableNodeA) {
       return true;
@@ -20,19 +20,19 @@ export default function verifyVariableAgainstTerm(variableNode, termNode, substi
   }) || null;
 
   if (substitution !== null) {
-    const termNodeMatches = substitution.matchTermNode(termNode);
+    const substitutionMatchesTermNodeB = substitution.matchTermNode(termNodeB);
 
-    if (termNodeMatches) {
+    if (substitutionMatchesTermNodeB) {
       const verifiedAhead = verifyAhead();
 
       variableVerifiedAgainstTerm = verifiedAhead;  ///
     }
   } else {
-    const variableA = localContextA.findVariableByVariableNode(variableNode);
+    const variableA = localContextA.findVariableByVariableNode(variableNodeA);
 
     if (variableA !== null) {
       const terms = [],
-            termVerified = verifyTerm(termNode, terms, localContextB, () => {
+            termVerified = verifyTerm(termNodeB, terms, localContextB, () => {
               let verifiedAhead = false;
 
               const firstTerm = first(terms),
@@ -49,7 +49,9 @@ export default function verifyVariableAgainstTerm(variableNode, termNode, substi
                       variableTypeEqualToOrSuperTypeOfTermType = variableType.isEqualToOrSuperTypeOf(termType);
 
                 if (variableTypeEqualToOrSuperTypeOfTermType) {
-                  const termForVariableSubstitution = TermForVariableSubstitution.fromVariableNodeAndTermNode(variableNode, termNode),
+                  const termNode = termNodeB, ///
+                        variableNode = variableNodeA, ///
+                        termForVariableSubstitution = TermForVariableSubstitution.fromVariableNodeAndTermNode(variableNode, termNode),
                         substitution = termForVariableSubstitution;  ///
 
                   substitutions.push(substitution);