occam-verify-cli 0.0.922 → 0.0.924

package/src/verify/metastatement.js

@@ -2,142 +2,114 @@
 
 import verifyJudgement from "../verify/judgement";
 import metaLevelNodeVerifier from "../verifier/node/metaLevel";
-import verifyMetastatementAsDefinedAssertion from "./metastatementAsDefinedAssertion";
-import verifyMetastatementAsContainedAssertion from "./metastatementAsContainedAssertion";
 
 import { nodeQuery } from "../utilities/query";
 
-const judgementNodeQuery = nodeQuery("/metastatement/judgement!");
+const judgementNodeQuery = nodeQuery("/statement/judgement!");
 
-function verifyMetastatement(metastatementNode, assignments, derived, localContext) {
-  let metastatementVerified;
+function verifyStatement(statementNode, assignments, derived, localContext) {
+  let statementVerified;
 
-  const metastatementString = localContext.nodeAsString(metastatementNode);
+  const statementString = localContext.nodeAsString(statementNode);
 
-  localContext.trace(`Verifying the '${metastatementString}' metastatement...`, metastatementNode);
+  localContext.trace(`Verifying the '${statementString}' statement...`, statementNode);
 
-  const verifyMetaStatementFunctions = [
-    verifyMetastatementAsJudgement,
-    verifyMetastatementAsDefinedAssertion,
-    verifyMetastatementAsContainedAssertion,
-    verifyMetastatementAsIs
+  const verifyStatementFunctions = [
+    verifyStatementAsIs
   ];
 
-  metastatementVerified = verifyMetaStatementFunctions.some((verifyStatementFunction) => {
-    const metastatementVerified = verifyStatementFunction(metastatementNode, assignments, derived, localContext);
+  statementVerified = verifyStatementFunctions.some((verifyStatementFunction) => {
+    const statementVerified = verifyStatementFunction(statementNode, assignments, derived, localContext);
 
-    if (metastatementVerified) {
+    if (statementVerified) {
       return true;
     }
   });
 
-  if (metastatementVerified) {
-    localContext.debug(`...verified the '${metastatementString}' metastatement.`, metastatementNode);
+  if (statementVerified) {
+    localContext.debug(`...verified the '${statementString}' statement.`, statementNode);
   }
 
-  return metastatementVerified;
+  return statementVerified;
 }
 
 Object.assign(metaLevelNodeVerifier, {
-  verifyMetastatement
+  verifyStatement
 });
 
-export default verifyMetastatement;
+export default verifyStatement;
 
-function verifyMetastatementAsJudgement(metastatementNode, assignments, derived, localContext) {
-  let metastatementVerifiedAsJudgement = false;
+function verifyStatementAsIs(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAsIs;
 
-  const metastatementJudgement = isMetastatementJudgement(metastatementNode);
+  const statementJudgement = isStatementJudgement(statementNode);
 
-  if (metastatementJudgement) {
-    const metastatementString = localContext.nodeAsString(metastatementNode);
+  if (!statementJudgement) {
+    const statementString = localContext.nodeAsString(statementNode);
 
-    localContext.trace(`Verifying the '${metastatementString}' metastatement as a judgement...`, metastatementNode);
+    localContext.trace(`Verifying the '${statementString}' statement as is...`, statementNode);
 
-    const judgementNode = judgementNodeQuery(metastatementNode),
-          judgementVerified = verifyJudgement(judgementNode, assignments, derived, localContext);
-
-    metastatementVerifiedAsJudgement = judgementVerified;  ///
-
-    if (metastatementVerifiedAsJudgement) {
-      localContext.debug(`...verified the '${metastatementString}' metastatement as a judgement.`, metastatementNode);
-    }
-  }
-
-  return metastatementVerifiedAsJudgement;
-}
-
-function verifyMetastatementAsIs(metastatementNode, assignments, derived, localContext) {
-  let metastatementVerifiedAsIs;
-
-  const metastatementJudgement = isMetastatementJudgement(metastatementNode);
-
-  if (!metastatementJudgement) {
-    const metastatementString = localContext.nodeAsString(metastatementNode);
-
-    localContext.trace(`Verifying the '${metastatementString}' metastatement as is...`, metastatementNode);
-
-    const verifyMetastatementAsIsFunctions = [
-      verifyDerivedMetastatementAsIs,
-      verifyStatedMetastatementAsIs
+    const verifyStatementAsIsFunctions = [
+      verifyDerivedStatementAsIs,
+      verifyStatedStatementAsIs
     ];
 
-    metastatementVerifiedAsIs = verifyMetastatementAsIsFunctions.some((verifyMetastatementAsIsFunction) => {
-      const metastatementVerifiedAsIs = verifyMetastatementAsIsFunction(metastatementNode, assignments, derived, localContext);
+    statementVerifiedAsIs = verifyStatementAsIsFunctions.some((verifyStatementAsIsFunction) => {
+      const statementVerifiedAsIs = verifyStatementAsIsFunction(statementNode, assignments, derived, localContext);
 
-      if (metastatementVerifiedAsIs) {
+      if (statementVerifiedAsIs) {
         return true;
       }
     });
 
-    if (metastatementVerifiedAsIs) {
-      localContext.debug(`...verified the '${metastatementString}' metastatement as is.`, metastatementNode);
+    if (statementVerifiedAsIs) {
+      localContext.debug(`...verified the '${statementString}' statement as is.`, statementNode);
     }
   }
 
-  return metastatementVerifiedAsIs;
+  return statementVerifiedAsIs;
 }
 
-function verifyDerivedMetastatementAsIs(metastatementNode, assignments, derived, localContext) {
-  let derivedMetastatementVerifiedAsIs = false;
+function verifyDerivedStatementAsIs(statementNode, assignments, derived, localContext) {
+  let derivedStatementVerifiedAsIs = false;
 
   if (derived) {
-    const metastatementString = localContext.nodeAsString(metastatementNode);
+    const statementString = localContext.nodeAsString(statementNode);
 
-    localContext.debug(`Cannot verify the derived '${metastatementString}' metastatement as is.`, metastatementNode);
+    localContext.debug(`Cannot verify the '${statementString}' derived statement as is.`, statementNode);
   }
 
-  return derivedMetastatementVerifiedAsIs;
+  return derivedStatementVerifiedAsIs;
 }
 
-function verifyStatedMetastatementAsIs(metastatementNode, assignments, derived, localContext) {
-  let statedMetastatementVerifiedAsIs = false;
+function verifyStatedStatementAsIs(statementNode, assignments, derived, localContext) {
+  let statedStatementVerifiedAsIs = false;
 
   if (!derived) {
-    const metastatementString = localContext.nodeAsString(metastatementNode);
+    const statementString = localContext.nodeAsString(statementNode);
 
-    localContext.trace(`Verifying the stated '${metastatementString}' metastatement as is...`, metastatementNode);
+    localContext.trace(`Verifying the '${statementString}' stated statement as is...`, statementNode);
 
-    const nonTerminalNode = metastatementNode, ///
+    const nonTerminalNode = statementNode, ///
           nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;
           });
 
-    statedMetastatementVerifiedAsIs = nonTerminalNodeVerified;  ///
+    statedStatementVerifiedAsIs = nonTerminalNodeVerified;  ///
 
-    if (statedMetastatementVerifiedAsIs) {
-      localContext.debug(`...verified the stated '${metastatementString}' metastatement as is.`, metastatementNode);
+    if (statedStatementVerifiedAsIs) {
+      localContext.debug(`...verified the '${statementString}' stated statement as is.`, statementNode);
     }
   }
 
-  return statedMetastatementVerifiedAsIs;
+  return statedStatementVerifiedAsIs;
 }
 
-function isMetastatementJudgement(metastatementNode) {
-  const judgementNode = judgementNodeQuery(metastatementNode),
-        metastatementJudgement = (judgementNode !== null);
+function isStatementJudgement(statementNode) {
+  const judgementNode = judgementNodeQuery(statementNode),
+        statementJudgement = (judgementNode !== null);
 
-  return metastatementJudgement;
+  return statementJudgement;
 }

package/src/verify/metatheorem.js

@@ -1,19 +1,19 @@
 "use strict";
 
+import verifyProof from "../verify/proof";
 import Metatheorem from "../metatheorem";
 import verifyLabels from "../verify/labels";
 import LocalContext from "../context/local";
-import verifyMetaproof from "../verify/metaproof";
-import verifyMetaConsequent from "../verify/metaConsequent";
-import verifyMetaSuppositions from "../verify/metaSuppositions";
+import verifyConsequent from "../verify/consequent";
+import verifySuppositions from "../verify/suppositions";
 
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const labelNodesQuery = nodesQuery("/metatheorem/label"),
-      metaproofNodeQuery = nodeQuery("/metatheorem/metaproof!"),
-      metaConsequentNodeQuery = nodeQuery("/metatheorem/metaConsequent!"),
-      metaSuppositionsNodeQuery = nodesQuery("/metatheorem/metaSupposition");
+      proofNodeQuery = nodeQuery("/metatheorem/proof!"),
+      consequentNodeQuery = nodeQuery("/metatheorem/consequent!"),
+      suppositionsNodeQuery = nodesQuery("/metatheorem/supposition");
 
 export default function verifyMetatheorem(metatheoremNode, fileContext) {
   let metatheoremVerified = false;
@@ -27,26 +27,26 @@ export default function verifyMetatheorem(metatheoremNode, fileContext) {
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
-    const localContext = LocalContext.fromFileContext(fileContext), ///
-          substitutions = [],
-          metaSuppositions = [],
-          metaSuppositionNodes = metaSuppositionsNodeQuery(metatheoremNode),
-          metaSuppositionsVerified = verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, substitutions, localContext);
+    const localContext = LocalContext.fromFileContext(fileContext),
+          suppositions = [],
+          suppositionNodes = suppositionsNodeQuery(metatheoremNode),
+          suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
 
-    if (metaSuppositionsVerified) {
-      const metaConsequents = [],
-            metaConsequentNode = metaConsequentNodeQuery(metatheoremNode),
-            metaConsequentVerified = verifyMetaConsequent(metaConsequentNode, metaConsequents, substitutions, localContext);
+    if (suppositionsVerified) {
+      const consequents = [],
+            consequentNode = consequentNodeQuery(metatheoremNode),
+            consequentVerified = verifyConsequent(consequentNode, consequents, localContext);
 
-      if (metaConsequentVerified) {
-        const metaproofNode = metaproofNodeQuery(metatheoremNode),
-              firstMetaConsequent = first(metaConsequents),
-              metaConsequent = firstMetaConsequent, ///
-              metastatementNode = metaConsequent.getMetastatementNode(),
-              metaproofVerified = verifyMetaproof(metaproofNode, metastatementNode, substitutions, localContext);
+      if (consequentVerified) {
+        const proofNode = proofNodeQuery(metatheoremNode),
+              firstConsequent = first(consequents),
+              consequent = firstConsequent, ///
+              substitutions = [],
+              statementNode = consequent.getStatementNode(),
+              proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);
 
-        if (metaproofVerified) {
-          const metatheorem = Metatheorem.fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(labels, metaSuppositions, metaConsequent, substitutions, fileContext);
+        if (proofVerified) {
+          const metatheorem = Metatheorem.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext);
 
           fileContext.addMetatheorem(metatheorem);
 

package/src/verify/metavariable.js

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

package/src/verify/premise.js

@@ -1,17 +1,14 @@
 "use strict";
 
 import Premise from "../premise";
-import MetaproofStep from "../step/metaproof";
+import ProofStep from "../proofStep";
 import verifyUnqualifiedStatement from "../verify/statement/unqualified";
-import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
 import { assignAssignment } from "../utilities/assignments";
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
-      metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
-      unqualifiedStatementNodeQuery = nodeQuery("/premise/unqualifiedStatement!"),
-      unqualifiedMetastatementNodeQuery = nodeQuery("/premise/unqualifiedMetastatement!");
+      unqualifiedStatementNodeQuery = nodeQuery("/premise/unqualifiedStatement!");
 
 export default function verifyPremise(premiseNode, premises, localContext) {
   let premiseVerified;
@@ -21,56 +18,27 @@ export default function verifyPremise(premiseNode, premises, localContext) {
   localContext.trace(`Verifying the '${premiseString}' premise...`, premiseNode);
 
   const unqualifiedStatementNode = unqualifiedStatementNodeQuery(premiseNode),
-        unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(premiseNode);
+        derived = false,
+        assignments = [],
+        unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
 
-  if (unqualifiedStatementNode !== null) {
-    const derived = false,
-          assignments = [],
-          unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
+  if (unqualifiedStatementVerified) {
+    const assignmentAssigned = assignAssignment(assignments, localContext);
 
-    if (unqualifiedStatementVerified) {
-      const assignmentAssigned = assignAssignment(assignments, localContext);
+    if (assignmentAssigned) {
+      const statementNode = statementNodeQuery(unqualifiedStatementNode),
+            metaproofStep = ProofStep.fromStatementNode(statementNode),
+            premise = Premise.fromStatementNode(statementNode);
 
-      premiseVerified = assignmentAssigned; ///
-    }
-  }
+      premises.push(premise);
 
-  if (unqualifiedMetastatementNode !== null) {
-    const derived = false,
-          assignments = [],
-          unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localContext);
+      localContext.addProofStep(metaproofStep);
 
-    if (unqualifiedMetastatementVerified) {
-      const assignmentAssigned = assignAssignment(assignments, localContext);
-
-      premiseVerified = assignmentAssigned; ///
+      premiseVerified = true;
     }
   }
 
   if (premiseVerified) {
-    let premise,
-        metaproofStep;
-
-    if (unqualifiedStatementNode !== null) {
-      const statementNode = statementNodeQuery(unqualifiedStatementNode);
-
-      metaproofStep = MetaproofStep.fromMetastatementNode(statementNode);
-
-      premise = Premise.fromStatementNode(statementNode);
-    }
-
-    if (unqualifiedMetastatementNode !== null) {
-      const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
-
-      metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
-
-      premise = Premise.fromMetastatementNode(metastatementNode);
-    }
-
-    premises.push(premise);
-
-    localContext.addMetaproofStep(metaproofStep);
-
     localContext.debug(`...verified the '${premiseString}' premise.`, premiseNode);
   }
 

package/src/verify/proof.js

@@ -7,13 +7,13 @@ import { nodeQuery } from "../utilities/query";
 
 const derivationNodeQuery = nodeQuery("/proof/derivation!");
 
-export default function verifyProof(proofNode, conclusion, localContext) {
+export default function verifyProof(proofNode, conclusion, substitutions, localContext) {
   let proofVerified = false;
 
   localContext = LocalContext.fromLocalContext(localContext); ///
 
   const derivationNode = derivationNodeQuery(proofNode),
-        derivationVerified = verifyDerivation(derivationNode, localContext);
+        derivationVerified = verifyDerivation(derivationNode, substitutions, localContext);
 
   if (derivationVerified) {
     const lastProofStep = localContext.getLastProofStep();

package/src/verify/proofStep.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import ProofStep from "../step/proof";
+import ProofStep from "../proofStep";
 import verifySubproof from "../verify/subproof";
 import verifySubDerivation from "../verify/subDerivation";
 import verifyQualifiedStatement from "../verify/statement/qualified";
@@ -14,7 +14,7 @@ const subproofNodeQuery = nodeQuery("/proofStep|lastProofStep/subproof!"),
       qualifiedStatementNodeQuery = nodeQuery("/proofStep|lastProofStep/qualifiedStatement!"),
       unqualifiedStatementNodeQuery = nodeQuery("/proofStep|lastProofStep/unqualifiedStatement!");
 
-export default function verifyProofStep(proofStepNode, localContext) {
+export default function verifyProofStep(proofStepNode, substitutions, localContext) {
   let proofStepVerified = false;
 
   const subproofNode = subproofNodeQuery(proofStepNode),
@@ -26,7 +26,7 @@ export default function verifyProofStep(proofStepNode, localContext) {
   } else if (subproofNode !== null) {
     let subproofVerified;
 
-    subproofVerified = verifySubproof(subproofNode, localContext);
+    subproofVerified = verifySubproof(subproofNode, substitutions, localContext);
 
     if (subproofVerified) {
       const proofStep = ProofStep.fromSubproofNode(subproofNode);
@@ -40,7 +40,7 @@ export default function verifyProofStep(proofStepNode, localContext) {
 
     const assignments = [];
 
-    qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, assignments, localContext);
+    qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, substitutions, assignments, localContext);
 
     if (qualifiedStatementVerified) {
       const assignmentAssigned = assignAssignment(assignments, localContext);

package/src/verify/rule.js

@@ -1,18 +1,18 @@
 "use strict";
 
 import Rule from "../rule";
+import verifyProof from "../verify/proof";
 import LocalContext from "../context/local";
 import verifyLabels from "../verify/labels";
 import verifyPremises from "../verify/premises";
-import verifyMetaproof from "../verify/metaproof";
 import verifyConclusion from "../verify/conclusion";
 
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const labelNodesQuery = nodesQuery("/rule/label"),
+const proofNodeQuery = nodeQuery("/rule/proof!"),
+      labelNodesQuery = nodesQuery("/rule/label"),
       premisesNodeQuery = nodesQuery("/rule/premise"),
-      metaproofNodeQuery = nodeQuery("/rule/metaproof!"),
       conclusionNodeQuery = nodeQuery("/rule/conclusion!");
 
 export default function verifyRule(ruleNode, fileContext) {
@@ -27,8 +27,8 @@ export default function verifyRule(ruleNode, fileContext) {
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
-    const premises = [],
-          localContext = LocalContext.fromFileContext(fileContext),
+    const localContext = LocalContext.fromFileContext(fileContext),
+          premises = [],
           premiseNodes = premisesNodeQuery(ruleNode),
           premisesVerified = verifyPremises(premiseNodes, premises, localContext);
 
@@ -38,20 +38,20 @@ export default function verifyRule(ruleNode, fileContext) {
             conclusionVerified = verifyConclusion(conclusionNode, conclusions, localContext);
 
       if (conclusionVerified) {
-        let metaproofVerified = true; ///
+        let proofVerified = true; ///
 
         const firstConclusion = first(conclusions),
-              metaproofNode = metaproofNodeQuery(ruleNode),
+              proofNode = proofNodeQuery(ruleNode),
               conclusion = firstConclusion; ///
 
-        if (metaproofNode !== null) {
+        if (proofNode !== null) {
           const substitutions = [],
-                metastatementNode = conclusion.getMetastatementNode();
+                statementNode = conclusion.getStatementNode();
 
-          metaproofVerified = verifyMetaproof(metaproofNode, metastatementNode, substitutions, localContext);
+          proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);
         }
 
-        if (metaproofVerified) {
+        if (proofVerified) {
           const rule = Rule.fromLabelsPremisesConclusionAndFileContext(labels, premises, conclusion, fileContext);
 
           fileContext.addRule(rule);

package/src/verify/statement/qualified.js

@@ -6,24 +6,26 @@ import { verifyStatementAsEquality, verifyStatementAsTypeAssertion } from "../..
 const statementNodeQuery = nodeQuery("/qualifiedStatement/statement!"),
       metavariableNodeQuery = nodeQuery("/qualifiedStatement/reference!/metavariable!");
 
-export default function verifyQualifiedStatement(qualifiedStatementNode, assignments, localContext) {
+import verifyMetavariableAgainstStatement from "../../verify/metavariableAgainstStatement";
+
+export default function verifyQualifiedStatement(qualifiedStatementNode, substitutions, assignments, localContext) {
   let qualifiedStatementVerified;
 
   const qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
   localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement...`, qualifiedStatementNode);
 
-  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
-        verifyQualifiedStatementFunctions = [
-          verifyQualifiedStatementAAgainstRule,
-          verifyQualifiedStatementAAgainstAxiom,
-          verifyQualifiedStatementAAgainstLemma,
-          verifyQualifiedStatementAAgainstTheorem,
-          verifyQualifiedStatementAAgainstConjecture
-        ];
+  const verifyQualifiedStatementFunctions = [
+    verifyQualifiedStatementAAgainstRule,
+    verifyQualifiedStatementAAgainstAxiom,
+    verifyQualifiedStatementAAgainstLemma,
+    verifyQualifiedStatementAAgainstTheorem,
+    verifyQualifiedStatementAAgainstConjecture,
+    verifyQualifiedStatementAAgainstReference
+  ];
 
   qualifiedStatementVerified = verifyQualifiedStatementFunctions.some((verifyQualifiedStatementFunction) => {  ///
-    const qualifiedStatementVerified = verifyQualifiedStatementFunction(qualifiedStatementNode, metavariableNode, localContext);
+    const qualifiedStatementVerified = verifyQualifiedStatementFunction(qualifiedStatementNode, substitutions, localContext);
 
     if (qualifiedStatementVerified) {
       return true;
@@ -35,7 +37,7 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
           statementNode = statementNodeQuery(qualifiedStatementNode),
           statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
 
-    qualifiedStatementVerified = statementVerified;  ///
+    qualifiedStatementVerified = statementVerified; ///
   }
 
   if (qualifiedStatementVerified) {
@@ -45,10 +47,11 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
   return qualifiedStatementVerified;
 }
 
-function verifyQualifiedStatementAAgainstRule(qualifiedStatementNode, metavariableNode, localContext) {
+function verifyQualifiedStatementAAgainstRule(qualifiedStatementNode, substitutions, localContext) {
   let qualifiedStatementVerifiedAgainstRule = false;
 
-  const rule = localContext.findRuleByMetavariableNode(metavariableNode);
+  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
+        rule = localContext.findRuleByMetavariableNode(metavariableNode);
 
   if (rule !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
@@ -69,10 +72,11 @@ function verifyQualifiedStatementAAgainstRule(qualifiedStatementNode, metavariab
   return qualifiedStatementVerifiedAgainstRule;
 }
 
-function verifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, metavariableNode, localContext) {
+function verifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, substitutions, localContext) {
   let qualifiedStatementVerifiedAgainstAxiom = false;
 
-  const axiom = localContext.findAxiomByMetavariableNode(metavariableNode);
+  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
+        axiom = localContext.findAxiomByMetavariableNode(metavariableNode);
 
   if (axiom !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
@@ -93,10 +97,11 @@ function verifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, metavaria
   return qualifiedStatementVerifiedAgainstAxiom;
 }
 
-function verifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, metavariableNode, localContext) {
+function verifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, substitutions, localContext) {
   let qualifiedStatementVerifiedAgainstLemma = false;
 
-  const lemma = localContext.findLemmaByMetavariableNode(metavariableNode);
+  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
+        lemma = localContext.findLemmaByMetavariableNode(metavariableNode);
 
   if (lemma !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
@@ -117,10 +122,11 @@ function verifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, metavaria
   return qualifiedStatementVerifiedAgainstLemma;
 }
 
-function verifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, metavariableNode, localContext) {
+function verifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, substitutions, localContext) {
   let qualifiedStatementVerifiedAgainstTheorem = false;
 
-  const theorem = localContext.findTheoremByMetavariableNode(metavariableNode);
+  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
+        theorem = localContext.findTheoremByMetavariableNode(metavariableNode);
 
   if (theorem !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
@@ -141,10 +147,11 @@ function verifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, metavar
   return qualifiedStatementVerifiedAgainstTheorem;
 }
 
-function verifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, metavariableNode, localContext) {
+function verifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, substitutions, localContext) {
   let qualifiedStatementVerifiedAgainstConjecture = false;
 
-  const conjecture = localContext.findConjectureByMetavariableNode(metavariableNode);
+  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
+        conjecture = localContext.findConjectureByMetavariableNode(metavariableNode);
 
   if (conjecture !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
@@ -165,6 +172,34 @@ function verifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, meta
   return qualifiedStatementVerifiedAgainstConjecture;
 }
 
+function verifyQualifiedStatementAAgainstReference(qualifiedStatementNode, substitutions, localContext) {
+  let qualifiedStatementVerifiedAgainstReference = false;
+
+  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
+        metavariableString = localContext.nodeAsString(metavariableNode),
+        metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode),
+        qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+
+  localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' reference...`, qualifiedStatementNode);
+
+  if (metavariablePresent) {
+    const statementNode = statementNodeQuery(qualifiedStatementNode),
+          metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNode, statementNode, substitutions, () => {
+            const verifiedAhead = true;
+
+            return verifiedAhead;
+          });
+
+    qualifiedStatementVerifiedAgainstReference = metavariableVerifiedAgainstStatement; ///
+  }
+
+  if (qualifiedStatementVerifiedAgainstReference) {
+    localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' reference.`, qualifiedStatementNode);
+  }
+
+  return qualifiedStatementVerifiedAgainstReference;
+}
+
 function verifyStatement(statementNode, assignments, derived, localContext) {
   let statementVerified;