occam-verify-cli 0.0.923 → 0.0.924

package/src/context/local.js

@@ -305,8 +305,8 @@ class LocalContext {
     return judgementPresent;
   }
 
-  isMetavariablePresentByMetavariableNode(metavariableNode, localContext) {
-    const metavariable = this.findMetavariableByMetavariableNode(metavariableNode, localContext),
+  isMetavariablePresentByMetavariableNode(metavariableNode) {
+    const metavariable = this.findMetavariableByMetavariableNode(metavariableNode),
           metavariablePresent = (metavariable !== null);
 
     return metavariablePresent;
@@ -339,8 +339,9 @@ class LocalContext {
     return judgement;
   }
 
-  findMetavariableByMetavariableNode(metavariableNode, localContext) {
+  findMetavariableByMetavariableNode(metavariableNode) {
     const node = metavariableNode,  ///
+          localContext = this,  ///
           metavariables = this.getMetavariables(),
           metavariable = metavariables.find((metavariable) => {
             const matches = metavariable.matchNode(node, localContext);

package/src/lemma.js

@@ -1,9 +1,9 @@
 "use strict";
 
-import AxiomLemmaTheoremConjecture from "./axiomLemmaTheoremConjecture";
+import TopLevelAssertion from "./topLevelAssertion";
 
-export default class Lemma extends AxiomLemmaTheoremConjecture {
-  static fromJSONAndFileContext(json, fileContext) { return AxiomLemmaTheoremConjecture.fromJSONAndFileContext(Lemma,json, fileContext); }
+export default class Lemma extends TopLevelAssertion {
+  static fromJSONAndFileContext(json, fileContext) { return TopLevelAssertion.fromJSONAndFileContext(Lemma,json, fileContext); }
 
-  static fromLabelsSuppositionsConsequentAndLocalContext(labels, suppositions, consequent, localContext) { return AxiomLemmaTheoremConjecture.fromLabelsSuppositionsConsequentAndLocalContext(Lemma, labels, suppositions, consequent, localContext); }
+  static fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext) { return TopLevelAssertion.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(Lemma, labels, suppositions, consequent, substitutions, fileContext); }
 }

package/src/metaLemma.js

@@ -1,9 +1,9 @@
 "use strict";
 
-import MetalemmaMetatheorem from "./metalemmaMetatheorem";
+import TopLevelAssertion from "./topLevelAssertion";
 
-export default class MetaLemma extends MetalemmaMetatheorem {
-  static fromJSONAndFileContext(json, fileContext) { return MetalemmaMetatheorem.fromJSONAndFileContext(MetaLemma, json, fileContext); }
+export default class MetaLemma extends TopLevelAssertion {
+  static fromJSONAndFileContext(json, fileContext) { return TopLevelAssertion.fromJSONAndFileContext(MetaLemma, json, fileContext); }
 
-  static fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(labels, metaSuppositions, metaConsequent, substitutions, fileContext) { return MetalemmaMetatheorem.fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(MetaLemma, labels, metaSuppositions, metaConsequent, substitutions, fileContext); }
+  static fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(labels, metaSuppositions, metaConsequent, substitutions, fileContext) { return TopLevelAssertion.fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(MetaLemma, labels, metaSuppositions, metaConsequent, substitutions, fileContext); }
 }

package/src/metatheorem.js

@@ -1,9 +1,9 @@
 "use strict";
 
-import MetaLemmaMetatheorem from "./metaLemmaMetatheorem";
+import TopLevelAssertion from "./topLevelAssertion";
 
-export default class Metatheorem extends MetaLemmaMetatheorem {
-  static fromJSONAndFileContext(json, fileContext) { return MetaLemmaMetatheorem.fromJSONAndFileContext(Metatheorem, json, fileContext); }
+export default class Metatheorem extends TopLevelAssertion {
+  static fromJSONAndFileContext(json, fileContext) { return TopLevelAssertion.fromJSONAndFileContext(Metatheorem, json, fileContext); }
 
-  static fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, fileContext) { return MetaLemmaMetatheorem.fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(Metatheorem, labels, suppositions, consequent, fileContext); }
+  static fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, fileContext) { return TopLevelAssertion.fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(Metatheorem, labels, suppositions, consequent, fileContext); }
 }

package/src/metavariable.js

@@ -36,6 +36,12 @@ export default class Metavariable {
     return this.metaType;
   }
 
+  getMetaTypeName() {
+    const metaTypeName = this.metaType.getName();
+
+    return metaTypeName;
+  }
+
   matchName(name) {
     const matchesName = (this.name === name);
 

package/src/theorem.js

@@ -1,9 +1,9 @@
 "use strict";
 
-import AxiomLemmaTheoremConjecture from "./axiomLemmaTheoremConjecture";
+import TopLevelAssertion from "./topLevelAssertion";
 
-export default class Theorem extends AxiomLemmaTheoremConjecture {
-  static fromJSONAndFileContext(json, fileContext) { return AxiomLemmaTheoremConjecture.fromJSONAndFileContext(Theorem, json, fileContext); }
+export default class Theorem extends TopLevelAssertion {
+  static fromJSONAndFileContext(json, fileContext) { return TopLevelAssertion.fromJSONAndFileContext(Theorem, json, fileContext); }
 
-  static fromLabelsSuppositionsConsequentAndLocalContext(labels, suppositions, consequent, localContext) { return AxiomLemmaTheoremConjecture.fromLabelsSuppositionsConsequentAndLocalContext(Theorem, labels, suppositions, consequent, localContext); }
+  static fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext) { return TopLevelAssertion.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(Theorem, labels, suppositions, consequent, substitutions, fileContext); }
 }

package/src/{metaLemmaMetatheorem.js → topLevelAssertion.js}

@@ -7,7 +7,7 @@ import StatementForMetavariableSubstitution from "./substitution/statementForMet
 
 import { reverse, correlate } from "./utilities/array";
 
-export default class MetaLemmaMetatheorem {
+export default class TopLevelAssertion {
   constructor(labels, suppositions, consequent, substitutions, fileContext) {
     this.labels = labels;
     this.suppositions = suppositions;
@@ -39,9 +39,9 @@ export default class MetaLemmaMetatheorem {
   matchStatement(statementNode, localContext) {
     let statementNatches = false;
 
-    const metaproofSteps = localContext.getProofSteps(),
+    const proofSteps = localContext.getProofSteps(),
           substitutions = [],
-          suppositionsMatch = matchSuppositions(this.suppositions, metaproofSteps, substitutions, this.fileContext, localContext);
+          suppositionsMatch = matchSuppositions(this.suppositions, proofSteps, substitutions, this.fileContext, localContext);
 
     if (suppositionsMatch) {
       const consequentMatches = matchConsequent(this.consequent, statementNode, substitutions, this.fileContext, localContext);
@@ -77,22 +77,19 @@ export default class MetaLemmaMetatheorem {
           }),
           consequentJSON = this.consequent.toJSON(tokens),
           substitutionsJSON = this.substitutions.map((substitution) => {
-            const substitutionJSON = substitution.toJSON();
+        const substitutionJSON = substitution.toJSON();
 
-            return substitutionJSON;
-          }),
-          localContextJSON = this.fileContext.toJSON(tokens),
+        return substitutionJSON;
+      }),
           labels = labelsJSON,  ///
           suppositions = suppositionsJSON,  ///
           consequent = consequentJSON,  ///
           substitutions = substitutionsJSON,  ///
-          fileContext = localContextJSON,  ///
           json = {
             labels,
             suppositions,
             consequent,
-            substitutions,
-            fileContext
+            substitutions
           };
 
     return json;
@@ -143,13 +140,13 @@ export default class MetaLemmaMetatheorem {
   static fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(Class, labels, suppositions, consequent, substitutions, fileContext) { return new Class(labels, suppositions, consequent, substitutions, fileContext); }
 }
 
-function matchSuppositions(suppositions, metaproofSteps, substitutions, fileContext, localContext) {
+function matchSuppositions(suppositions, proofSteps, substitutions, fileContext, localContext) {
   suppositions = reverse(suppositions); ///
 
-  metaproofSteps = reverse(metaproofSteps); ///
+  proofSteps = reverse(proofSteps); ///
 
-  const suppositionsMatch = correlate(suppositions, metaproofSteps, (supposition, metaproofStep) => {
-    const suppositionMatches = matchSupposition(supposition, metaproofStep, substitutions, fileContext, localContext);
+  const suppositionsMatch = correlate(suppositions, proofSteps, (supposition, proofStep) => {
+    const suppositionMatches = matchSupposition(supposition, proofStep, substitutions, fileContext, localContext);
 
     if (suppositionMatches) {
       return true;
@@ -159,25 +156,18 @@ function matchSuppositions(suppositions, metaproofSteps, substitutions, fileCont
   return suppositionsMatch;
 }
 
-function matchSupposition(supposition, metaproofStep, substitutions, fileContext, localContext) {
-  let matchesSupposition = false;
-
-  const metaSubproofNode = metaproofStep.getSubproofNode(),
-        statementNode = metaproofStep.getStatementNode();
+function matchSupposition(supposition, proofStep, substitutions, fileContext, localContext) {
+  let suppositionMatches = false;
 
-  if (metaSubproofNode !== null) {
-    const suppositionMatchesSubproofNode = supposition.matchSubproofNode(metaSubproofNode, substitutions, fileContext, localContext);
-
-    matchesSupposition - suppositionMatchesSubproofNode; ///
-  }
+  const statementNode = proofStep.getStatementNode();
 
   if (statementNode !== null) {
     const suppositionMatchesStatementNode = supposition.matchStatementNode(statementNode, substitutions, fileContext, localContext);
 
-    matchesSupposition - suppositionMatchesStatementNode; ///
+    suppositionMatches = suppositionMatchesStatementNode;  ///
   }
 
-  return matchesSupposition;
+  return suppositionMatches;
 }
 
 function matchConsequent(consequent, statementNode, substitutions, fileContext, localContext) {

package/src/verify/axiom.js

@@ -17,8 +17,7 @@ export default function verifyAxiom(axiomNode, fileContext) {
   let axiomVerified = false;
 
   const labelNodes = labelNodesQuery(axiomNode),
-        labelsString = fileContext.nodesAsString(labelNodes),
-        localContext = LocalContext.fromFileContext(fileContext);
+        labelsString = fileContext.nodesAsString(labelNodes);
 
   fileContext.trace(`Verifying the '${labelsString}' axiom...`, axiomNode);
 
@@ -26,7 +25,8 @@ export default function verifyAxiom(axiomNode, fileContext) {
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
-    const suppositions = [],
+    const localContext = LocalContext.fromFileContext(fileContext),
+          suppositions = [],
           suppositionNodes = suppositionsNodeQuery(axiomNode),
           suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
 
@@ -38,7 +38,8 @@ export default function verifyAxiom(axiomNode, fileContext) {
       if (consequentVerified) {
         const firstConsequent = first(consequents),
               consequent = firstConsequent, ///
-              axiom = Axiom.fromLabelsSuppositionsConsequentAndLocalContext(labels, suppositions, consequent, localContext);
+              substitutions = [],
+              axiom = Axiom.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext);
 
         fileContext.addAxiom(axiom);
 

package/src/verify/conjecture.js

@@ -19,8 +19,7 @@ export default function verifyConjecture(conjectureNode, fileContext) {
   let conjectureVerified = false;
 
   const labelNodes = labelNodesQuery(conjectureNode),
-        labelsString = fileContext.nodesAsString(labelNodes),
-        localContext = LocalContext.fromFileContext(fileContext);  ///
+        labelsString = fileContext.nodesAsString(labelNodes);
 
   fileContext.trace(`Verifying the '${labelsString}' conjecture...`, conjectureNode);
 
@@ -28,7 +27,8 @@ export default function verifyConjecture(conjectureNode, fileContext) {
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
-    const suppositions = [],
+    const localContext = LocalContext.fromFileContext(fileContext),
+          suppositions = [],
           suppositionNodes = suppositionsNodeQuery(conjectureNode),
           suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
 
@@ -46,7 +46,8 @@ export default function verifyConjecture(conjectureNode, fileContext) {
           verifyProof(proofNode, consequent, localContext);
         }
 
-        const conjecture = Conjecture.fromLabelsSuppositionsConsequentAndLocalContext(labels, suppositions, consequent, localContext);
+        const substitutions = [],
+              conjecture = Conjecture.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext);
 
         fileContext.addConjecture(conjecture);
 

package/src/verify/{statementAsContainedAssertion.js → containedAssertion.js}

@@ -2,23 +2,21 @@
 
 import metaLevelNodeVerifier from "../verifier/node/metaLevel";
 
-import { CONTAINED } from "../constants";
 import { isStatementNegated } from "../utilities/verify";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const termNodeQuery = nodeQuery("/statement/term!"),
-      statementTermNodesQuery = nodesQuery("/statement/metaArgument/statement//term"),
-      operatorTerminalNodesQuery = nodesQuery("/statement/@operator");
+      statementTermNodesQuery = nodesQuery("/statement/metaArgument/statement//term");
 
-export default function verifyStatementAsContainedAssertion(statementNode, assignments, derived, localContext) {
+export default function verifyContainedAssertion(containedAssertionNode, assignments, derived, localContext) {
   let statementVerifiedAsContainedAssertion;
 
-  const statementContainedAssertion = isStatementContainedAssertion(statementNode);
+  const statementContainedAssertion = isStatementContainedAssertion(containedAssertionNode);
 
   if (statementContainedAssertion) {
-    const statementString = localContext.nodeAsString(statementNode);
+    const containedAssertionString = localContext.nodeAsString(containedAssertionNode);
 
-    localContext.trace(`Verifying the '${statementString}' statement as a contained assertion...`, statementNode);
+    localContext.trace(`Verifying the '${containedAssertionString}' statement as a contained assertion...`, containedAssertionNode);
 
     const statementFunctions = [
       verifyStatementAsDerivedContainedAssertion,
@@ -26,7 +24,7 @@ export default function verifyStatementAsContainedAssertion(statementNode, assig
     ];
 
     statementVerifiedAsContainedAssertion = statementFunctions.some((statementFunction) => {
-      const statementVerifiedAsContainedAssertion = statementFunction(statementNode, assignments, derived, localContext);
+      const statementVerifiedAsContainedAssertion = statementFunction(containedAssertionNode, assignments, derived, localContext);
 
       if (statementVerifiedAsContainedAssertion) {
         return true;
@@ -34,25 +32,25 @@ export default function verifyStatementAsContainedAssertion(statementNode, assig
     });
 
     if (statementVerifiedAsContainedAssertion) {
-      localContext.debug(`...verified the '${statementString}' statement as a contained assertion.`, statementNode);
+      localContext.debug(`...verified the '${containedAssertionString}' statement as a contained assertion.`, containedAssertionNode);
     }
   }
 
   return statementVerifiedAsContainedAssertion;
 }
 
-function verifyStatementAsDerivedContainedAssertion(statementNode, assignments, derived, localContext) {
+function verifyStatementAsDerivedContainedAssertion(containedAssertionNode, assignments, derived, localContext) {
   let statementVerifiedAsDefinedContainedAssertion = false;
 
   if (derived) {
-    const statementString = localContext.nodeAsString(statementNode);
+    const containedAssertionString = localContext.nodeAsString(containedAssertionNode);
 
-    localContext.trace(`Verifying the derived '${statementString}' statement as a contained assertion...`, statementNode);
+    localContext.trace(`Verifying the '${containedAssertionString}' derived statement as a contained assertion...`, containedAssertionNode);
 
-    const statementNegated = isStatementNegated(statementNode),
-          termNode = termNodeQuery(statementNode),
+    const statementNegated = isStatementNegated(containedAssertionNode),
+          termNode = termNodeQuery(containedAssertionNode),
           negated = statementNegated, ///
-          statementTermNodes = statementTermNodesQuery(statementNode),
+          statementTermNodes = statementTermNodesQuery(containedAssertionNode),
           termNodeMatchesMetaArgumentVariableNode = statementTermNodes.some((statementTermNode) => {
             const termNodeMatchesMetaArgumentVariableNode = termNode.match(statementTermNode);
 
@@ -74,27 +72,27 @@ function verifyStatementAsDerivedContainedAssertion(statementNode, assignments,
     }
 
     if (statementVerifiedAsDefinedContainedAssertion) {
-      localContext.debug(`...verified the derived '${statementString}' statement as a contained assertion.`, statementNode);
+      localContext.debug(`...verified the '${containedAssertionString}' derived statement as a contained assertion.`, containedAssertionNode);
     }
   }
 
   return statementVerifiedAsDefinedContainedAssertion;
 }
 
-function verifyStatementAsStatedContainedAssertion(statementNode, assignments, derived, localContext) {
+function verifyStatementAsStatedContainedAssertion(containedAssertionNode, assignments, derived, localContext) {
   let statementVerifiedAsStatedContainedAssertion = false;
 
   if (!derived) {
-    const statementString = localContext.nodeAsString(statementNode);
+    const containedAssertionString = localContext.nodeAsString(containedAssertionNode);
 
-    localContext.trace(`Verifying the stated '${statementString}' statement as a contained assertion...`, statementNode);
+    localContext.trace(`Verifying the '${containedAssertionString}' stated statement as a contained assertion...`, containedAssertionNode);
 
     const intrinsicLevel = localContext.isIntrinsicLevel();
 
     if (intrinsicLevel) {
-      localContext.debug(`The stated '${statementString}' statement as a contained assertion cannot be verified at intrinsic level.`, statementNode);
+      localContext.debug(`The '${containedAssertionString}' stated statement as a contained assertion cannot be verified at intrinsic level.`, containedAssertionNode);
     } else {
-      const nonTerminalNode = statementNode, ///
+      const nonTerminalNode = containedAssertionNode, ///
             nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
               const verifiedAhead = true;
 
@@ -105,23 +103,9 @@ function verifyStatementAsStatedContainedAssertion(statementNode, assignments, d
     }
 
     if (statementVerifiedAsStatedContainedAssertion) {
-      localContext.debug(`...verified the stated '${statementString}' statement as a contained assertion.`, statementNode);
+      localContext.debug(`...verified the '${containedAssertionString}' stated statement as a contained assertion.`, containedAssertionNode);
     }
   }
 
   return statementVerifiedAsStatedContainedAssertion;
 }
-
-export function isStatementContainedAssertion(statementNode) {
-  const operatorTerminalNodes = operatorTerminalNodesQuery(statementNode),
-        statementContainedAssertion = operatorTerminalNodes.some((operatorTerminalNode) => {
-          const content = operatorTerminalNode.getContent(),
-                contentContained = (content === CONTAINED);
-
-          if (contentContained) {
-            return true;
-          }
-        });
-
-  return statementContainedAssertion;
-}

package/src/verify/declaration.js

@@ -57,7 +57,7 @@ function verifyReference(referenceNode, localContext) {
   localContext.trace(`Verifying the '${referenceString}' reference...`, referenceNode);
 
   const metavariableNode = metavariableNodeQuery(referenceNode),
-        metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode, localContext);
+        metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode);
 
   if (metavariable !== null) {
     const metaType = metavariable.getMetaType();

package/src/verify/{statementAsDefinedAssertion.js → definedAssertion.js}

@@ -5,22 +5,21 @@ import metaLevelNodeVerifier from "../verifier/node/metaLevel";
 
 import { first } from "../utilities/array";
 import { DEFINED } from "../constants";
-import { isStatementNegated } from "../utilities/verify";
-import { nodeQuery, nodesQuery } from "../utilities/query";
+import { nodeQuery } from "../utilities/query";
+import { isAssertionNegated } from "../utilities/verify";
 
 const termNodeQuery = nodeQuery("/statement/term!"),
-      variableNodeQuery = nodeQuery("/statement/term/variable!"),
-      operatorTerminalNodesQuery = nodesQuery("/statement/@operator");
+      variableNodeQuery = nodeQuery("/statement/term/variable!");
 
-export default function verifyStatementAsDefinedAssertion(statementNode, assignments, derived, localContext) {
+export default function verifyDefinedAssertion(definedAssertionNode, assignments, derived, localContext) {
   let statementVerifiedAsDefinedAssertion = false;
 
-  const statementDefinedAssertion = isStatementDefinedAssertion(statementNode);
+  const statementDefinedAssertion = isStatementDefinedAssertion(definedAssertionNode);
 
   if (statementDefinedAssertion) {
-    const statementString = localContext.nodeAsString(statementNode);
+    const definedAssertionString = localContext.nodeAsString(definedAssertionNode);
 
-    localContext.trace(`Verifying the '${statementString}' statement as a defined assertion...`, statementNode);
+    localContext.trace(`Verifying the '${definedAssertionString}' statement as a defined assertion...`, definedAssertionNode);
 
     const definedAssertionFunctions = [
       verifyDerivedStatementAsDefinedAssertion,
@@ -28,7 +27,7 @@ export default function verifyStatementAsDefinedAssertion(statementNode, assignm
     ];
 
     statementVerifiedAsDefinedAssertion = definedAssertionFunctions.some((definedAssertionFunction) => {
-      const statementVerifiedAsDefinedAssertion = definedAssertionFunction(statementNode, assignments, derived, localContext);
+      const statementVerifiedAsDefinedAssertion = definedAssertionFunction(definedAssertionNode, assignments, derived, localContext);
 
       if (statementVerifiedAsDefinedAssertion) {
         return true;
@@ -36,24 +35,24 @@ export default function verifyStatementAsDefinedAssertion(statementNode, assignm
     });
 
     if (statementVerifiedAsDefinedAssertion) {
-      localContext.debug(`...verified the '${statementString}' statement as a defined assertion.`, statementNode);
+      localContext.debug(`...verified the '${definedAssertionString}' statement as a defined assertion.`, definedAssertionNode);
     }
   }
 
   return statementVerifiedAsDefinedAssertion;
 }
 
-function verifyDerivedStatementAsDefinedAssertion(statementNode, assignments, derived, localContext) {
+function verifyDerivedStatementAsDefinedAssertion(definedAssertionNode, assignments, derived, localContext) {
   let derivedStatementVerifiedAsDefeindAssertion = false;
 
   if (derived) {
-    const statementString = localContext.nodeAsString(statementNode);
+    const definedAssertionString = localContext.nodeAsString(definedAssertionNode);
 
-    localContext.trace(`Verifying the derived '${statementString}' statement as a defined assertion...`, statementNode);
+    localContext.trace(`Verifying the '${definedAssertionString}' derived statement as a defined assertion...`, definedAssertionNode);
 
-    const statementNegated = isStatementNegated(statementNode),
-          variableNode = variableNodeQuery(statementNode),
-          termNode = termNodeQuery(statementNode);
+    const statementNegated = isAssertionNegated(definedAssertionNode),
+          variableNode = variableNodeQuery(definedAssertionNode),
+          termNode = termNodeQuery(definedAssertionNode);
 
     if (false) {
       ///
@@ -103,27 +102,27 @@ function verifyDerivedStatementAsDefinedAssertion(statementNode, assignments, de
     }
 
     if (derivedStatementVerifiedAsDefeindAssertion) {
-      localContext.debug(`...verified the derived '${statementString}' statement as a defined assertion.`, statementNode);
+      localContext.debug(`...verified the '${definedAssertionString}' derived statement as a defined assertion.`, definedAssertionNode);
     }
   }
 
   return derivedStatementVerifiedAsDefeindAssertion;
 }
 
-function verifyStatedStatementAsDefinedAssertion(statementNode, assignments, derived, localContext) {
+function verifyStatedStatementAsDefinedAssertion(definedAssertionNode, assignments, derived, localContext) {
   let statedStatementVerifiedAsDefinedAssertion = false;
 
   if (!derived) {
-    const statementString = localContext.nodeAsString(statementNode);
+    const definedAssertionString = localContext.nodeAsString(definedAssertionNode);
 
-    localContext.trace(`Verifying the stated '${statementString}' statement as a defined assertion...`, statementNode);
+    localContext.trace(`Verifying the '${definedAssertionString}' stated statement as a defined assertion...`, definedAssertionNode);
 
     const intrinsicLevel = localContext.isIntrinsicLevel();
 
     if (intrinsicLevel) {
-      localContext.debug(`The stated '${statementString}' statement as a defined assertion cannot be verified at intrinsic level.`, statementNode);
+      localContext.debug(`The '${definedAssertionString}' stated statement as a defined assertion cannot be verified at intrinsic level.`, definedAssertionNode);
     } else {
-      const nonTerminalNode = statementNode, ///
+      const nonTerminalNode = definedAssertionNode, ///
             nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
               const verifiedAhead = true;
 
@@ -134,23 +133,9 @@ function verifyStatedStatementAsDefinedAssertion(statementNode, assignments, der
     }
 
     if (statedStatementVerifiedAsDefinedAssertion) {
-      localContext.debug(`...verified the stated '${statementString}' statement as a defined assertion.`, statementNode);
+      localContext.debug(`...verified the '${definedAssertionString}' stated statement as a defined assertion.`, definedAssertionNode);
     }
   }
 
   return statedStatementVerifiedAsDefinedAssertion;
 }
-
-export function isStatementDefinedAssertion(statementNode) {
-  const operatorTerminalNodes = operatorTerminalNodesQuery(statementNode),
-        statementDefinedAssertion = operatorTerminalNodes.some((operatorTerminalNode) => {
-          const content = operatorTerminalNode.getContent(),
-                contentDefined = (content === DEFINED);
-
-          if (contentDefined) {
-            return true;
-          }
-        });
-
-  return statementDefinedAssertion;
-}

package/src/verify/derivation.js

@@ -6,18 +6,18 @@ import { nodesQuery } from "../utilities/query";
 
 const proofStepNodesQuery = nodesQuery("/derivation/proofStep|lastProofStep");
 
-export default function verifyDerivation(ruleDerivationNode, localContext) {
-  let ruleDerivationVerified;
+export default function verifyDerivation(derivationNode, substitutions, localContext) {
+  let derivationVerified;
 
-  const proofStepNodes = proofStepNodesQuery(ruleDerivationNode);
+  const proofStepNodes = proofStepNodesQuery(derivationNode);
 
-  ruleDerivationVerified = proofStepNodes.every((proofStepNode) => {
-    const proofStepVerified = verifyProofStep(proofStepNode, localContext);
+  derivationVerified = proofStepNodes.every((proofStepNode) => {
+    const proofStepVerified = verifyProofStep(proofStepNode, substitutions, localContext);
 
     if (proofStepVerified) {
       return true;
     }
   });
 
-  return ruleDerivationVerified;
+  return derivationVerified;
 }

package/src/verify/frame.js

@@ -56,7 +56,7 @@ function verifyMetavariable(metavariableNode, declarations, localContext) {
 
   localContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
 
-  const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode, localContext);
+  const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode);
 
   if (metavariable !== null) {
     const metaType = metavariable.getMetaType();

package/src/verify/judgement.js

@@ -144,7 +144,7 @@ function verifyMetavariable(metavariableNode, localContext) {
 
   localContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
 
-  const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode, localContext);
+  const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode);
 
   if (metavariable !== null) {
     const metaType = metavariable.getMetaType();

package/src/verify/lemma.js

@@ -20,8 +20,7 @@ export default function verifyLemma(lemmaNode, fileContext) {
   let lemmaVerified = false;
 
   const labelNodes = labelNodesQuery(lemmaNode),
-        labelsString = fileContext.nodesAsString(labelNodes),
-        localContext = LocalContext.fromFileContext(fileContext);
+        labelsString = fileContext.nodesAsString(labelNodes);
 
   (labelsString === EMPTY_STRING) ?
     fileContext.trace(`Verifying a lemma...`, lemmaNode) :
@@ -31,7 +30,8 @@ export default function verifyLemma(lemmaNode, fileContext) {
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
-    const suppositions = [],
+    const localContext = LocalContext.fromFileContext(fileContext),
+          suppositions = [],
           suppositionNodes = suppositionsNodeQuery(lemmaNode),
           suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
 
@@ -44,10 +44,13 @@ export default function verifyLemma(lemmaNode, fileContext) {
         const proofNode = proofNodeQuery(lemmaNode),
               firstConsequent = first(consequents),
               consequent = firstConsequent, ///
-              proofVerified = verifyProof(proofNode, consequent, localContext);
+              statementNode = consequent.getStatementNode(),
+              substitutions = [],
+              proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);
 
         if (proofVerified) {
-          const lemma = Lemma.fromLabelsSuppositionsConsequentAndLocalContext(labels, suppositions, consequent, localContext);
+          const substitutions = [],
+                lemma = Lemma.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext);
 
           fileContext.addLemma(lemma);
 

package/src/verify/metaLemma.js

@@ -30,22 +30,22 @@ export default function verifyMetaLemma(metaLemmaNode, fileContext) {
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
-    const localContext = LocalContext.fromFileContext(fileContext), ///
-          substitutions = [],
+    const localContext = LocalContext.fromFileContext(fileContext),
           suppositions = [],
           suppositionNodes = suppositionsNodeQuery(metaLemmaNode),
-          suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, substitutions, localContext);
+          suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
 
     if (suppositionsVerified) {
       const consequents = [],
             consequentNode = consequentNodeQuery(metaLemmaNode),
-            consequentVerified = verifyConsequent(consequentNode, consequents, substitutions, localContext);
+            consequentVerified = verifyConsequent(consequentNode, consequents, localContext);
 
       if (consequentVerified) {
         const proofNode = proofNodeQuery(metaLemmaNode),
               firstConsequent = first(consequents),
               consequent = firstConsequent, ///
               statementNode = consequent.getStatementNode(),
+              substitutions = [],
               proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);
 
         if (proofVerified) {