occam-verify-cli 0.0.913 → 0.0.915

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

@@ -1,10 +1,10 @@
 "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 {
+class MetaLevelLocalContext extends IntrinsicLevelLocalContext {
   constructor(context, variables, proofSteps, equivalences, metavariables, metaproofSteps, frameAssertions) {
     super(context, variables, proofSteps, equivalences);
 
@@ -46,6 +46,12 @@ class LocalMetaContext extends LocalContext {
     return frameAssertions;
   }
 
+  isIntrinsicLevel() {
+    const intrinsicLevel = false;
+
+    return intrinsicLevel;
+  }
+
   getLastMetaproofStep() {
     let lastMetaproofStep = null;
 
@@ -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;
@@ -141,8 +147,8 @@ class LocalMetaContext extends LocalContext {
     return frameAssertion;
   }
 
-  isMetavariablePresentByMetavariableNode(metavariableNode, localMetaContext) {
-    const metavariable = this.findMetavariableByMetavariableNode(metavariableNode, localMetaContext),
+  isMetavariablePresentByMetavariableNode(metavariableNode, metaLevelLocalContext) {
+    const metavariable = this.findMetavariableByMetavariableNode(metavariableNode, metaLevelLocalContext),
           metavariablePresent = (metavariable !== null);
 
     return metavariablePresent;
@@ -163,24 +169,23 @@ class LocalMetaContext extends LocalContext {
           metavariables = [],
           metaproofSteps = [],
           frameAssertions = [],
-          localMetaContext = new LocalMetaContext(context, variables, proofSteps, equivalences, metavariables, metaproofSteps, frameAssertions);
+          metaLevelLocalContext = new MetaLevelLocalContext(context, variables, proofSteps, equivalences, metavariables, metaproofSteps, frameAssertions);
 
-    return localMetaContext;
+    return metaLevelLocalContext;
   }
 
-  static fromLocalMetaContext(localMetaContext) {
-    const context = localMetaContext,  ///
+  static fromLocalContext(localContext) {
+    const context = localContext,  ///
           variables = [],
           proofSteps = [],
           equivalences = [],
           metavariables = [],
           metaproofSteps = [],
-          frameAssertions = [];
-
-    localMetaContext = new LocalMetaContext(context, variables, proofSteps, equivalences, metavariables, metaproofSteps, frameAssertions);  ///
+          frameAssertions = [],
+          metaLevelLocalContext = new MetaLevelLocalContext(context, variables, proofSteps, equivalences, metavariables, metaproofSteps, frameAssertions);  ///
 
-    return localMetaContext;
+    return metaLevelLocalContext;
   }
 }
 
-export default LocalMetaContext;
+export default MetaLevelLocalContext;

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;

package/src/verifier/node/{metastatement.js → metaLevel.js}

@@ -13,18 +13,18 @@ const termNodeQuery = nodeQuery("/term!"),
       nonTerminalNodeQuery = nodeQuery("/*"),
       metavariableNodeQuery = nodeQuery("/metavariable!");
 
-class MetastatementNodeVerifier extends NodeVerifier {
-  verifyNonTerminalNode(nonTerminalNode, localMetaContext, verifyAhead) {
+class MetaLevelNodeVerifier extends NodeVerifier {
+  verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead) {
     let nonTerminalNodeVerified;
 
     const nodeQueryMaps = [
       {
         nodeQuery: termNodeQuery,
-        verifyNode: (node, localMetaContext, verifyAhead) => {
+        verifyNode: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const termNode = node, ///
-                termNodeVerified = this.verifyTermNode(termNode, localMetaContext, verifyAhead);
+                termNodeVerified = this.verifyTermNode(termNode, localContext, verifyAhead);
 
           nonTerminalNodeVerified = termNodeVerified; ///
 
@@ -33,11 +33,11 @@ class MetastatementNodeVerifier extends NodeVerifier {
       },
       {
         nodeQuery: variableNodeQuery,
-        verifyNode: (node, localMetaContext, verifyAhead) => {
+        verifyNode: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const variableNode = node, ///
-                variableNodeVerified = this.verifyVariableNode(variableNode, localMetaContext, verifyAhead);
+                variableNodeVerified = this.verifyVariableNode(variableNode, localContext, verifyAhead);
 
           nonTerminalNodeVerified = variableNodeVerified; ///
 
@@ -46,11 +46,11 @@ class MetastatementNodeVerifier extends NodeVerifier {
       },
       {
         nodeQuery: metavariableNodeQuery,
-        verifyNode: (node, localMetaContext, verifyAhead) => {
+        verifyNode: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const metavariableNode = node, ///
-                metavariableNodeVerified = this.verifyMetavariableNode(metavariableNode, localMetaContext, verifyAhead);
+                metavariableNodeVerified = this.verifyMetavariableNode(metavariableNode, localContext, verifyAhead);
 
           nonTerminalNodeVerified = metavariableNodeVerified; ///
 
@@ -59,51 +59,49 @@ class MetastatementNodeVerifier extends NodeVerifier {
       },
       {
         nodeQuery: nonTerminalNodeQuery,
-        verifyNode: (node, localMetaContext, verifyAhead) => {
+        verifyNode: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const nonTerminalNode = node; ///
 
           nonTerminalNodeVerified =
 
-            super.verifyNonTerminalNode(nonTerminalNode, localMetaContext, verifyAhead);
+            super.verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead);
 
           return nonTerminalNodeVerified;
         }
       }
     ];
 
-    const nodeVerified = verifyNode(nodeQueryMaps, nonTerminalNode, localMetaContext, verifyAhead);
+    const nodeVerified = verifyNode(nodeQueryMaps, nonTerminalNode, localContext, verifyAhead);
 
     nonTerminalNodeVerified = nodeVerified; ///
 
     return nonTerminalNodeVerified;
   }
 
-  verifyMetavariableNode(metavariableNode, localMetaContext, verifyAhead) {
-    const standaloneMetavariableVerified = verifyStandaloneMetavariable(metavariableNode, localMetaContext, verifyAhead),
+  verifyMetavariableNode(metavariableNode, localContext, verifyAhead) {
+    const standaloneMetavariableVerified = verifyStandaloneMetavariable(metavariableNode, localContext, verifyAhead),
           metavariableNodeVerified = standaloneMetavariableVerified;  ///
 
     return metavariableNodeVerified;
   }
 
-  verifyVariableNode(variableNode, localMetaContext, verifyAhead) {
-    const localContext = localMetaContext,  ///
-          standaloneVariableVerified = verifyStandaloneVariable(variableNode, localContext, verifyAhead),
+  verifyVariableNode(variableNode, localContext, verifyAhead) {
+    const standaloneVariableVerified = verifyStandaloneVariable(variableNode, localContext, verifyAhead),
           variableNodeVerified = standaloneVariableVerified;  ///
 
     return variableNodeVerified;
   }
 
-  verifyTermNode(termNode, localMetaContext, verifyAhead) {
-    const localContext = localMetaContext,  ///
-          standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
+  verifyTermNode(termNode, localContext, verifyAhead) {
+    const standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
           termNodeVerified = standaloneTermVerified;  ///
 
     return termNodeVerified;
   }
 }
 
-const metastatementNodeVerifier = new MetastatementNodeVerifier();
+const metaLevelNodeVerifier = new MetaLevelNodeVerifier();
 
-export default metastatementNodeVerifier;
+export default metaLevelNodeVerifier;