occam-verify-cli 0.0.959 → 0.0.961

package/src/verify/proofStep.js

@@ -7,7 +7,7 @@ import verifyQualifiedStatement from "../verify/statement/qualified";
 import verifyUnqualifiedStatement from "../verify/statement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
-import { assignAssignment } from "../utilities/assignments";
+import { assignAssignments } from "../utilities/assignments";
 
 const subproofNodeQuery = nodeQuery("/proofStep|lastProofStep/subproof!"),
       statementNodeQuery = nodeQuery("/qualifiedStatement|unqualifiedStatement/statement!"),
@@ -21,63 +21,51 @@ export default function verifyProofStep(proofStepNode, substitutions, localConte
         qualifiedStatementNode = qualifiedStatementNodeQuery(proofStepNode),
         unqualifiedStatementNode = unqualifiedStatementNodeQuery(proofStepNode);
 
-  if (false) {
-    ///
-  } else if (subproofNode !== null) {
+  let proofStep = null;
+
+  if (subproofNode !== null) {
     let subproofVerified;
 
     subproofVerified = verifySubproof(subproofNode, substitutions, localContext);
 
     if (subproofVerified) {
-      const proofStep = ProofStep.fromSubproofNode(subproofNode);
-
-      localContext.addProofStep(proofStep);
-
-      proofStepVerified = true;
+      proofStep = ProofStep.fromSubproofNode(subproofNode);
     }
-  } else if (qualifiedStatementNode !== null) {
-    let qualifiedStatementVerified;
-
-    const assignments = [];
+  } else {
+    const derived = true,
+          assignments = [];
 
-    qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, substitutions, assignments, localContext);
+    let statementVerified = false;
 
-    if (qualifiedStatementVerified) {
-      const assignmentAssigned = assignAssignment(assignments, localContext);
+    if (qualifiedStatementNode !== null) {
+      const qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, substitutions, assignments, derived, localContext);
 
-      qualifiedStatementVerified = assignmentAssigned; ///
-    }
+      const statementNode = statementNodeQuery(qualifiedStatementNode);
 
-    if (qualifiedStatementVerified) {
-      const statementNode = statementNodeQuery(qualifiedStatementNode),
-            proofStep = ProofStep.fromStatementNode(statementNode);
+      proofStep = ProofStep.fromStatementNode(statementNode);
 
-      localContext.addProofStep(proofStep);
-
-      proofStepVerified = true;
+      statementVerified = qualifiedStatementVerified; ///
     }
-  } else if (unqualifiedStatementNode !== null) {
-    let unqualifiedStatementVerified;
 
-    const derived = true,
-          assignments = [];
+    if (unqualifiedStatementNode !== null) {
+      const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
 
-    unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
+      const statementNode = statementNodeQuery(unqualifiedStatementNode);
 
-    if (unqualifiedStatementVerified) {
-      const assignmentAssigned = assignAssignment(assignments, localContext);
+      proofStep = ProofStep.fromStatementNode(statementNode);
 
-      unqualifiedStatementVerified = assignmentAssigned;  ///
+      statementVerified = unqualifiedStatementVerified; ///
     }
 
-    if (unqualifiedStatementVerified) {
-      const statementNode = statementNodeQuery(unqualifiedStatementNode),
-            proofStep = ProofStep.fromStatementNode(statementNode);
+    if (statementVerified) {
+      assignAssignments(assignments, localContext);
+    }
+  }
 
-      localContext.addProofStep(proofStep);
+  if (proofStep !== null) {
+    localContext.addProofStep(proofStep);
 
-      proofStepVerified = true;
-    }
+    proofStepVerified = true;
   }
 
   return proofStepVerified;

package/src/verify/statement/qualified.js

@@ -1,48 +1,39 @@
 "use strict";
 
-import verifyEquality from "../equality";
-import verifyJudgement from "../judgement";
-import verifyTypeAssertion from "../assertion/type";
-import unifyMetavariableAgainstStatement from "../../unify/metavariableAgainstStatement";
+import verifyStatement from "../../verify/statement";
 
 import { nodeQuery } from "../../utilities/query";
 
 const statementNodeQuery = nodeQuery("/qualifiedStatement/statement!"),
-      equalityNodeQuery = nodeQuery("/statement/equality!"),
-      judgementNodeQuery = nodeQuery("/statement/judgement!"),
-      metavariableNodeQuery = nodeQuery("/qualifiedStatement/reference/metavariable!"),
-      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
-
-export default function verifyQualifiedStatement(qualifiedStatementNode, substitutions, assignments, localContext) {
+      metavariableNodeQuery = nodeQuery("/qualifiedStatement/reference/metavariable!");
+
+const unifyDerivedQualifiedStatementFunctions = [
+  unifyDerivedQualifiedStatementAWithRule,
+  unifyDerivedQualifiedStatementAWithAxiom,
+  unifyDerivedQualifiedStatementAWithLemma,
+  unifyDerivedQualifiedStatementAWithTheorem,
+  unifyDerivedQualifiedStatementAWithConjecture,
+  unifyDerivedQualifiedStatementAWithReference
+];
+
+export default function verifyQualifiedStatement(qualifiedStatementNode, substitutions, assignments, derived, localContext) {
   let qualifiedStatementVerified;
 
   const qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
   localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement...`, qualifiedStatementNode);
 
-  const unifyQualifiedStatementFunctions = [
-    unifyQualifiedStatementAAgainstRule,
-    unifyQualifiedStatementAAgainstAxiom,
-    unifyQualifiedStatementAAgainstLemma,
-    unifyQualifiedStatementAAgainstTheorem,
-    unifyQualifiedStatementAAgainstConjecture,
-    unifyQualifiedStatementAAgainstReference
-  ];
+  const statementNode = statementNodeQuery(qualifiedStatementNode),
+        statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
 
-  const qualifiedStatementUnified = unifyQualifiedStatementFunctions.some((unifyQualifiedStatementFunction) => {  ///
-    const qualifiedStatementUnified = unifyQualifiedStatementFunction(qualifiedStatementNode, substitutions, localContext);
+  if (statementVerified) {
+    if (derived) {
+      const derivedQualifiedStatementVerified = verifyDerivedQualifiedStatement(qualifiedStatementNode, substitutions, localContext);
 
-    if (qualifiedStatementUnified) {
-      return true;
+      qualifiedStatementVerified = derivedQualifiedStatementVerified; ///
+    } else {
+      qualifiedStatementVerified = true;
     }
-  });
-
-  if (qualifiedStatementUnified) {
-    const derived = false,
-          statementNode = statementNodeQuery(qualifiedStatementNode),
-          statedStatementVerified = verifyStatedStatement(statementNode, assignments, derived, localContext);
-
-    qualifiedStatementVerified = statedStatementVerified; ///
   }
 
   if (qualifiedStatementVerified) {
@@ -52,8 +43,30 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, substit
   return qualifiedStatementVerified;
 }
 
-function unifyQualifiedStatementAAgainstRule(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementUnifiedAgainstRule = false;
+function verifyDerivedQualifiedStatement(qualifiedStatementNode, substitutions, localContext) {
+  let derivedQualifiedStatementVerified;
+
+  const qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+
+  localContext.trace(`Verifying the '${qualifiedStatementString}' derived qualified statement...`, qualifiedStatementNode);
+
+  const derivedQualifiedStatementUnified = unifyDerivedQualifiedStatementFunctions.some((unifyDerivedQualifiedStatementFunction) => {
+    const derivedQualifiedStatementUnified = unifyDerivedQualifiedStatementFunction(qualifiedStatementNode, substitutions, localContext);
+
+    return derivedQualifiedStatementUnified;
+  });
+
+  derivedQualifiedStatementVerified = derivedQualifiedStatementUnified; ///
+
+  if (derivedQualifiedStatementVerified) {
+    localContext.debug(`...verified the '${qualifiedStatementString}' derived qualified statement.`, qualifiedStatementNode);
+  }
+
+  return derivedQualifiedStatementVerified;
+}
+
+function unifyDerivedQualifiedStatementAWithRule(qualifiedStatementNode, substitutions, localContext) {
+  let derivedQualifiedStatementUnifiedWithRule = false;
 
   const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
         rule = localContext.findRuleByMetavariableNode(metavariableNode);
@@ -63,22 +76,22 @@ function unifyQualifiedStatementAAgainstRule(qualifiedStatementNode, substitutio
           metavariableString = localContext.nodeAsString(metavariableNode),
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' rule...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' derived qualified statement with the '${metavariableString}' rule...`, qualifiedStatementNode);
 
-    const ruleMatchesStatement = rule.unifyStatement(statementNode, localContext);
+    const statementUnified = rule.unifyStatement(statementNode, localContext);
 
-    qualifiedStatementUnifiedAgainstRule = ruleMatchesStatement;  ///
+    derivedQualifiedStatementUnifiedWithRule = statementUnified;  ///
 
-    if (qualifiedStatementUnifiedAgainstRule) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' rule.`, qualifiedStatementNode);
+    if (derivedQualifiedStatementUnifiedWithRule) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' derived qualified statement with the '${metavariableString}' rule.`, qualifiedStatementNode);
     }
   }
 
-  return qualifiedStatementUnifiedAgainstRule;
+  return derivedQualifiedStatementUnifiedWithRule;
 }
 
-function unifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementUnifiedAgainstAxiom = false;
+function unifyDerivedQualifiedStatementAWithAxiom(qualifiedStatementNode, substitutions, localContext) {
+  let derivedQualifiedStatementUnifiedWithAxiom = false;
 
   const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
         axiom = localContext.findAxiomByMetavariableNode(metavariableNode);
@@ -88,22 +101,22 @@ function unifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, substituti
           metavariableString = localContext.nodeAsString(metavariableNode),
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' axiom...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' derived qualified statement with the '${metavariableString}' axiom...`, qualifiedStatementNode);
 
-    const axiomMatchesStatement = axiom.unifyStatement(statementNode, localContext);
+    const statementUnified = axiom.unifyStatement(statementNode, localContext);
 
-    qualifiedStatementUnifiedAgainstAxiom = axiomMatchesStatement; ///
+    derivedQualifiedStatementUnifiedWithAxiom = statementUnified; ///
 
-    if (qualifiedStatementUnifiedAgainstAxiom) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' axiom.`, qualifiedStatementNode);
+    if (derivedQualifiedStatementUnifiedWithAxiom) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' derived qualified statement with the '${metavariableString}' axiom.`, qualifiedStatementNode);
     }
   }
 
-  return qualifiedStatementUnifiedAgainstAxiom;
+  return derivedQualifiedStatementUnifiedWithAxiom;
 }
 
-function unifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementUnifiedAgainstLemma = false;
+function unifyDerivedQualifiedStatementAWithLemma(qualifiedStatementNode, substitutions, localContext) {
+  let derivedQualifiedStatementUnifiedWithLemma = false;
 
   const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
         lemma = localContext.findLemmaByMetavariableNode(metavariableNode);
@@ -113,22 +126,22 @@ function unifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, substituti
           metavariableString = localContext.nodeAsString(metavariableNode),
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' lemma...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' derived qualified statement with the '${metavariableString}' lemma...`, qualifiedStatementNode);
 
-    const lemmaMatchesStatement = lemma.unifyStatement(statementNode, localContext);
+    const statementUnified = lemma.unifyStatement(statementNode, localContext);
 
-    qualifiedStatementUnifiedAgainstLemma = lemmaMatchesStatement; ///
+    derivedQualifiedStatementUnifiedWithLemma = statementUnified; ///
 
-    if (qualifiedStatementUnifiedAgainstLemma) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' lemma.`, qualifiedStatementNode);
+    if (derivedQualifiedStatementUnifiedWithLemma) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' derived qualified statement with the '${metavariableString}' lemma.`, qualifiedStatementNode);
     }
   }
 
-  return qualifiedStatementUnifiedAgainstLemma;
+  return derivedQualifiedStatementUnifiedWithLemma;
 }
 
-function unifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementUnifiedAgainstTheorem = false;
+function unifyDerivedQualifiedStatementAWithTheorem(qualifiedStatementNode, substitutions, localContext) {
+  let derivedQualifiedStatementUnifiedWithTheorem = false;
 
   const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
         theorem = localContext.findTheoremByMetavariableNode(metavariableNode);
@@ -138,22 +151,22 @@ function unifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, substitu
           metavariableString = localContext.nodeAsString(metavariableNode),
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' theorem...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' derived qualified statement with the '${metavariableString}' theorem...`, qualifiedStatementNode);
 
-    const theoremMatchesStatement = theorem.unifyStatement(statementNode, localContext);
+    const statementUnified = theorem.unifyStatement(statementNode, localContext);
 
-    qualifiedStatementUnifiedAgainstTheorem = theoremMatchesStatement; ///
+    derivedQualifiedStatementUnifiedWithTheorem = statementUnified; ///
 
-    if (qualifiedStatementUnifiedAgainstTheorem) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' theorem.`, qualifiedStatementNode);
+    if (derivedQualifiedStatementUnifiedWithTheorem) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' derived qualified statement with the '${metavariableString}' theorem.`, qualifiedStatementNode);
     }
   }
 
-  return qualifiedStatementUnifiedAgainstTheorem;
+  return derivedQualifiedStatementUnifiedWithTheorem;
 }
 
-function unifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementUnifiedAgainstConjecture = false;
+function unifyDerivedQualifiedStatementAWithConjecture(qualifiedStatementNode, substitutions, localContext) {
+  let derivedQualifiedStatementUnifiedWithConjecture = false;
 
   const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
         conjecture = localContext.findConjectureByMetavariableNode(metavariableNode);
@@ -163,145 +176,52 @@ function unifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, subst
           metavariableString = localContext.nodeAsString(metavariableNode),
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' conjecture...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' derived qualified statement with the '${metavariableString}' conjecture...`, qualifiedStatementNode);
 
-    const conjectureMatchesStatement = conjecture.unifyStatement(statementNode, localContext);
+    const statementUnified = conjecture.unifyStatement(statementNode, localContext);
 
-    qualifiedStatementUnifiedAgainstConjecture = conjectureMatchesStatement; ///
+    derivedQualifiedStatementUnifiedWithConjecture = statementUnified; ///
 
-    if (qualifiedStatementUnifiedAgainstConjecture) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' conjecture.`, qualifiedStatementNode);
+    if (derivedQualifiedStatementUnifiedWithConjecture) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' derived qualified statement with the '${metavariableString}' conjecture.`, qualifiedStatementNode);
     }
   }
 
-  return qualifiedStatementUnifiedAgainstConjecture;
+  return derivedQualifiedStatementUnifiedWithConjecture;
 }
 
-function unifyQualifiedStatementAAgainstReference(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementUnifiedAgainstReference = false;
+function unifyDerivedQualifiedStatementAWithReference(qualifiedStatementNode, substitutions, localContext) {
+  let derivedQualifiedStatementUnifiedWithReference = false;
 
   const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
         metavariableString = localContext.nodeAsString(metavariableNode),
         metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode),
         qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-  localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' reference...`, qualifiedStatementNode);
+  localContext.trace(`Unifying the '${qualifiedStatementString}' derived qualified statement with the '${metavariableString}' reference...`, qualifiedStatementNode);
 
   if (metavariablePresent) {
-    const statementNode = statementNodeQuery(qualifiedStatementNode),
-          localContextA = null,
-          localContextB = localContext, ///
-          statementNodeB = statementNode, ///
-          substitutionNodeA = null,
-          metavariableNodeA = metavariableNode, ///
-          metavariableUnifiedAgainstStatement = unifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB, () => {
-            const verifiedAhead = true;
-
-            return verifiedAhead;
-          });
-
-    qualifiedStatementUnifiedAgainstReference = metavariableUnifiedAgainstStatement; ///
-  }
-
-  if (qualifiedStatementUnifiedAgainstReference) {
-    localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' reference.`, qualifiedStatementNode);
-  }
-
-  return qualifiedStatementUnifiedAgainstReference;
-}
-
-function verifyStatedStatement(statementNode, assignments, derived, localContext) {
-  let statedStatementVerified;
-
-  const statementString = localContext.nodeAsString(statementNode);
-
-  localContext.trace(`Verifying the '${statementString}' stated statement...`, statementNode);
-
-  const verifyStatedStatementFunctions = [
-    verifyStatedStatementAsEquality,
-    verifyStatedStatementAsJudgement,
-    verifyStatedStatementAsTypeAssertion
-  ];
-
-  verifyStatedStatementFunctions.every((verifyStatedStatementFunction) => { ///
-    const statedStatementVerified = verifyStatedStatementFunction(statementNode, assignments, derived, localContext);
-
-    if (statedStatementVerified) {
-      return true;
-    }
-  });
-
-  statedStatementVerified = true; ///
 
-  if (statedStatementVerified) {
-    localContext.debug(`...verified the '${statementString}' stated statement.`, statementNode);
+    debugger
+
+    // const statementNode = statementNodeQuery(qualifiedStatementNode),
+    //       localContextA = null,
+    //       localContextB = localContext, ///
+    //       statementNodeB = statementNode, ///
+    //       substitutionNodeA = null,
+    //       metavariableNodeA = metavariableNode, ///
+    //       metavariableUnifiedWithStatement = unifyMetavariableWithStatement(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB, () => {
+    //         const verifiedAhead = true;
+    //
+    //         return verifiedAhead;
+    //       });
+    //
+    // derivedQualifiedStatementUnifiedWithReference = metavariableUnifiedWithStatement; ///
   }
 
-  return statedStatementVerified;
-}
-
-function verifyStatedStatementAsEquality(statementNode, assignments, derived, localContext) {
-  let statedStatementVerifiedAsEquality = true; ///
-
-  const equalityNode = equalityNodeQuery(statementNode);
-
-  if (equalityNode !== null) {
-    const statementString = localContext.nodeAsString(statementNode);
-
-    localContext.trace(`Verifying the '${statementString}' stated statement as an equality...`, statementNode);
-
-    const equalityVerified = verifyEquality(equalityNode, assignments, derived, localContext);
-
-    statedStatementVerifiedAsEquality = equalityVerified; ///
-
-    if (statedStatementVerifiedAsEquality) {
-      localContext.debug(`...verified the '${statementString}' stated statement as an equality.`, statementNode);
-    }
-  }
-
-  return statedStatementVerifiedAsEquality;
-}
-
-function verifyStatedStatementAsJudgement(statementNode, assignments, derived, localContext) {
-  let statedStatementVerifiedAsJudgement = true;
-
-  const judgementNode = judgementNodeQuery(statementNode);
-
-  if (judgementNode !== null) {
-    const statementString = localContext.nodeAsString(statementNode);
-
-    localContext.trace(`Verifying the '${statementString}' stated statement as a judgement...`, statementNode);
-
-    const judgementVerified = verifyJudgement(judgementNode, assignments, derived, localContext);
-
-    statedStatementVerifiedAsJudgement = judgementVerified;  ///
-
-    if (statedStatementVerifiedAsJudgement) {
-      localContext.debug(`...verified the '${statementString}' stated statement as a judgement.`, statementNode);
-    }
-  }
-
-  return statedStatementVerifiedAsJudgement;
-}
-
-function verifyStatedStatementAsTypeAssertion(statementNode, assignments, derived, localContext) {
-  let statementVerifiedAsTypeAssertion = true;  ///
-
-  const typeAssertionNode = typeAssertionNodeQuery(statementNode);
-
-  if (typeAssertionNode !== null) {
-    const statementString = localContext.nodeAsString(statementNode);
-
-    localContext.trace(`Verifying the '${statementString}' stated statement as a type assertion...`, statementNode);
-
-    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, localContext);
-
-    statementVerifiedAsTypeAssertion = typeAssertionVerified; ///
-
-    if (statementVerifiedAsTypeAssertion) {
-      localContext.debug(`...verified the '${statementString}' stated statement as a type assertion.`, statementNode);
-    }
+  if (derivedQualifiedStatementUnifiedWithReference) {
+    localContext.debug(`...unified the '${qualifiedStatementString}' derived qualified statement with the '${metavariableString}' reference.`, qualifiedStatementNode);
   }
 
-  return statementVerifiedAsTypeAssertion;
+  return derivedQualifiedStatementUnifiedWithReference;
 }