occam-verify-cli 0.0.921 → 0.0.922

package/src/context/{local/intrinsicLevel.js → local.js}

@@ -1,18 +1,21 @@
 "use strict";
 
-import Variable from "../../variable";
-import Equivalence from "../../equivalence";
-import contextMixins from "../../mixins/context";
+import Variable from "../variable";
+import Equivalence from "../equivalence";
+import contextMixins from "../mixins/context";
 
-import { last, reverse } from "../../utilities/array";
-import { mergeEquivalences, findEquivalenceByTerm, groundedTermsAndDefinedVariablesFromFromEquivalences } from "../../utilities/equivalences";
+import { last, reverse } from "../utilities/array";
+import { mergeEquivalences, findEquivalenceByTerm, groundedTermsAndDefinedVariablesFromFromEquivalences } from "../utilities/equivalences";
 
-class IntrinsicLevelLocalContext {
-  constructor(context, variables, proofSteps, equivalences) {
+class LocalContext {
+  constructor(context, variables, proofSteps, equivalences, judgements, metavariables, metaproofSteps) {
     this.context = context;
     this.variables = variables;
     this.proofSteps = proofSteps;
     this.equivalences = equivalences;
+    this.judgements = judgements;
+    this.metavariables = metavariables;
+    this.metaproofSteps = metaproofSteps;
   }
 
   getContext() {
@@ -46,87 +49,68 @@ class IntrinsicLevelLocalContext {
 
     const equivalencesA = this.equivalences, ///
           equivalencesB = equivalences,
-          intrinsicLevelLocalContext = this;  ///
+          LocalContext = this;  ///
 
-    equivalences = mergeEquivalences(equivalencesA, equivalencesB, intrinsicLevelLocalContext); ///
+    equivalences = mergeEquivalences(equivalencesA, equivalencesB, LocalContext); ///
 
     return equivalences;
   }
 
-  isIntrinsicLevel() {
-    const intrinsicLevel = true;
+  getJudgements() {
+    let judgements = this.context.getJudgements();
 
-    return intrinsicLevel;
+    judgements = [ ///
+      ...this.judgements,
+      ...judgements
+    ]
+
+    return judgements;
   }
 
-  getLastProofStep() {
-    let lastProofStep = null;
+  getMetavariables() {
+    let metavariables = this.context.getMetavariables();
 
-    const proofStepsLength = this.proofSteps.length;
+    metavariables = [ ///
+      ...this.metavariables,
+      ...metavariables
+    ]
 
-    if (proofStepsLength > 0) {
-      lastProofStep = last(this.proofSteps);
-    }
-
-    return lastProofStep;
+    return metavariables;
   }
 
-  getTermType(term) {
-    let termType;
-
-    const equivalences = this.getEquivalences(),
-          equivalence = findEquivalenceByTerm(equivalences, term);
-
-    if (equivalence !== null) {
-      const intrinsicLevelLocalContext = this,  ///
-            equivalenceType = equivalence.getType(intrinsicLevelLocalContext);
+  getMetaproofSteps() {
+    let metaproofSteps = this.context.getMetaproofSteps();
 
-      termType = equivalenceType;  ///
-    } else {
-      termType = term.getType();
-    }
+    metaproofSteps = [  ///
+      ...metaproofSteps,
+      ...this.metaproofSteps
+    ];
 
-    return termType;
+    return metaproofSteps;
   }
 
-  isTermGrounded(term) {
-    const context = this,
-          equivalences = this.getEquivalences(),
-          groundedTerms = [],
-          definedVariables = [];
-
-    groundedTermsAndDefinedVariablesFromFromEquivalences(equivalences, groundedTerms, definedVariables, context);
+  getLastProofStep() {
+    let lastProofStep = null;
 
-    const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
-            const termMatchesGroundedTerm = term.match(groundedTerm);
+    const proofStepsLength = this.proofSteps.length;
 
-            if (termMatchesGroundedTerm) {
-              return true;
-            }
-          }),
-          termGrounded = termMatchesGroundedTerm; ///
+    if (proofStepsLength > 0) {
+      lastProofStep = last(this.proofSteps);
+    }
 
-    return termGrounded;
+    return lastProofStep;
   }
 
-  isVariableDefined(variable) {
-    const context = this,
-          equivalences = this.getEquivalences(),
-          groundedTerms = [],
-          definedVariables = [];
+  getLastMetaproofStep() {
+    let lastMetaproofStep = null;
 
-    groundedTermsAndDefinedVariablesFromFromEquivalences(equivalences, groundedTerms, definedVariables, context);
+    const metaproofStepsLength = this.metaproofSteps.length;
 
-    const variableMatchesDefinedVariable = definedVariables.some((definedVariable) => {
-            const variableMatchesDefinedVariable = variable.match(definedVariable);
-
-            if (variableMatchesDefinedVariable) {
-              return true;
-            }
-          }),
-          variableDefined = variableMatchesDefinedVariable; ///
+    if (metaproofStepsLength > 0) {
+      lastMetaproofStep = last(this.metaproofSteps);
+    }
 
-    return variableDefined;
+    return lastMetaproofStep;
   }
 
   addEquality(equality) {
@@ -221,6 +205,46 @@ class IntrinsicLevelLocalContext {
     this.equivalences.splice(start, deleteCount);
   }
 
+  addJudgement(judgement) {
+    let judgementAdded = false;
+
+    const metavariableNode = judgement.getMetavariableNode(),
+          judgementPresent = this.isJudgementPresentByMetavariableNode(metavariableNode);
+
+    if (!judgementPresent) {
+      this.judgements.push(judgement);
+
+      judgementAdded = true;
+    }
+
+    return judgementAdded;
+  }
+
+  addMetavariable(metavariable) {
+    let metavariableAdded = false;
+
+    const node = metavariable.getName(),
+          metavariablePresent = this.metavariables.some((metavariable) => {
+            const metavariableMatchesNode = metavariable.matchNode(node);
+
+            if (metavariableMatchesNode) {
+              return true;
+            }
+          });
+
+    if (!metavariablePresent) {
+      this.metavariables.push(metavariable);
+
+      metavariableAdded = true;
+    }
+
+    return metavariableAdded;
+  }
+
+  addMetaproofStep(metaproofStep) {
+    this.metaproofSteps.push(metaproofStep);
+  }
+
   matchStatementNode(statementNode) {
     let proofSteps = this.getProofSteps();
 
@@ -237,21 +261,79 @@ class IntrinsicLevelLocalContext {
     return matchesStatementNode;
   }
 
-  findVariableByVariableNode(variableNode) {
-    const node = variableNode,  ///
-          variables = this.getVariables(),
-          variable = variables.find((variable) => {
-            const matches = variable.matchNode(node);
+  matchMetastatementNode(metastatementNode) {
+    let metaproofSteps = this.getMetaproofSteps();
 
-            if (matches) {
+    metaproofSteps = reverse(metaproofSteps); ///
+
+    const matchesMetastatementNode = metaproofSteps.some((metaproofStep) => {
+      const metaproofStepMatchesMetastatementNode = metaproofStep.matchMetastatementNode(metastatementNode);
+
+      if (metaproofStepMatchesMetastatementNode) {
+        return true;
+      }
+    });
+
+    return matchesMetastatementNode;
+  }
+
+  getTermType(term) {
+    let termType;
+
+    const equivalences = this.getEquivalences(),
+          equivalence = findEquivalenceByTerm(equivalences, term);
+
+    if (equivalence !== null) {
+      const LocalContext = this,  ///
+            equivalenceType = equivalence.getType(LocalContext);
+
+      termType = equivalenceType;  ///
+    } else {
+      termType = term.getType();
+    }
+
+    return termType;
+  }
+
+  isTermGrounded(term) {
+    const context = this,
+          equivalences = this.getEquivalences(),
+          groundedTerms = [],
+          definedVariables = [];
+
+    groundedTermsAndDefinedVariablesFromFromEquivalences(equivalences, groundedTerms, definedVariables, context);
+
+    const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
+            const termMatchesGroundedTerm = term.match(groundedTerm);
+
+            if (termMatchesGroundedTerm) {
               return true;
             }
-          }) || null;
+          }),
+          termGrounded = termMatchesGroundedTerm; ///
 
-    return variable;
+    return termGrounded;
   }
 
-  findMetaTypeByMetaTypeNode(metaTypeNode) { return this.context.findMetaTypeByMetaTypeNode(metaTypeNode); }
+  isVariableDefined(variable) {
+    const context = this,
+          equivalences = this.getEquivalences(),
+          groundedTerms = [],
+          definedVariables = [];
+
+    groundedTermsAndDefinedVariablesFromFromEquivalences(equivalences, groundedTerms, definedVariables, context);
+
+    const variableMatchesDefinedVariable = definedVariables.some((definedVariable) => {
+            const variableMatchesDefinedVariable = variable.match(definedVariable);
+
+            if (variableMatchesDefinedVariable) {
+              return true;
+            }
+          }),
+          variableDefined = variableMatchesDefinedVariable; ///
+
+    return variableDefined;
+  }
 
   isVariablePresentByVariableNode(variableNode) {
     const variable = this.findVariableByVariableNode(variableNode),
@@ -260,19 +342,59 @@ class IntrinsicLevelLocalContext {
     return variablePresent;
   }
 
-  toJSON(tokens) {
-    const variables = this.variables.map((variable) => {
-            const variableJSON = variable.toJSON(tokens);
+  isJudgementPresentByMetavariableNode(metavariableNode) {
+    const judgement = this.findJudgementByMetavariableNode(metavariableNode),
+          judgementPresent = (judgement !== null);
 
-            variable = variableJSON;
+    return judgementPresent;
+  }
 
-            return variable;
-          }),
-          json = {
-            variables
-          };
+  isMetavariablePresentByMetavariableNode(metavariableNode, localContext) {
+    const metavariable = this.findMetavariableByMetavariableNode(metavariableNode, localContext),
+          metavariablePresent = (metavariable !== null);
+
+    return metavariablePresent;
+  }
+
+  findVariableByVariableNode(variableNode) {
+    const node = variableNode,  ///
+      variables = this.getVariables(),
+      variable = variables.find((variable) => {
+        const matches = variable.matchNode(node);
+
+        if (matches) {
+          return true;
+        }
+      }) || null;
 
-    return json;
+    return variable;
+  }
+
+  findJudgementByMetavariableNode(metavariableNode) {
+    const judgements = this.getJudgements(),
+          judgement = judgements.find((judgement) => {
+            const judgementMatchesMetavariableNode = judgement.matchMetavariableNode(metavariableNode);
+
+            if (judgementMatchesMetavariableNode) {
+              return true;
+            }
+          }) || null;
+
+    return judgement;
+  }
+
+  findMetavariableByMetavariableNode(metavariableNode, localContext) {
+    const node = metavariableNode,  ///
+          metavariables = this.getMetavariables(),
+          metavariable = metavariables.find((metavariable) => {
+            const matches = metavariable.matchNode(node, localContext);
+
+            if (matches) {
+              return true;
+            }
+          }) || null;
+
+    return metavariable;
   }
 
   static fromFileContext(fileContext) {
@@ -280,9 +402,12 @@ class IntrinsicLevelLocalContext {
           variables = [],
           proofSteps = [],
           equivalences = [],
-          intrinsicLevelLocalContext = new IntrinsicLevelLocalContext(context, variables, proofSteps, equivalences);
+          judgements = [],
+          metavariables = [],
+          metaproofSteps = [],
+          localContext = new LocalContext(context, variables, proofSteps, equivalences, judgements, metavariables, metaproofSteps);
 
-    return intrinsicLevelLocalContext;
+    return localContext;
   }
 
   static fromLocalContext(localContext) {
@@ -290,9 +415,13 @@ class IntrinsicLevelLocalContext {
           variables = [],
           proofSteps = [],
           equivalences = [],
-          intrinsicLevelLocalContext = new IntrinsicLevelLocalContext(context, variables, proofSteps, equivalences);
+          judgements = [],
+          metavariables = [],
+          metaproofSteps = [];
+
+    localContext = new LocalContext(context, variables, proofSteps, equivalences, judgements, metavariables, metaproofSteps);  ///
 
-    return intrinsicLevelLocalContext;
+    return localContext;
   }
 
   static fromJSONAndFileContext(json, fileContext) {
@@ -310,12 +439,15 @@ class IntrinsicLevelLocalContext {
     const context = fileContext,  ///
           proofSteps = [],
           equivalences = [],
-          intrinsicLevelLocalContext = new IntrinsicLevelLocalContext(context, variables, proofSteps, equivalences);
+          judgements = [],
+          metavariables = [],
+          metaproofSteps = [],
+          localContext = new LocalContext(context, variables, proofSteps, equivalences, judgements, metavariables, metaproofSteps);  ///
 
-    return intrinsicLevelLocalContext;
+    return localContext;
   }
 }
 
-Object.assign(IntrinsicLevelLocalContext.prototype, contextMixins);
+Object.assign(LocalContext.prototype, contextMixins);
 
-export default IntrinsicLevelLocalContext;
+export default LocalContext;

package/src/metaConsequent.js

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

package/src/metaSupposition.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import MetaLevelLocalContext from "./context/local/metaLevel";
+import LocalContext from "./context/local";
 import metaLevelNodesVerifier from "./verifier/nodes/metaLevel";
 
 import { match } from "./utilities/array";
@@ -43,10 +43,10 @@ export default class MetaSupposition {
               subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
 
         matchesMetaSubproofNode = match(subproofAssertionMetastatementNodes, metaSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
-          const metaLevelLocalContext = MetaLevelLocalContext.fromFileContext(fileContext),
+          const fileContextA = fileContext, ///
                 nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = ruleSubproofMetastatementNode, ///
-                localContextA = metaLevelLocalContext,  ///
+                localContextA = LocalContext.fromFileContext(fileContextA),  ///
                 localContextB = localContext,  ///
                 nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
                   const verifiedAhead = true;
@@ -68,10 +68,10 @@ export default class MetaSupposition {
     let matchesMetastatementNode = false;
 
     if (this.metastatementNode !== null) {
-      const metaLevelLocalContext = MetaLevelLocalContext.fromFileContext(fileContext),
+      const fileContextA = fileContext, ///
             nonTerminalNodeA = this.metastatementNode,  ///
             nonTerminalNodeB = metastatementNode,  ///
-            localContextA = metaLevelLocalContext,  ///
+            localContextA = LocalContext.fromFileContext(fileContextA),  ///
             localContextB = localContext,  ///
             nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
               const verifiedAhead = true;

package/src/mixins/context.js

@@ -24,12 +24,6 @@ function getCombinators() { return this.context.getCombinators(); }
 
 function getConstructors() { return this.context.getConstructors(); }
 
-function findTypeByTypeName(typeName) { return this.context.findTypeByTypeName(typeName); }
-
-function findTypeByTypeNode(typeNode) { return this.context.findTypeByTypeNode(typeNode); }
-
-function findMetavariableByName(name) { return this.context.findMetavariableByName(name); }
-
 function isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }
 
 function isTypePresentByTypeNode(typeNode) { return this.context.isTypePresentByTypeNode(typeNode); }
@@ -38,8 +32,16 @@ function isMetavariablePresentByName(name) { return this.context.isMetavariableP
 
 function isLabelPresentByMetavariableNode(metavariableNode) { return this.context.isLabelPresentByMetavariableNode(metavariableNode); }
 
+function findTypeByTypeName(typeName) { return this.context.findTypeByTypeName(typeName); }
+
+function findTypeByTypeNode(typeNode) { return this.context.findTypeByTypeNode(typeNode); }
+
+function findMetavariableByName(name) { return this.context.findMetavariableByName(name); }
+
 function findLabelByMetavariableNode(metavariableNode) { return this.context.findLabelByMetavariableNode(metavariableNode); }
 
+function findMetaTypeByMetaTypeNode(metaTypeNode) { return this.context.findMetaTypeByMetaTypeNode(metaTypeNode); }
+
 function findRuleByMetavariableNode(metavariableNode) { return this.context.findRuleByMetavariableNode(metavariableNode); }
 
 function findAxiomByMetavariableNode(metavariableNode) { return this.context.findAxiomByMetavariableNode(metavariableNode); }
@@ -71,14 +73,15 @@ const contextMixins = {
   getConjectures,
   getCombinators,
   getConstructors,
-  findTypeByTypeName,
-  findTypeByTypeNode,
-  findMetavariableByName,
   isTypePresentByTypeName,
   isTypePresentByTypeNode,
   isMetavariablePresentByName,
   isLabelPresentByMetavariableNode,
+  findTypeByTypeName,
+  findTypeByTypeNode,
+  findMetavariableByName,
   findLabelByMetavariableNode,
+  findMetaTypeByMetaTypeNode,
   findRuleByMetavariableNode,
   findAxiomByMetavariableNode,
   findLemmaByMetavariableNode,

package/src/premise.js

@@ -1,8 +1,7 @@
 "use strict";
 
-import MetaLevelLocalContext from "./context/local/metaLevel";
+import LocalContext from "./context/local";
 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 +36,10 @@ export default class Premise {
     let matchesStatementNode = false;
 
     if (this.metastatementNode !== null) {
-      const intrinsicLevelLocalContext = IntrinsicLevelLocalContext.fromFileContext(fileContext),
+      const fileContextA = fileContext, ///
             nonTerminalNodeA = this.metastatementNode,  ///
             nonTerminalNodeB = statementNode,  ///
-            localContextA = intrinsicLevelLocalContext, ///
+            localContextA = LocalContext.fromFileContext(fileContextA),
             localContextB = localContext,  ///
             nonTerminalNodeVerified = intrinsicLevelAgainstMetaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
               const verifiedAhead = true;
@@ -70,10 +69,10 @@ export default class Premise {
               subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
 
         matchesSubproofNode = match(subproofAssertionMetastatementNodes, subproofStatementNodes, (subproofAssertionMetastatementNode, subproofStatementNode) => {
-          const metaLevelLocalContext = MetaLevelLocalContext.fromFileContext(fileContext),
+          const fileContextA = fileContext, ///
                 nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = subproofStatementNode, ///
-                localContextA = metaLevelLocalContext,  ///
+                localContextA = LocalContext.fromFileContext(fileContextA),
                 localContextB = localContext,  ///
                 nonTerminalNodeVerified = intrinsicLevelAgainstMetaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
                   const verifiedAhead = true;
@@ -107,10 +106,10 @@ export default class Premise {
               subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
 
         matchesRuleSubproofNode = match(subproofAssertionMetastatementNodes, ruleSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
-          const metaLevelLocalContext = MetaLevelLocalContext.fromFileContext(fileContext),
+          const fileContextA = fileContext, ///
                 nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = ruleSubproofMetastatementNode, ///
-                localContextA = metaLevelLocalContext,  ///
+                localContextA = LocalContext.fromFileContext(fileContextA),
                 localContextB = localContext,  ///
                 nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
                   const verifiedAhead = true;
@@ -144,10 +143,10 @@ export default class Premise {
               subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
 
         matchesMetaSubproofNode = match(subproofAssertionMetastatementNodes, metaSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
-          const metaLevelLocalContext = MetaLevelLocalContext.fromFileContext(fileContext),
+          const fileContextA = fileContext, ///
                 nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = ruleSubproofMetastatementNode, ///
-                localContextA = metaLevelLocalContext,  ///
+                localContextA = LocalContext.fromFileContext(fileContextA),
                 localContextB = localContext,  ///
                 nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
                   const verifiedAhead = true;
@@ -169,10 +168,10 @@ export default class Premise {
     let matchesMetastatementNode = false;
 
     if (this.metastatementNode !== null) {
-      const metaLevelLocalContext = MetaLevelLocalContext.fromFileContext(fileContext),
+      const fileContextA = fileContext, ///
             nonTerminalNodeA = this.metastatementNode,  ///
             nonTerminalNodeB = metastatementNode,  ///
-            localContextA = metaLevelLocalContext,  ///
+            localContextA = LocalContext.fromFileContext(fileContextA),
             localContextB = localContext,  ///
             nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
               const verifiedAhead = true;

package/src/verify/axiom.js

@@ -1,10 +1,10 @@
 "use strict";
 
 import Axiom from "../axiom";
+import LocalContext from "../context/local";
 import verifyLabels from "../verify/labels";
 import verifyConsequent from "../verify/consequent";
 import verifySuppositions from "../verify/suppositions";
-import IntrinsicLevelLocalContext from "../context/local/intrinsicLevel";
 
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
@@ -16,10 +16,9 @@ const labelNodesQuery = nodesQuery("/axiom/label"),
 export default function verifyAxiom(axiomNode, fileContext) {
   let axiomVerified = false;
 
-  const intrinsicLevelLocalContext = IntrinsicLevelLocalContext.fromFileContext(fileContext),
-        labelNodes = labelNodesQuery(axiomNode),
+  const labelNodes = labelNodesQuery(axiomNode),
         labelsString = fileContext.nodesAsString(labelNodes),
-        localContext = intrinsicLevelLocalContext;  ///
+        localContext = LocalContext.fromFileContext(fileContext);
 
   fileContext.trace(`Verifying the '${labelsString}' axiom...`, axiomNode);
 

package/src/verify/conjecture.js

@@ -3,9 +3,9 @@
 import Conjecture from "../conjecture";
 import verifyProof from "../verify/proof";
 import verifyLabels from "../verify/labels";
+import LocalContext from "../context/local";
 import verifyConsequent from "../verify/consequent";
 import verifySuppositions from "../verify/suppositions";
-import IntrinsicLevelLocalContext from "../context/local/intrinsicLevel";
 
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
@@ -18,10 +18,9 @@ const proofNodeQuery = nodeQuery("/conjecture/proof!"),
 export default function verifyConjecture(conjectureNode, fileContext) {
   let conjectureVerified = false;
 
-  const intrinsicLevelLocalContext = IntrinsicLevelLocalContext.fromFileContext(fileContext),
-        labelNodes = labelNodesQuery(conjectureNode),
+  const labelNodes = labelNodesQuery(conjectureNode),
         labelsString = fileContext.nodesAsString(labelNodes),
-        localContext = intrinsicLevelLocalContext;  ///
+        localContext = LocalContext.fromFileContext(fileContext);  ///
 
   fileContext.trace(`Verifying the '${labelsString}' conjecture...`, conjectureNode);
 

package/src/verify/lemma.js

@@ -3,9 +3,9 @@
 import Lemma from "../lemma";
 import verifyProof from "../verify/proof";
 import verifyLabels from "../verify/labels";
+import LocalContext from "../context/local";
 import verifyConsequent from "../verify/consequent";
 import verifySuppositions from "../verify/suppositions";
-import IntrinsicLevelLocalContext from "../context/local/intrinsicLevel";
 
 import { first } from "../utilities/array";
 import { EMPTY_STRING } from "../constants";
@@ -19,10 +19,9 @@ const proofNodeQuery = nodeQuery("/lemma/proof!"),
 export default function verifyLemma(lemmaNode, fileContext) {
   let lemmaVerified = false;
 
-  const intrinsicLevelLocalContext = IntrinsicLevelLocalContext.fromFileContext(fileContext),
-        labelNodes = labelNodesQuery(lemmaNode),
+  const labelNodes = labelNodesQuery(lemmaNode),
         labelsString = fileContext.nodesAsString(labelNodes),
-        localContext = intrinsicLevelLocalContext;  ///
+        localContext = LocalContext.fromFileContext(fileContext);
 
   (labelsString === EMPTY_STRING) ?
     fileContext.trace(`Verifying a lemma...`, lemmaNode) :