occam-verify-cli 0.0.914 → 0.0.916

package/src/context/{localMeta.js → local/metaLevel.js}

@@ -1,16 +1,27 @@
 "use strict";
 
-import LocalContext from "../context/local";
+import IntrinsicLevelLocalContext from "../../context/local/intrinsicLevel";
 
-import { last, reverse } from "../utilities/array";
+import { last, reverse } from "../../utilities/array";
 
-class LocalMetaContext extends LocalContext {
-  constructor(context, variables, proofSteps, equivalences, metavariables, metaproofSteps, frameAssertions) {
+class MetaLevelLocalContext extends IntrinsicLevelLocalContext {
+  constructor(context, variables, proofSteps, equivalences, judgements, metavariables, metaproofSteps) {
     super(context, variables, proofSteps, equivalences);
 
+    this.judgements = judgements;
     this.metavariables = metavariables;
     this.metaproofSteps = metaproofSteps;
-    this.frameAssertions = frameAssertions;
+  }
+
+  getJudgements() {
+    let judgements = this.context.getJudgements();
+
+    judgements = [ ///
+      ...this.judgements,
+      ...judgements
+    ]
+
+    return judgements;
   }
 
   getMetavariables() {
@@ -35,15 +46,10 @@ class LocalMetaContext extends LocalContext {
     return metaproofSteps;
   }
 
-  getFrameAssertions() {
-    let frameAssertions = this.context.getFrameAssertions();
-
-    frameAssertions = [ ///
-      ...this.frameAssertions,
-      ...frameAssertions
-    ]
+  isIntrinsicLevel() {
+    const intrinsicLevel = false;
 
-    return frameAssertions;
+    return intrinsicLevel;
   }
 
   getLastMetaproofStep() {
@@ -58,19 +64,19 @@ class LocalMetaContext extends LocalContext {
     return lastMetaproofStep;
   }
 
-  addFrameAssertion(frameAssertion) {
-    let frameAssertionAdded = false;
+  addJudgement(judgement) {
+    let judgementAdded = false;
 
-    const metavariableNode = frameAssertion.getMetavariableNode(),
-          frameAssertionPresent = this.isFrameAssertionPresentByMetavariableNode(metavariableNode);
+    const metavariableNode = judgement.getMetavariableNode(),
+          judgementPresent = this.isJudgementPresentByMetavariableNode(metavariableNode);
 
-    if (!frameAssertionPresent) {
-      this.frameAssertions.push(frameAssertion);
+    if (!judgementPresent) {
+      this.judgements.push(judgement);
 
-      frameAssertionAdded = true;
+      judgementAdded = true;
     }
 
-    return frameAssertionAdded;
+    return judgementAdded;
   }
 
   addMetavariable(metavariable) {
@@ -114,11 +120,11 @@ class LocalMetaContext extends LocalContext {
     return matchesMetastatementNode;
   }
 
-  findMetavariableByMetavariableNode(metavariableNode, localMetaContext) {
+  findMetavariableByMetavariableNode(metavariableNode, metaLevelLocalContext) {
     const node = metavariableNode,  ///
           metavariables = this.getMetavariables(),
           metavariable = metavariables.find((metavariable) => {
-            const matches = metavariable.matchNode(node, localMetaContext);
+            const matches = metavariable.matchNode(node, metaLevelLocalContext);
 
             if (matches) {
               return true;
@@ -128,31 +134,31 @@ class LocalMetaContext extends LocalContext {
     return metavariable;
   }
 
-  findFrameAssertionByMetavariableNode(metavariableNode) {
-    const frameAssertions = this.getFrameAssertions(),
-          frameAssertion = frameAssertions.find((frameAssertion) => {
-            const frameAssertionMatchesMetavariableNode = frameAssertion.matchMetavariableNode(metavariableNode);
+  findJudgementByMetavariableNode(metavariableNode) {
+    const judgements = this.getJudgements(),
+          judgement = judgements.find((judgement) => {
+            const judgementMatchesMetavariableNode = judgement.matchMetavariableNode(metavariableNode);
 
-            if (frameAssertionMatchesMetavariableNode) {
+            if (judgementMatchesMetavariableNode) {
               return true;
             }
           }) || null;
 
-    return frameAssertion;
+    return judgement;
   }
 
-  isMetavariablePresentByMetavariableNode(metavariableNode, localMetaContext) {
-    const metavariable = this.findMetavariableByMetavariableNode(metavariableNode, localMetaContext),
+  isMetavariablePresentByMetavariableNode(metavariableNode, metaLevelLocalContext) {
+    const metavariable = this.findMetavariableByMetavariableNode(metavariableNode, metaLevelLocalContext),
           metavariablePresent = (metavariable !== null);
 
     return metavariablePresent;
   }
 
-  isFrameAssertionPresentByMetavariableNode(metavariableNode) {
-    const frameAssertion = this.findFrameAssertionByMetavariableNode(metavariableNode),
-          frameAssertionPresent = (frameAssertion !== null);
+  isJudgementPresentByMetavariableNode(metavariableNode) {
+    const judgement = this.findJudgementByMetavariableNode(metavariableNode),
+          judgementPresent = (judgement !== null);
 
-    return frameAssertionPresent;
+    return judgementPresent;
   }
 
   static fromFileContext(fileContext) {
@@ -160,27 +166,26 @@ class LocalMetaContext extends LocalContext {
           variables = [],
           proofSteps = [],
           equivalences = [],
+          judgements = [],
           metavariables = [],
           metaproofSteps = [],
-          frameAssertions = [],
-          localMetaContext = new LocalMetaContext(context, variables, proofSteps, equivalences, metavariables, metaproofSteps, frameAssertions);
+          metaLevelLocalContext = new MetaLevelLocalContext(context, variables, proofSteps, equivalences, judgements, metavariables, metaproofSteps);
 
-    return localMetaContext;
+    return metaLevelLocalContext;
   }
 
-  static fromLocalMetaContext(localMetaContext) {
-    const context = localMetaContext,  ///
+  static fromLocalContext(localContext) {
+    const context = localContext,  ///
           variables = [],
           proofSteps = [],
           equivalences = [],
+          judgements = [],
           metavariables = [],
           metaproofSteps = [],
-          frameAssertions = [];
-
-    localMetaContext = new LocalMetaContext(context, variables, proofSteps, equivalences, metavariables, metaproofSteps, frameAssertions);  ///
+          metaLevelLocalContext = new MetaLevelLocalContext(context, variables, proofSteps, equivalences, judgements, metavariables, metaproofSteps);  ///
 
-    return localMetaContext;
+    return metaLevelLocalContext;
   }
 }
 
-export default LocalMetaContext;
+export default MetaLevelLocalContext;

package/src/{frameAssertion.js → judgement.js}

@@ -1,6 +1,6 @@
 "use strict";
 
-export default class FrameAssertion {
+export default class Judgement {
   constructor(node, frame, metavariableNode) {
     this.node = node;
     this.frame = frame;
@@ -29,10 +29,10 @@ export default class FrameAssertion {
 
   matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem) { return this.frame.matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem); }
 
-  static fromFrameAssertionNodeFrameAndMetavariableNode(frameAssertionNode, frame, metavariableNode) {
-    const node = frameAssertionNode,
-          frameAssertion = new FrameAssertion(node, frame, metavariableNode);
+  static fromJudgementNodeFrameAndMetavariableNode(judgementNode, frame, metavariableNode) {
+    const node = judgementNode,
+          judgement = new Judgement(node, frame, metavariableNode);
 
-    return frameAssertion;
+    return judgement;
   }
 }

package/src/metaConsequent.js

@@ -1,7 +1,7 @@
 "use strict";
 
-import LocalMetaContext from "./context/localMeta";
 import metaLevelNodesVerifier from "./verifier/nodes/metaLevel";
+import MetaLevelLocalContext from "./context/local/metaLevel";
 
 import { nodeAsString } from "./utilities/string";
 import { statementNodeFromStatementString, metastatementNodeFromMetastatementString } from "./utilities/node";
@@ -20,16 +20,16 @@ export default class MetaConsequent {
     return this.statementNode;
   }
 
-  matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext) {
+  matchMetastatementNode(metastatementNode, substitutions, fileContext, localContext) {
     let matchesMetastatementNode = false;
 
     if (this.metastatementNode !== null) {
-      const nonTerminalNodeA = this.metastatementNode,  ///
+      const metaLevelLocalContext = MetaLevelLocalContext.fromFileContext(fileContext),
+            nonTerminalNodeA = this.metastatementNode,  ///
             nonTerminalNodeB = metastatementNode,  ///
-            fileContextA = fileContext, ///
-            localMetaContextA = LocalMetaContext.fromFileContext(fileContextA),
-            localMetaContextB = localMetaContext, ///
-            nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, () => {
+            localContextA = metaLevelLocalContext,  ///
+            localContextB = localContext, ///
+            nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
               const verifiedAhead = true;
 
               return verifiedAhead;

package/src/metaLemmaMetatheorem.js

@@ -36,15 +36,15 @@ export default class MetaLemmaMetatheorem {
     return this.fileContext;
   }
 
-  matchMetastatement(metastatementNode, localMetaContext) {
+  matchMetastatement(metastatementNode, localContext) {
     let metastatementNatches = false;
 
-    const metaproofSteps = localMetaContext.getProofSteps(),
+    const metaproofSteps = localContext.getProofSteps(),
           substitutions = [],
-          metaSuppositionsMatch = matchMetaSuppositions(this.metaSuppositions, metaproofSteps, substitutions, this.fileContext, localMetaContext);
+          metaSuppositionsMatch = matchMetaSuppositions(this.metaSuppositions, metaproofSteps, substitutions, this.fileContext, localContext);
 
     if (metaSuppositionsMatch) {
-      const metaConsequentMatches = matchMetaConsequent(this.metaConsequent, metastatementNode, substitutions, this.fileContext, localMetaContext);
+      const metaConsequentMatches = matchMetaConsequent(this.metaConsequent, metastatementNode, substitutions, this.fileContext, localContext);
 
       metastatementNatches = metaConsequentMatches;  ///
     }
@@ -143,13 +143,13 @@ export default class MetaLemmaMetatheorem {
   static fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(Class, labels, metaSuppositions, metaConsequent, substitutions, fileContext) { return new Class(labels, metaSuppositions, metaConsequent, substitutions, fileContext); }
 }
 
-function matchMetaSuppositions(metaSuppositions, metaproofSteps, substitutions, fileContext, localMetaContext) {
+function matchMetaSuppositions(metaSuppositions, metaproofSteps, substitutions, fileContext, localContext) {
   metaSuppositions = reverse(metaSuppositions); ///
 
   metaproofSteps = reverse(metaproofSteps); ///
 
   const metaSuppositionsMatch = correlate(metaSuppositions, metaproofSteps, (metaSupposition, metaproofStep) => {
-    const metaSuppositionMatches = matchMetaSupposition(metaSupposition, metaproofStep, substitutions, fileContext, localMetaContext);
+    const metaSuppositionMatches = matchMetaSupposition(metaSupposition, metaproofStep, substitutions, fileContext, localContext);
 
     if (metaSuppositionMatches) {
       return true;
@@ -159,20 +159,20 @@ function matchMetaSuppositions(metaSuppositions, metaproofSteps, substitutions,
   return metaSuppositionsMatch;
 }
 
-function matchMetaSupposition(metaSupposition, metaproofStep, substitutions, fileContext, localMetaContext) {
+function matchMetaSupposition(metaSupposition, metaproofStep, substitutions, fileContext, localContext) {
   let matchesMetaSupposition = false;
 
   const metaSubproofNode = metaproofStep.getMetaSubproofNode(),
         metastatementNode = metaproofStep.getMetastatementNode();
 
   if (metaSubproofNode !== null) {
-    const metaSuppositionMatchesMetaSubproofNode = metaSupposition.matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext);
+    const metaSuppositionMatchesMetaSubproofNode = metaSupposition.matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localContext);
 
     matchesMetaSupposition - metaSuppositionMatchesMetaSubproofNode; ///
   }
 
   if (metastatementNode !== null) {
-    const metaSuppositionMatchesMetastatementNode = metaSupposition.matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext);
+    const metaSuppositionMatchesMetastatementNode = metaSupposition.matchMetastatementNode(metastatementNode, substitutions, fileContext, localContext);
 
     matchesMetaSupposition - metaSuppositionMatchesMetastatementNode; ///
   }
@@ -180,8 +180,8 @@ function matchMetaSupposition(metaSupposition, metaproofStep, substitutions, fil
   return matchesMetaSupposition;
 }
 
-function matchMetaConsequent(metaConsequent, metastatementNode, substitutions, fileContext, localMetaContext) {
-  const metaConsequentMatchesMetastatementNode = metaConsequent.matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext),
+function matchMetaConsequent(metaConsequent, metastatementNode, substitutions, fileContext, localContext) {
+  const metaConsequentMatchesMetastatementNode = metaConsequent.matchMetastatementNode(metastatementNode, substitutions, fileContext, localContext),
         metaConsequentMatches = metaConsequentMatchesMetastatementNode; ///
 
   return metaConsequentMatches;

package/src/metaSupposition.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import LocalMetaContext from "./context/localMeta";
+import MetaLevelLocalContext from "./context/local/metaLevel";
 import metaLevelNodesVerifier from "./verifier/nodes/metaLevel";
 
 import { match } from "./utilities/array";
@@ -27,7 +27,7 @@ export default class MetaSupposition {
     return this.statementNode;
   }
 
-  matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext) {
+  matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localContext) {
     let matchesMetaSubproofNode = false;
 
     if (this.metastatementNode !== null) {
@@ -43,12 +43,12 @@ export default class MetaSupposition {
               subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
 
         matchesMetaSubproofNode = match(subproofAssertionMetastatementNodes, metaSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
-          const nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
+          const metaLevelLocalContext = MetaLevelLocalContext.fromFileContext(fileContext),
+                nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = ruleSubproofMetastatementNode, ///
-                fileContextA = fileContext, ///
-                localMetaContextA = LocalMetaContext.fromFileContext(fileContextA),
-                localMetaContextB = localMetaContext,  ///
-                nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, () => {
+                localContextA = metaLevelLocalContext,  ///
+                localContextB = localContext,  ///
+                nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
                   const verifiedAhead = true;
 
                   return verifiedAhead;
@@ -64,16 +64,16 @@ export default class MetaSupposition {
     return matchesMetaSubproofNode;
   }
 
-  matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext) {
+  matchMetastatementNode(metastatementNode, substitutions, fileContext, localContext) {
     let matchesMetastatementNode = false;
 
     if (this.metastatementNode !== null) {
-      const nonTerminalNodeA = this.metastatementNode,  ///
+      const metaLevelLocalContext = MetaLevelLocalContext.fromFileContext(fileContext),
+            nonTerminalNodeA = this.metastatementNode,  ///
             nonTerminalNodeB = metastatementNode,  ///
-            fileContextA = fileContext, ///
-            localMetaContextA = LocalMetaContext.fromFileContext(fileContextA),
-            localMetaContextB = localMetaContext,  ///
-            nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, () => {
+            localContextA = metaLevelLocalContext,  ///
+            localContextB = localContext,  ///
+            nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
               const verifiedAhead = true;
 
               return verifiedAhead;

package/src/metavariable.js

@@ -42,7 +42,7 @@ export default class Metavariable {
     return matchesName;
   }
 
-  matchNode(node, localMetaContext) {
+  matchNode(node, localContext) {
     let matchesNode = false;
 
     const metavariableNode = node,  ///
@@ -59,7 +59,7 @@ export default class Metavariable {
         } else if ((termNode === null) && (this.termType === null)) {
           matchesNode = true;
         } else if ((termNode !== null) && (this.termType !== null)) {
-          const termVerifiedAgainstTermType = verifyTermAgainstTermType(termNode, this.termType, localMetaContext);
+          const termVerifiedAgainstTermType = verifyTermAgainstTermType(termNode, this.termType, localContext);
 
           matchesNode = termVerifiedAgainstTermType;  ///
         }
@@ -122,12 +122,11 @@ export default class Metavariable {
   }
 }
 
-function verifyTermAgainstTermType(termNode, termType, localMetaContext) {
+function verifyTermAgainstTermType(termNode, termType, localContext) {
   let termVerifiedAgainstTermType;
 
   const type = termType,  ///
-        terms = [],
-        localContext = localMetaContext;  ///
+        terms = [];
 
   termVerifiedAgainstTermType = verifyTerm(termNode, terms, localContext, () => {
     let verifiedAhead = false;
@@ -153,9 +152,9 @@ function termTypeFromMetavariableNode(metavariableNode, fileContext) {
   const typeNode = typeNodeQuery(metavariableNode);
 
   if (typeNode !== null) {
-      const type = fileContext.findTypeByTypeNode(typeNode);
+    const type = fileContext.findTypeByTypeNode(typeNode);
 
-      termType = type;  ///
+    termType = type;  ///
   }
 
   return termType;

package/src/premise.js

@@ -1,8 +1,8 @@
 "use strict";
 
-import LocalContext from "./context/local";
-import LocalMetaContext from "./context/localMeta";
+import MetaLevelLocalContext from "./context/local/metaLevel";
 import metaLevelNodesVerifier from "./verifier/nodes/metaLevel";
+import IntrinsicLevelLocalContext from "./context/local/intrinsicLevel";
 import intrinsicLevelAgainstMetaLevelNodesVerifier from "./verifier/nodes/intrinsicLevelAgainstMetaLevel";
 
 import { match } from "./utilities/array";
@@ -37,10 +37,10 @@ export default class Premise {
     let matchesStatementNode = false;
 
     if (this.metastatementNode !== null) {
-      const nonTerminalNodeA = this.metastatementNode,  ///
+      const intrinsicLevelLocalContext = IntrinsicLevelLocalContext.fromFileContext(fileContext),
+            nonTerminalNodeA = this.metastatementNode,  ///
             nonTerminalNodeB = statementNode,  ///
-            fileContextA = fileContext, ///
-            localContextA = LocalContext.fromFileContext(fileContextA),
+            localContextA = intrinsicLevelLocalContext, ///
             localContextB = localContext,  ///
             nonTerminalNodeVerified = intrinsicLevelAgainstMetaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
               const verifiedAhead = true;
@@ -70,10 +70,10 @@ export default class Premise {
               subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
 
         matchesSubproofNode = match(subproofAssertionMetastatementNodes, subproofStatementNodes, (subproofAssertionMetastatementNode, subproofStatementNode) => {
-          const nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
+          const metaLevelLocalContext = MetaLevelLocalContext.fromFileContext(fileContext),
+                nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = subproofStatementNode, ///
-                fileContextA = fileContext, ///
-                localContextA = LocalMetaContext.fromFileContext(fileContextA),
+                localContextA = metaLevelLocalContext,  ///
                 localContextB = localContext,  ///
                 nonTerminalNodeVerified = intrinsicLevelAgainstMetaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
                   const verifiedAhead = true;
@@ -91,7 +91,7 @@ export default class Premise {
     return matchesSubproofNode;
   }
 
-  matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, localMetaContext) {
+  matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, localContext) {
     let matchesRuleSubproofNode = false;
 
     if (this.metastatementNode !== null) {
@@ -107,12 +107,12 @@ export default class Premise {
               subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
 
         matchesRuleSubproofNode = match(subproofAssertionMetastatementNodes, ruleSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
-          const nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
+          const metaLevelLocalContext = MetaLevelLocalContext.fromFileContext(fileContext),
+                nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = ruleSubproofMetastatementNode, ///
-                fileContextA = fileContext, ///
-                localMetaContextA = LocalMetaContext.fromFileContext(fileContextA),
-                localMetaContextB = localMetaContext,  ///
-                nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, () => {
+                localContextA = metaLevelLocalContext,  ///
+                localContextB = localContext,  ///
+                nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
                   const verifiedAhead = true;
 
                   return verifiedAhead;
@@ -128,7 +128,7 @@ export default class Premise {
     return matchesRuleSubproofNode;
   }
 
-  matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext) {
+  matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localContext) {
     let matchesMetaSubproofNode = false;
 
     if (this.metastatementNode !== null) {
@@ -144,12 +144,12 @@ export default class Premise {
               subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
 
         matchesMetaSubproofNode = match(subproofAssertionMetastatementNodes, metaSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
-          const nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
+          const metaLevelLocalContext = MetaLevelLocalContext.fromFileContext(fileContext),
+                nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = ruleSubproofMetastatementNode, ///
-                fileContextA = fileContext, ///
-                localMetaContextA = LocalMetaContext.fromFileContext(fileContextA),
-                localMetaContextB = localMetaContext,  ///
-                nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, () => {
+                localContextA = metaLevelLocalContext,  ///
+                localContextB = localContext,  ///
+                nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
                   const verifiedAhead = true;
 
                   return verifiedAhead;
@@ -165,16 +165,16 @@ export default class Premise {
     return matchesMetaSubproofNode;
   }
 
-  matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext) {
+  matchMetastatementNode(metastatementNode, substitutions, fileContext, localContext) {
     let matchesMetastatementNode = false;
 
     if (this.metastatementNode !== null) {
-      const nonTerminalNodeA = this.metastatementNode,  ///
+      const metaLevelLocalContext = MetaLevelLocalContext.fromFileContext(fileContext),
+            nonTerminalNodeA = this.metastatementNode,  ///
             nonTerminalNodeB = metastatementNode,  ///
-            fileContextA = fileContext, ///
-            localMetaContextA = LocalMetaContext.fromFileContext(fileContextA),
-            localMetaContextB = localMetaContext,  ///
-            nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, () => {
+            localContextA = metaLevelLocalContext,  ///
+            localContextB = localContext,  ///
+            nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
               const verifiedAhead = true;
 
               return verifiedAhead;

package/src/rule.js

@@ -46,15 +46,15 @@ export default class Rule {
     return matchesStatement;
   }
 
-  matchMetastatement(metastatementNode, localMetaContext) {
+  matchMetastatement(metastatementNode, localContext) {
     let matchesMetastatement = false;
 
-    const metaproofSteps = localMetaContext.getMetaproofSteps(),
+    const metaproofSteps = localContext.getMetaproofSteps(),
           substitutions = [],
-          premisesMatch = metaMatchPremises(this.premises, metaproofSteps, substitutions, this.fileContext, localMetaContext);
+          premisesMatch = metaMatchPremises(this.premises, metaproofSteps, substitutions, this.fileContext, localContext);
 
     if (premisesMatch) {
-      const conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, substitutions, this.fileContext, localMetaContext);
+      const conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, substitutions, this.fileContext, localContext);
 
       matchesMetastatement = conclusionMatches;  ///
     }
@@ -187,7 +187,7 @@ function matchConclusion(conclusion, statementNode, substitutions, fileContext,
   return conclusionMatches;
 }
 
-function metaMatchPremise(premise, metaproofStep, substitutions, fileContext, localMetaContext) {
+function metaMatchPremise(premise, metaproofStep, substitutions, fileContext, localContext) {
   let premiseMatches = false;
 
   const ruleSubproofNode = metaproofStep.getRuleSubproofNode(),
@@ -195,19 +195,19 @@ function metaMatchPremise(premise, metaproofStep, substitutions, fileContext, lo
         metastatementNode = metaproofStep.getMetastatementNode()
 
   if (ruleSubproofNode !== null) {
-    const premiseMatchesRuleSubproofNode = premise.matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, localMetaContext);
+    const premiseMatchesRuleSubproofNode = premise.matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, localContext);
 
     premiseMatches = premiseMatchesRuleSubproofNode; ///
   }
 
   if (metaSubproofNode !== null) {
-    const premiseMatchesMetaSubproofNode = premise.matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext);
+    const premiseMatchesMetaSubproofNode = premise.matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localContext);
 
     premiseMatches = premiseMatchesMetaSubproofNode; ///
   }
 
   if (metastatementNode !== null) {
-    const premiseMatchesMetastatementNode = premise.matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext);
+    const premiseMatchesMetastatementNode = premise.matchMetastatementNode(metastatementNode, substitutions, fileContext, localContext);
 
     premiseMatches = premiseMatchesMetastatementNode;  ///
   }
@@ -215,13 +215,13 @@ function metaMatchPremise(premise, metaproofStep, substitutions, fileContext, lo
   return premiseMatches;
 }
 
-function metaMatchPremises(premises, metaproofSteps, substitutions, fileContext, localMetaContext) {
+function metaMatchPremises(premises, metaproofSteps, substitutions, fileContext, localContext) {
   premises = reverse(premises); ///
 
   metaproofSteps = reverse(metaproofSteps); ///
 
   const premisesMatch = correlate(premises, metaproofSteps, (premise, metaproofStep) => {
-    const premiseMatches = metaMatchPremise(premise, metaproofStep, substitutions, fileContext, localMetaContext);
+    const premiseMatches = metaMatchPremise(premise, metaproofStep, substitutions, fileContext, localContext);
 
     if (premiseMatches) {
       return true;
@@ -231,8 +231,8 @@ function metaMatchPremises(premises, metaproofSteps, substitutions, fileContext,
   return premisesMatch;
 }
 
-function metaMatchConclusion(conclusion, metastatementNode, substitutions, fileContext, localMetaContext) {
-  const conclusionMatchesMetastatementNode = conclusion.matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext),
+function metaMatchConclusion(conclusion, metastatementNode, substitutions, fileContext, localContext) {
+  const conclusionMatchesMetastatementNode = conclusion.matchMetastatementNode(metastatementNode, substitutions, fileContext, localContext),
         conclusionMatches = conclusionMatchesMetastatementNode; ///
 
   return conclusionMatches;