occam-verify-cli 0.0.874 → 0.0.876

package/src/metaLemmaMetatheorem.js

@@ -1,19 +1,19 @@
 "use strict";
 
 import Label from "./label";
-import LocalContext from "./context/local";
 import MetaConsequent from "./metaConsequent";
 import MetaSupposition from "./metaSupposition";
+import LocalMetaContext from "./context/localMeta";
 
 import { prune } from "./utilities/array";
 import { someSubArray } from "./utilities/array";
 
 export default class MetaLemmaMetatheorem {
-  constructor(labels, metaSuppositions, metaConsequent, localContext) {
+  constructor(labels, metaSuppositions, metaConsequent, fileContext) {
     this.labels = labels;
     this.metaSuppositions = metaSuppositions;
     this.metaConsequent = metaConsequent;
-    this.localContext = localContext;
+    this.fileContext = fileContext;
   }
 
   getLabels() {
@@ -28,8 +28,8 @@ export default class MetaLemmaMetatheorem {
     return this.metaConsequent;
   }
 
-  getLocalContext() {
-    return this.localContext;
+  getFileContext() {
+    return this.fileContext;
   }
 
   matchMetastatement(metastatementNode, metastatementLocalContext) {
@@ -39,7 +39,7 @@ export default class MetaLemmaMetatheorem {
 
     if (metaSuppositionsLength === 0) {
       const substitutions = [],
-            metaConsequentMatches = matchMetaConsequent(this.metaConsequent, metastatementNode, substitutions, this.localContext, metastatementLocalContext);
+            metaConsequentMatches = matchMetaConsequent(this.metaConsequent, metastatementNode, substitutions, this.fileContext, metastatementLocalContext);
 
       metastatementNatches = metaConsequentMatches; ///
     } else {
@@ -49,10 +49,10 @@ export default class MetaLemmaMetatheorem {
         let metaSuppositionsMatchMetaConsequent = false;
 
         const substitutions = [],
-              metaSuppositionsMatch = matchMetaSuppositions(this.metaSuppositions, metaproofSteps, substitutions, this.localContext, metastatementLocalContext);
+              metaSuppositionsMatch = matchMetaSuppositions(this.metaSuppositions, metaproofSteps, substitutions, this.fileContext, metastatementLocalContext);
 
         if (metaSuppositionsMatch) {
-          const metaConsequentMatches = matchMetaConsequent(this.metaConsequent, metastatementNode, substitutions, this.localContext, metastatementLocalContext);
+          const metaConsequentMatches = matchMetaConsequent(this.metaConsequent, metastatementNode, substitutions, this.fileContext, metastatementLocalContext);
 
           metaSuppositionsMatchMetaConsequent = metaConsequentMatches;  ///
         }
@@ -91,16 +91,16 @@ export default class MetaLemmaMetatheorem {
             return metaSuppositionJSON;
           }),
           metaConsequentJSON = this.metaConsequent.toJSON(tokens),
-          localContextJSON = this.localContext.toJSON(tokens),
+          localContextJSON = this.fileContext.toJSON(tokens),
           labels = labelsJSON,  ///
           metaSuppositions = metaSuppositionsJSON,  ///
           metaConsequent = metaConsequentJSON,  ///
-          localContext = localContextJSON,  ///
+          fileContext = localContextJSON,  ///
           json = {
             labels,
             metaSuppositions,
             metaConsequent,
-            localContext
+            fileContext
           };
 
     return json;
@@ -118,7 +118,7 @@ export default class MetaLemmaMetatheorem {
       return label;
     });
 
-    let { metaSuppositions, metaConsequent, localContext } = json;
+    let { metaSuppositions, metaConsequent } = json;
 
     const metaSuppositionsJSON = metaSuppositions;  ///
 
@@ -135,25 +135,19 @@ export default class MetaLemmaMetatheorem {
 
     metaConsequent = MetaConsequent.fromJSONAndFileContext(json, fileContext);
 
-    const localContextJSON = localContext;  ///
-
-    json = localContextJSON;  ///
-
-    localContext = LocalContext.fromJSONAndFileContext(json, fileContext);
-
-    return new Class(labels, metaSuppositions, metaConsequent, localContext);  ///
+    return new Class(labels, metaSuppositions, metaConsequent, fileContext);  ///
   }
 
-  static fromLabelsMetaSuppositionsMetaConsequentAndLocalContext(Class, labels, metaSuppositions, metaConsequent, localContext) { return new Class(labels, metaSuppositions, metaConsequent, localContext); }
+  static fromLabelsMetaSuppositionsMetaConsequentAndFileContext(Class, labels, metaSuppositions, metaConsequent, fileContext) { return new Class(labels, metaSuppositions, metaConsequent, fileContext); }
 }
 
-function matchMetaSupposition(metaSupposition, metaproofSteps, substitutions, localContext, metastatementLocalContext) {
+function matchMetaSupposition(metaSupposition, metaproofSteps, substitutions, fileContext, metastatementLocalContext) {
   const metaproofStep = prune(metaproofSteps, (metaproofStep) => {
     const metaSubproofNode = metaproofStep.getMetaSubproofNode(),
           metastatementNode = metaproofStep.getMetastatementNode();
 
     if (metaSubproofNode !== null) {
-      const metaSubProofMatches = metaSupposition.matchMetaSubproofNode(metaSubproofNode, substitutions, localContext, metastatementLocalContext);
+      const metaSubProofMatches = metaSupposition.matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, metastatementLocalContext);
 
       if (!metaSubProofMatches) {  ///
         return true;
@@ -161,7 +155,7 @@ function matchMetaSupposition(metaSupposition, metaproofSteps, substitutions, lo
     }
 
     if (metastatementNode !== null) {
-      const metastatementMatches = metaSupposition.matchMetastatementNode(metastatementNode, substitutions, localContext, metastatementLocalContext);
+      const metastatementMatches = metaSupposition.matchMetastatementNode(metastatementNode, substitutions, fileContext, metastatementLocalContext);
 
       if (!metastatementMatches) {  ///
         return true;
@@ -174,9 +168,9 @@ function matchMetaSupposition(metaSupposition, metaproofSteps, substitutions, lo
   return metaSuppositionMatches;
 }
 
-function matchMetaSuppositions(metaSuppositions, metaproofSteps, substitutions, localContext, metastatementLocalContext) {
+function matchMetaSuppositions(metaSuppositions, metaproofSteps, substitutions, fileContext, metastatementLocalContext) {
   const metaSuppositionsMatch = metaSuppositions.every((metaSupposition) => {
-    const metaSuppositionMatches = matchMetaSupposition(metaSupposition, metaproofSteps, substitutions, localContext, metastatementLocalContext);
+    const metaSuppositionMatches = matchMetaSupposition(metaSupposition, metaproofSteps, substitutions, fileContext, metastatementLocalContext);
 
     if (metaSuppositionMatches) {
       return true;
@@ -186,8 +180,8 @@ function matchMetaSuppositions(metaSuppositions, metaproofSteps, substitutions,
   return metaSuppositionsMatch;
 }
 
-function matchMetaConsequent(metaConsequent, metastatementNode, substitutions, localContext, metastatementLocalContext) {
-  const nonTerminalNodeMatches = metaConsequent.matchMetastatementNode(metastatementNode, substitutions, localContext, metastatementLocalContext),
+function matchMetaConsequent(metaConsequent, metastatementNode, substitutions, fileContext, metastatementLocalContext) {
+  const nonTerminalNodeMatches = metaConsequent.matchMetastatementNode(metastatementNode, substitutions, fileContext, metastatementLocalContext),
         metaConsequentMatches = nonTerminalNodeMatches; ///
 
   return metaConsequentMatches;

package/src/metatheorem.js

@@ -5,5 +5,5 @@ import MetaLemmaMetatheorem from "./metaLemmaMetatheorem";
 export default class Metatheorem extends MetaLemmaMetatheorem {
   static fromJSONAndFileContext(json, fileContext) { return MetaLemmaMetatheorem.fromJSONAndFileContext(Metatheorem, json, fileContext); }
 
-  static fromLabelsMetaSuppositionsMetaConsequentAndLocalMetaContext(labels, suppositions, consequent, localMetaContext) { return MetaLemmaMetatheorem.fromLabelsMetaSuppositionsMetaConsequentAndLocalMetaContext(Metatheorem, labels, suppositions, consequent, localMetaContext); }
+  static fromLabelsMetaSuppositionsMetaConsequentAndFileContext(labels, suppositions, consequent, fileContext) { return MetaLemmaMetatheorem.fromLabelsMetaSuppositionsMetaConsequentAndFileContext(Metatheorem, labels, suppositions, consequent, fileContext); }
 }

package/src/metavariable.js

@@ -1,12 +1,17 @@
 "use strict";
 
+import verifyTerm from "./verify/term";
+import LocalContext from "./context/local";
+
+import { first } from "./utilities/array";
 import { nodeQuery } from "./utilities/query";
 import { nodeAsString } from "./utilities/string";
 import { nameFromMetavariableNode } from "./utilities/name";
 import { metaTypeFromJSONAndFileContext } from "./metaType";
 import { metavariableNodeFromMetavariableString } from "./utilities/node";
 
-const typeNodeQuery = nodeQuery("/metavariable/argument!/type!");
+const termNodeQuery = nodeQuery("/metavariable/argument!/term!"),
+      typeNodeQuery = nodeQuery("/metavariable/argument!/type!");
 
 export default class Metavariable {
   constructor(node, name, termType, metaType) {
@@ -38,14 +43,28 @@ export default class Metavariable {
     return nameMatches;
   }
 
-  matchNode(node) {
-    let nodeMatches;
+  matchNode(node, localMetaContext) {
+    let nodeMatches = false;
 
     const metavariableNode = node,  ///
-          name = nameFromMetavariableNode(metavariableNode);
+          typeNode = typeNodeQuery(metavariableNode);
+
+    if (typeNode === null) {
+      const name = nameFromMetavariableNode(metavariableNode);
+
+      if (this.name === name) {
+        const termNode = termNodeQuery(metavariableNode);
+
+        if (false) {
+          ///
+        } else if ((termNode === null) && (this.termType === null)) {
+          nodeMatches = true;
+        } else if ((termNode !== null) && (this.termType !== null)) {
+          const termVerifiedAgainstTermType = verifyTermAgainstTermType(termNode, this.termType, localMetaContext);
 
-    if (this.name === name) {
-      nodeMatches = true;
+          nodeMatches = termVerifiedAgainstTermType;  ///
+        }
+      }
     }
 
     return nodeMatches;
@@ -104,6 +123,31 @@ export default class Metavariable {
   }
 }
 
+function verifyTermAgainstTermType(termNode, termType, localMetaContext) {
+  let termVerifiedAgainstTermType;
+
+  const type = termType,  ///
+        terms = [],
+        localContext = LocalContext.fromLocalMetaContext(localMetaContext);
+
+  termVerifiedAgainstTermType = verifyTerm(termNode, terms, localContext, () => {
+    let verifiedAhead = false;
+
+    const firstTerm = first(terms),
+          term = firstTerm, ///
+          termType = term.getType(),
+          termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
+
+    if (termTypeEqualToOrSubTypeOfType) {
+      verifiedAhead = true;
+    }
+
+    return verifiedAhead;
+  });
+
+  return termVerifiedAgainstTermType;
+}
+
 function termTypeFromMetavariableNode(metavariableNode, fileContext) {
   let termType = null;
 

package/src/step/metaproof.js

@@ -1,8 +1,8 @@
 "use strict";
 
 import { first, second } from "../utilities/array";
+import { matchMetastatement } from "../utilities/metaproof";
 import { nodeQuery, nodesQuery } from "../utilities/query";
-import { matchMetastatementModuloBrackets } from "../utilities/metaproof";
 
 const metastatementNodesQuery = nodesQuery("/ruleSubproofAssertion/metastatement"),
       ruleSubproofAssertionNodeQuery = nodeQuery("/metastatement/ruleSubproofAssertion"),
@@ -54,10 +54,9 @@ export default class MetaproofStep {
 
     if (this.metastatementNode !== null) {
       const metastatementNodeA = metastatementNode, ///
-            metastatementNodeB = this.metastatementNode,  ///
-            metastatementMatchesModuloBrackets = matchMetastatementModuloBrackets(metastatementNodeA, metastatementNodeB);
+            metastatementNodeB = this.metastatementNode;  ///
 
-      metastatementMatches = metastatementMatchesModuloBrackets;  ///
+      metastatementMatches = matchMetastatement(metastatementNodeA, metastatementNodeB);
     }
 
     return metastatementMatches;
@@ -74,17 +73,17 @@ export default class MetaproofStep {
 
       const metastatementNodeA = firstRuleSubproofAssertionMetastatementNode,  ///
             metastatementNodeB = firstQualifiedOrUnqualifiedMetastatementMetastatementNode, ///
-            metastatementMatchesModuloBrackets = matchMetastatementModuloBrackets(metastatementNodeA, metastatementNodeB);
+            metastatementMatches = matchMetastatement(metastatementNodeA, metastatementNodeB);
 
-      if (metastatementMatchesModuloBrackets) {
+      if (metastatementMatches) {
         const secondRuleSubproofAssertionMetastatementNode = second(ruleSubproofAssertionMetastatementNodes),
               secondQualifiedOrUnqualifiedMetastatementMetastatementNode = second(qualifiedOrUnqualifiedMetastatementMetastatementNodes);
 
         const metastatementNodeA = secondRuleSubproofAssertionMetastatementNode, ///
               metastatementNodeB = secondQualifiedOrUnqualifiedMetastatementMetastatementNode, ///
-              metastatementMatchesModuloBrackets = matchMetastatementModuloBrackets(metastatementNodeA, metastatementNodeB);
+              metastatementMatches = matchMetastatement(metastatementNodeA, metastatementNodeB);
 
-        ruleSubproofAssertionMatches = metastatementMatchesModuloBrackets; ///
+        ruleSubproofAssertionMatches = metastatementMatches; ///
       }
     }
 

package/src/utilities/metaproof.js

@@ -7,36 +7,36 @@ import { BRACKETED_METASTATEMENT_DEPTH } from "../constants";
 
 const bracketedMetastatementChildNodeQuery = nodeQuery("/metastatement/metastatement!");
 
-export function matchMetastatementModuloBrackets(metastatementNodeA, metastatementNodeB) {
-  let metastatementMatchesModuloBrackets = false;
+export function matchMetastatement(metastatementNodeA, metastatementNodeB) {
+  let metastatementMatches = false;
 
-  if (!metastatementMatchesModuloBrackets) {
+  if (!metastatementMatches) {
     const metastatementNodeMatches = metastatementNodeA.match(metastatementNodeB);
 
-    metastatementMatchesModuloBrackets = metastatementNodeMatches;  ///
+    metastatementMatches = metastatementNodeMatches;  ///
   }
 
-  if (!metastatementMatchesModuloBrackets) {
+  if (!metastatementMatches) {
     const bracketedMetastatementChildNodeA = bracketedMetastatementChildNodeFromMetastatementNode(metastatementNodeA);
 
     if (bracketedMetastatementChildNodeA !== null) {
       const bracketedMetastatementChildNodeAMatchesMetastatementNodeB = bracketedMetastatementChildNodeA.match(metastatementNodeB);
 
-      metastatementMatchesModuloBrackets = bracketedMetastatementChildNodeAMatchesMetastatementNodeB; ///
+      metastatementMatches = bracketedMetastatementChildNodeAMatchesMetastatementNodeB; ///
     }
   }
 
-  if (!metastatementMatchesModuloBrackets) {
+  if (!metastatementMatches) {
     const bracketedMetastatementChildNodeB = bracketedMetastatementChildNodeFromMetastatementNode(metastatementNodeB);
 
     if (bracketedMetastatementChildNodeB !== null) {
       const metastatementNodeAMatchesBracketedMetastatementChildNodeB = metastatementNodeA.match(bracketedMetastatementChildNodeB);
 
-      metastatementMatchesModuloBrackets = metastatementNodeAMatchesBracketedMetastatementChildNodeB; ///
+      metastatementMatches = metastatementNodeAMatchesBracketedMetastatementChildNodeB; ///
     }
   }
 
-  return metastatementMatchesModuloBrackets;
+  return metastatementMatches;
 }
 
 export function bracketedMetastatementChildNodeFromMetastatementNode(metastatementNode) {

package/src/verify/conclusion.js

@@ -16,8 +16,9 @@ export default function verifyConclusion(conclusionNode, conclusions, localMetaC
   localMetaContext.trace(`Verifying the '${conclusionString}' conclusion...`, conclusionNode);
 
   const derived = false,
+        assignments = [],
         unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(conclusionNode),
-        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, derived, localMetaContext);
+        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
 
   if (unqualifiedMetastatementVerified) {
     const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),

package/src/verify/metaConsequent.js

@@ -8,16 +8,17 @@ import { nodeQuery } from "../utilities/query";
 const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/metaConsequent/unqualifiedMetastatement!");
 
-export default function verifyMetaConsequent(metaConsequentNode, metaConsequents, localContext) {
+export default function verifyMetaConsequent(metaConsequentNode, metaConsequents, localMetaContext) {
   let metaConsequentVerified = false;
 
-  const metaConsequentString = localContext.nodeAsString(metaConsequentNode);
+  const metaConsequentString = localMetaContext.nodeAsString(metaConsequentNode);
 
-  localContext.trace(`Verifying the '${metaConsequentString}' meta-consequent...`, metaConsequentNode);
+  localMetaContext.trace(`Verifying the '${metaConsequentString}' meta-consequent...`, metaConsequentNode);
 
   const derived = false,
+        assignments = [],
         unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(metaConsequentNode),
-        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, derived, localContext);
+        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
 
   if (unqualifiedMetastatementVerified) {
     metaConsequentVerified = true;
@@ -29,7 +30,7 @@ export default function verifyMetaConsequent(metaConsequentNode, metaConsequents
 
     metaConsequents.push(metaConsequent);
 
-    localContext.debug(`...verified the '${metaConsequentString}' meta-consequent.`, metaConsequentNode);
+    localMetaContext.debug(`...verified the '${metaConsequentString}' meta-consequent.`, metaConsequentNode);
   }
 
   return metaConsequentVerified;

package/src/verify/metaDerivation.js

@@ -97,9 +97,10 @@ function verifyChild(childNode, localMetaContext) {
 
       const derived = true,
             assignments = [],
+            metavariableReferences = true,
             qualifiedMetastatementNode = childNode;  ///
 
-      qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, assignments, derived, localMetaContext);
+      qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, metavariableReferences, assignments, derived, localMetaContext);
 
       if (qualifiedMetastatementVerified) {
         const assignmentAssigned = assignAssignment(assignments, localMetaContext);

package/src/verify/metaLemma.js

@@ -47,7 +47,7 @@ export default function verifyMetaLemma(metaLemmaNode, fileContext) {
               metaproofVerified = verifyMetaproof(metaproofNode, metaConsequent, localMetaContext);
 
         if (metaproofVerified) {
-          const metaLemma = MetaLemma.fromLabelsMetaSuppositionsMetaConsequentAndLocalMetaContext(labels, metaSuppositions, metaConsequent, localMetaContext);
+          const metaLemma = MetaLemma.fromLabelsMetaSuppositionsMetaConsequentAndFileContext(labels, metaSuppositions, metaConsequent, fileContext);
 
           fileContext.addMetaLemma(metaLemma);
 

package/src/verify/metaSupposition.js

@@ -10,20 +10,20 @@ import { assignAssignment } from "../utilities/assignments";
 const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/metaSupposition/unqualifiedMetastatement!");
 
-export default function verifyMetaSupposition(metaSuppositionNode, metaSuppositions, localContext) {
+export default function verifyMetaSupposition(metaSuppositionNode, metaSuppositions, localMetaContext) {
   let metaSuppositionVerified = false;
 
-  const metaSuppositionString = localContext.nodeAsString(metaSuppositionNode);
+  const metaSuppositionString = localMetaContext.nodeAsString(metaSuppositionNode);
 
-  localContext.trace(`Verifying the '${metaSuppositionString}' meta-supposition...`, metaSuppositionNode);
+  localMetaContext.trace(`Verifying the '${metaSuppositionString}' meta-supposition...`, metaSuppositionNode);
 
   const derived = false,
         assignments = [],
         unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(metaSuppositionNode),
-        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localContext);
+        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
 
   if (unqualifiedMetastatementVerified) {
-    const assignmentAssigned = assignAssignment(assignments, localContext);
+    const assignmentAssigned = assignAssignment(assignments, localMetaContext);
 
     metaSuppositionVerified = assignmentAssigned; ///
   }
@@ -35,9 +35,9 @@ export default function verifyMetaSupposition(metaSuppositionNode, metaSuppositi
 
     metaSuppositions.push(metaSupposition);
 
-    localContext.addMetaproofStep(metaproofStep);
+    localMetaContext.addMetaproofStep(metaproofStep);
 
-    localContext.debug(`...verified the '${metaSuppositionString}' meta-supposition.`, metaSuppositionNode);
+    localMetaContext.debug(`...verified the '${metaSuppositionString}' meta-supposition.`, metaSuppositionNode);
   }
 
   return metaSuppositionVerified;

package/src/verify/metaSuppositions.js

@@ -2,11 +2,11 @@
 
 import verifyMetaSupposition from "../verify/metaSupposition";
 
-export default function verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, localContext) {
+export default function verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, localMetaContext) {
   let metaSuppositionsVerified;
 
   metaSuppositionsVerified = metaSuppositionNodes.every((metaSuppositionNode) => {
-    const metaSuppositionVerified = verifyMetaSupposition(metaSuppositionNode, metaSuppositions, localContext);
+    const metaSuppositionVerified = verifyMetaSupposition(metaSuppositionNode, metaSuppositions, localMetaContext);
 
     if (metaSuppositionVerified) {
       return true;

package/src/verify/metastatement/qualified.js

@@ -1,11 +1,13 @@
 "use strict";
 
+import verifyMetastatement from "../metastatement";
+
 import { nodeQuery } from "../../utilities/query";
 
 const metastatementNodeQuery = nodeQuery("/qualifiedMetastatement/metastatement!"),
       referenceMetavariableNodeQuery = nodeQuery("/qualifiedMetastatement/reference!/metavariable!");
 
-export default function verifyQualifiedMetastatement(qualifiedMetastatementNode, assignments, derived, localMetaContext) {
+export default function verifyQualifiedMetastatement(qualifiedMetastatementNode, metavariableReferences, assignments, derived, localMetaContext) {
   let qualifiedMetastatementVerified = false;
 
   const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode);
@@ -24,6 +26,21 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
       const ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, metastatementLocalMetaContext);
 
       qualifiedMetastatementVerified = ruleMatchesMetastatement;  ///
+    } else {
+      if (metavariableReferences) {
+        const metavariableNode = referenceMetavariableNode, ///
+              metavariablePresent = localMetaContext.isMetavariablePresentByMetavariableNode(metavariableNode, localMetaContext);
+
+        if (metavariablePresent) {
+          const metastatementVerified = verifyMetastatement(metastatementNode, derived, localMetaContext, () => {
+            const verifiedAhead = true;
+
+            return verifiedAhead;
+          });
+
+          qualifiedMetastatementVerified = metastatementVerified; ///
+        }
+      }
     }
 
     if (qualifiedMetastatementVerified) {

package/src/verify/metastatement/unqualified.js

@@ -6,7 +6,7 @@ import { nodeQuery } from "../../utilities/query";
 
 const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
 
-export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, derived, localMetaContext) {
+export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext) {
   let unqualifiedMetastatementVerified = false;
 
   const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);

package/src/verify/metatheorem.js

@@ -44,7 +44,7 @@ export default function verifyMetatheorem(metatheoremNode, fileContext) {
               metaproofVerified = verifyMetaproof(metaproofNode, metaConsequent, localMetaContext);
 
         if (metaproofVerified) {
-          const metatheorem = Metatheorem.fromLabelsMetaSuppositionsMetaConsequentAndLocalMetaContext(labels, metaSuppositions, metaConsequent, localMetaContext);
+          const metatheorem = Metatheorem.fromLabelsMetaSuppositionsMetaConsequentAndFileContext(labels, metaSuppositions, metaConsequent, fileContext);
 
           fileContext.addMetatheorem(metatheorem);
 

package/src/verify/metavariable.js

@@ -73,7 +73,7 @@ export function verifyStandaloneMetavariable(metavariableNode, localMetaContext,
 
   localMetaContext.trace(`Verifying the '${metavariableString}' standalone metavariable...`, metavariableNode);
 
-  const metavariablePresent = localMetaContext.isMetavariablePresentByMetavariableNode(metavariableNode);
+  const metavariablePresent = localMetaContext.isMetavariablePresentByMetavariableNode(metavariableNode, localMetaContext);
 
   if (metavariablePresent) {
     const verifiedAhead = verifyAhead();

package/src/verify/premise.js

@@ -17,8 +17,9 @@ export default function verifyPremise(premiseNode, premises, localMetaContext) {
   localMetaContext.trace(`Verifying the '${premiseString}' premise...`, premiseNode);
 
   const derived = false,
+        assignments = [],
         unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(premiseNode),
-        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, derived, localMetaContext);
+        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
 
   if (unqualifiedMetastatementVerified) {
     const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),

package/src/verify/ruleDerivation.js

@@ -91,8 +91,9 @@ function verifyChild(childNode, localMetaContext) {
     case QUALIFIED_METASTATEMENT_RULE_NAME: {
       const derived = true,
             assignments = [],
+            metavariableReferences = true,
             qualifiedMetastatementNode = childNode,  ///
-            qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, assignments, derived, localMetaContext);
+            qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, metavariableReferences, assignments, derived, localMetaContext);
 
       if (qualifiedMetastatementVerified) {
         const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
@@ -108,8 +109,9 @@ function verifyChild(childNode, localMetaContext) {
 
     case UNQUALIFIED_METASTATEMENT_RULE_NAME: {
       const derived = true,
+            assignments = false,
             unqualifiedMetastatementNode = childNode,  ///
-            unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, derived, localMetaContext);
+            unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
 
       if (unqualifiedMetastatementVerified) {
         const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),