occam-verify-cli 0.0.892 → 0.0.893

package/src/verify/derivation.js

@@ -1,151 +1,23 @@
 "use strict";
 
-import ProofStep from "../step/proof";
-import LocalContext from "../context/local";
-import verifySuppositions from "../verify/suppositions";
-import verifyQualifiedStatement from "../verify/statement/qualified";
-import verifyUnqualifiedStatement from "../verify/statement/unqualified";
+import verifyProofStep from "../verify/proofStep";
 
-import { assignAssignment } from "../utilities/assignments";
-import { nodeQuery, nodesQuery } from "../utilities/query";
-import { SUBPROOF_RULE_NAME, QUALIFIED_STATEMENT_RULE_NAME, UNQUALIFIED_STATEMENT_RULE_NAME } from "../ruleNames";
+import { nodesQuery } from "../utilities/query";
 
-const childNodesQuery = nodesQuery("/derivation|subDerivation/*"),
-      statementNodeQuery = nodeQuery("/qualifiedStatement|unqualifiedStatement/statement!"),
-      suppositionNodesQuery = nodesQuery("/subproof/supposition"),
-      subDerivationNodeQuery = nodeQuery("/subproof/subDerivation");
+const proofStepNodesQuery = nodesQuery("/derivation/proofStep|lastProofStep");
 
-export default function verifyDerivation(derivationNode, localContext) {
-  let derivationVerified;
+export default function verifyDerivation(ruleDerivationNode, localMetaContext) {
+  let ruleDerivationVerified;
 
-  const childNodes = childNodesQuery(derivationNode);
+  const proofStepNodes = proofStepNodesQuery(ruleDerivationNode);
 
-  derivationVerified = childNodes.every((childNode) => {
-    const childVerified = verifyChild(childNode, localContext);
+  ruleDerivationVerified = proofStepNodes.every((proofStepNode) => {
+    const proofStepVerified = verifyProofStep(proofStepNode, localMetaContext);
 
-    if (childVerified) {
+    if (proofStepVerified) {
       return true;
     }
   });
 
-  return derivationVerified;
-}
-
-function verifySubDerivation(subDerivationNode, localContext) {
-  let subDerivationVerified;
-
-  const childNodes = childNodesQuery(subDerivationNode);
-
-  subDerivationVerified = childNodes.every((childNode) => {
-    const childVerified = verifyChild(childNode, localContext);
-
-    if (childVerified) {
-      return true;
-    }
-  });
-
-  return subDerivationVerified;
-}
-
-function verifySubproof(subproofNode, localContext) {
-  let subproofVerified = false;
-
-  localContext = LocalContext.fromLocalContext(localContext); ///
-
-  const suppositions = [],
-        suppositionNodes = suppositionNodesQuery(subproofNode),
-        suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
-
-  if (suppositionsVerified) {
-    const subDerivationNode = subDerivationNodeQuery(subproofNode),
-          subDerivationVerified = verifySubDerivation(subDerivationNode, localContext);
-
-    if (subDerivationVerified) {
-      subproofVerified = true;
-    }
-  }
-
-  return subproofVerified;
-}
-
-function verifyChild(childNode, localContext) {
-  let childVerified = false;
-
-  const childNodeRuleName = childNode.getRuleName();
-
-  switch (childNodeRuleName) {
-    case SUBPROOF_RULE_NAME: {
-      let subproofVerified;
-
-      const subproofNode = childNode;  ///
-
-      subproofVerified = verifySubproof(subproofNode, localContext);
-
-      if (subproofVerified) {
-        const proofStep = ProofStep.fromSubproofNode(subproofNode);
-
-        localContext.addProofStep(proofStep);
-
-        childVerified = true;
-      }
-
-      break;
-    }
-
-    case QUALIFIED_STATEMENT_RULE_NAME: {
-      let qualifiedStatementVerified;
-
-      const derived = true,
-            assignments = [],
-            qualifiedStatementNode = childNode;  ///
-
-      qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, assignments, derived, localContext);
-
-      if (qualifiedStatementVerified) {
-        const assignmentAssigned = assignAssignment(assignments, localContext);
-
-        qualifiedStatementVerified = assignmentAssigned; ///
-      }
-
-      if (qualifiedStatementVerified) {
-        const statementNode = statementNodeQuery(qualifiedStatementNode),
-              proofStep = ProofStep.fromStatementNode(statementNode);
-
-        localContext.addProofStep(proofStep);
-
-        childVerified = true; ///
-      }
-
-      break;
-    }
-
-    case UNQUALIFIED_STATEMENT_RULE_NAME: {
-      let unqualifiedStatementVerified;
-
-      const derived = true,
-            assignments = [],
-            unqualifiedStatementNode = childNode;  ///
-
-      unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
-
-      if (unqualifiedStatementVerified) {
-        const assignmentAssigned = assignAssignment(assignments, localContext);
-
-        unqualifiedStatementVerified = assignmentAssigned;  ///
-      }
-
-      if (unqualifiedStatementVerified) {
-        const statementNode = statementNodeQuery(unqualifiedStatementNode),
-              proofStep = ProofStep.fromStatementNode(statementNode);
-
-        localContext.addProofStep(proofStep);
-
-        childVerified = true;
-      }
-
-      break;
-    }
-  }
-
-  return childVerified;
+  return ruleDerivationVerified;
 }

package/src/verify/metaDerivation.js

@@ -1,151 +1,23 @@
 "use strict";
 
-import MetaproofStep from "../step/metaproof";
-import LocalMetaContext from "../context/localMeta";
-import verifyMetaSuppositions from "../verify/metaSuppositions";
-import verifyQualifiedMetastatement from "../verify/metastatement/qualified";
-import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
+import verifyMetaProofStep from "../verify/metaProofStep";
 
-import { assignAssignment } from "../utilities/assignments";
-import { nodeQuery, nodesQuery } from "../utilities/query";
-import { META_SUBPROOF_RULE_NAME, QUALIFIED_METASTATEMENT_RULE_NAME, UNQUALIFIED_METASTATEMENT_RULE_NAME } from "../ruleNames";
+import { nodesQuery } from "../utilities/query";
 
-const childNodesQuery = nodesQuery("/metaDerivation|metaSubDerivation/*"),
-      metastatementNodeQuery = nodeQuery("/qualifiedMetastatement|unqualifiedMetastatement/metastatement!"),
-      metaSuppositionNodesQuery = nodesQuery("/metaSubproof/metaSupposition"),
-      metaSubDerivationNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation");
+const metaProofStepNodesQuery = nodesQuery("/metaDerivation/metaProofStep|lastMetaProofStep");
 
 export default function verifyMetaDerivation(metaDerivationNode, substitutions, localMetaContext) {
   let metaDerivationVerified;
 
-  const childNodes = childNodesQuery(metaDerivationNode);
+  const metaProofStepNodes = metaProofStepNodesQuery(metaDerivationNode);
 
-  metaDerivationVerified = childNodes.every((childNode) => {
-    const childVerified = verifyChild(childNode, substitutions, localMetaContext);
+  metaDerivationVerified = metaProofStepNodes.every((metaProofStepNode) => {
+    const metaProofStepVerified = verifyMetaProofStep(metaProofStepNode, substitutions, localMetaContext);
 
-    if (childVerified) {
+    if (metaProofStepVerified) {
       return true;
     }
   });
 
   return metaDerivationVerified;
 }
-
-function verifyMetaSubDerivation(metaSubDerivationNode, substitutions, localMetaContext) {
-  let metaSubDerivationVerified;
-
-  const childNodes = childNodesQuery(metaSubDerivationNode);
-
-  metaSubDerivationVerified = childNodes.every((childNode) => {
-    const childVerified = verifyChild(childNode, substitutions, localMetaContext);
-
-    if (childVerified) {
-      return true;
-    }
-  });
-
-  return metaSubDerivationVerified;
-}
-
-function verifyMetaSubproof(metaSubproofNode, substitutions, localMetaContext) {
-  let metaSubproofVerified = false;
-
-  localMetaContext = LocalMetaContext.fromLocalMetaContext(localMetaContext); ///
-
-  const metaSuppositions = [],
-        metaSuppositionNodes = metaSuppositionNodesQuery(metaSubproofNode),
-        metaSuppositionsVerified = verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, substitutions, localMetaContext);
-
-  if (metaSuppositionsVerified) {
-    const metaSubDerivationNode = metaSubDerivationNodeQuery(metaSubproofNode),
-          metaSubDerivationVerified = verifyMetaSubDerivation(metaSubDerivationNode, substitutions, localMetaContext);
-
-    if (metaSubDerivationVerified) {
-      metaSubproofVerified = true;
-    }
-  }
-
-  return metaSubproofVerified;
-}
-
-function verifyChild(childNode, substitutions, localMetaContext) {
-  let childVerified = false;
-
-  const childNodeRuleName = childNode.getRuleName();
-
-  switch (childNodeRuleName) {
-    case META_SUBPROOF_RULE_NAME: {
-      let metaSubproofVerified;
-
-      const metaSubproofNode = childNode;  ///
-
-      metaSubproofVerified = verifyMetaSubproof(metaSubproofNode, substitutions, localMetaContext);
-
-      if (metaSubproofVerified) {
-        const metaproofStep = MetaproofStep.fromMetaSubproofNode(metaSubproofNode);
-
-        localMetaContext.addMetaproofStep(metaproofStep);
-
-        childVerified = true;
-      }
-
-      break;
-    }
-
-    case QUALIFIED_METASTATEMENT_RULE_NAME: {
-      let qualifiedMetastatementVerified;
-
-      const derived = true,
-            assignments = [],
-            qualifiedMetastatementNode = childNode;  ///
-
-      qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, substitutions, assignments, derived, localMetaContext);
-
-      if (qualifiedMetastatementVerified) {
-        const assignmentAssigned = assignAssignment(assignments, localMetaContext);
-
-        qualifiedMetastatementVerified = assignmentAssigned; ///
-      }
-
-      if (qualifiedMetastatementVerified) {
-        const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
-              metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
-
-        localMetaContext.addMetaproofStep(metaproofStep);
-
-        childVerified = true; ///
-      }
-
-      break;
-    }
-
-    case UNQUALIFIED_METASTATEMENT_RULE_NAME: {
-      let unqualifiedMetastatementVerified;
-
-      const derived = true,
-            assignments = [],
-            unqualifiedMetastatementNode = childNode;  ///
-
-      unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
-
-      if (unqualifiedMetastatementVerified) {
-        const assignmentAssigned = assignAssignment(assignments, localMetaContext);
-
-        unqualifiedMetastatementVerified = assignmentAssigned;  ///
-      }
-
-      if (unqualifiedMetastatementVerified) {
-        const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
-              metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
-
-        localMetaContext.addMetaproofStep(metaproofStep);
-
-        childVerified = true;
-      }
-
-      break;
-    }
-  }
-
-  return childVerified;
-}

package/src/verify/metaProofStep.js

@@ -0,0 +1,98 @@
+"use strict";
+
+import MetaproofStep from "../step/metaproof";
+import verifyMetaSubproof from "../verify/metaSubproof";
+import verifyMetaSubDerivation from "../verify/metaSubDerivation";
+import verifyQualifiedStatement from "../verify/statement/qualified";
+import verifyUnqualifiedStatement from "../verify/statement/unqualified";
+import verifyQualifiedMetastatement from "../verify/metastatement/qualified";
+import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
+
+import { nodeQuery } from "../utilities/query";
+import { assignAssignment } from "../utilities/assignments";
+
+const metaSubproofNodeQuery = nodeQuery("/metaProofStep|lastMetaProofStep/metaSubproof!"),
+      metastatementNodeQuery = nodeQuery("/qualifiedMetastatement|unqualifiedMetastatement/metastatement!"),
+      qualifiedStatementNodeQuery = nodeQuery("/metaProofStep|lastMetaProofStep/qualifiedStatement!"),
+      unqualifiedStatementNodeQuery = nodeQuery("/metaProofStep|lastMetaProofStep/unqualifiedStatement!"),
+      qualifiedMetastatementNodeQuery = nodeQuery("/metaProofStep|lastMetaProofStep/qualifiedMetastatement!"),
+      unqualifiedMetastatementNodeQuery = nodeQuery("/metaProofStep|lastMetaProofStep/unqualifiedMetastatement!");
+
+export default function verifyMetaProofStep(metaProofStepNode, substitutions, localMetaContext) {
+  let metaProofStepVerified = false;
+
+  const metaSubproofNode = metaSubproofNodeQuery(metaProofStepNode),
+        qualifiedStatementNode = qualifiedStatementNodeQuery(metaProofStepNode),
+        unqualifiedStatementNode = unqualifiedStatementNodeQuery(metaProofStepNode),
+        qualifiedMetastatementNode = qualifiedMetastatementNodeQuery(metaProofStepNode),
+        unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(metaProofStepNode);
+
+  if (false) {
+    ///
+  } else if (metaSubproofNode !== null) {
+    let metaSubproofVerified;
+
+    metaSubproofVerified = verifyMetaSubproof(metaSubproofNode, localMetaContext);
+
+    if (metaSubproofVerified) {
+      const metaproofStep = MetaproofStep.fromMetaSubproofNode(metaSubproofNode);
+
+      localMetaContext.addMetaproofStep(metaproofStep);
+
+      metaProofStepVerified = true;
+    }
+  } else if (qualifiedStatementNode !== null) {
+    debugger
+  } else if (unqualifiedStatementNode !== null) {
+    debugger
+  } else if (qualifiedMetastatementNode !== null) {
+    let qualifiedMetastatementVerified;
+
+    const assignments = [];
+
+    qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, substitutions, assignments, localMetaContext);
+
+    if (qualifiedMetastatementVerified) {
+      const assignmentAssigned = assignAssignment(assignments, localMetaContext);
+
+      qualifiedMetastatementVerified = assignmentAssigned; ///
+    }
+
+    if (qualifiedMetastatementVerified) {
+      const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
+            metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
+
+      localMetaContext.addMetaproofStep(metaproofStep);
+
+      metaProofStepVerified = qualifiedMetastatementVerified; ///
+    }
+  } else if (unqualifiedMetastatementNode !== null) {
+    let unqualifiedMetastatementVerified;
+
+    const derived = true,
+          assignments = [];
+
+    unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
+
+    if (unqualifiedMetastatementVerified) {
+      const assignmentAssigned = assignAssignment(assignments, localMetaContext);
+
+      unqualifiedMetastatementVerified = assignmentAssigned; ///
+    }
+
+    if (unqualifiedMetastatementVerified) {
+      const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
+            metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
+
+      localMetaContext.addMetaproofStep(metaproofStep);
+
+      metaProofStepVerified = true;
+    }
+  }
+
+  return metaProofStepVerified;
+}
+
+Object.assign(verifyMetaSubDerivation, {
+  verifyMetaProofStep
+});

package/src/verify/metaSubDerivation.js

@@ -0,0 +1,22 @@
+"use strict";
+
+import { nodesQuery } from "../utilities/query";
+
+const metaProofStepNodesQuery = nodesQuery("/metaSubDerivation/metaProofStep|lastMetaProofStep");
+
+export default function verifyMetaSubDerivation(metaSubDerivationNode, localMetaContext) {
+  let metaSubDerivationVerified;
+
+  const metaProofStepNodes = metaProofStepNodesQuery(metaSubDerivationNode);
+
+  metaSubDerivationVerified = metaProofStepNodes.every((metaProofStepNode) => {
+    const { verifyMetaProofStep } = verifyMetaSubDerivation,
+          metaProofStepVerified = verifyMetaProofStep(metaProofStepNode, localMetaContext);
+
+    if (metaProofStepVerified) {
+      return true;
+    }
+  });
+
+  return metaSubDerivationVerified;
+}

package/src/verify/metaSubproof.js

@@ -0,0 +1,32 @@
+"use strict";
+
+import LocalMetaContext from "../context/localMeta";
+import verifyMetaSuppositions from "../verify/metaSuppositions";
+import verifyMetaSubDerivation from "../verify/metaSubDerivation";
+
+import { nodeQuery, nodesQuery } from "../utilities/query";
+
+const suppositionNodesQuery = nodesQuery("/metaSubproof/supposition"),
+      metaSubDerivationNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation");
+
+export default function verifyMetaSubproof(metaSubproofNode, localMetaContext) {
+  let metaSubproofVerified = false;
+
+  localMetaContext = LocalMetaContext.fromLocalMetaContext(localMetaContext); ///
+
+  const metaSuppositions = [],
+        suppositionNodes = suppositionNodesQuery(metaSubproofNode),
+        metaSuppositionsVerified = verifyMetaSuppositions(suppositionNodes, metaSuppositions, localMetaContext);
+
+  if (metaSuppositionsVerified) {
+    const metaSubDerivationNode = metaSubDerivationNodeQuery(metaSubproofNode),
+          metaSubDerivationVerified = verifyMetaSubDerivation(metaSubDerivationNode, localMetaContext);
+
+    if (metaSubDerivationVerified) {
+      metaSubproofVerified = true;
+    }
+  }
+
+  return metaSubproofVerified;
+}
+

package/src/verify/metaproof.js

@@ -1,28 +1,28 @@
 "use strict";
 
+import LocalMetaContext from "../context/localMeta";
 import verifyMetaDerivation from "../verify/metaDerivation";
 
 import { nodeQuery } from "../utilities/query";
 
 const metaDerivationNodeQuery = nodeQuery("/metaproof/metaDerivation!");
 
-export default function verifyMetaproof(metaproofNode, conclusion, substitutions, localMetaproof) {
+export default function verifyMetaproof(metaproofNode, conclusion, substitutions, localMetaContext) {
   let metaproofVerified = false;
 
+  localMetaContext = LocalMetaContext.fromLocalMetaContext(localMetaContext); ///
+
   const metaDerivationNode = metaDerivationNodeQuery(metaproofNode),
-        metaDerivationVerified = verifyMetaDerivation(metaDerivationNode, substitutions, localMetaproof);
+        metaDerivationVerified = verifyMetaDerivation(metaDerivationNode, substitutions, localMetaContext);
 
   if (metaDerivationVerified) {
-    const lastMetaproofStep = localMetaproof.getLastMetaproofStep();
-
-    if (lastMetaproofStep !== null) {
-      const metaproofStep = lastMetaproofStep, ///
-            metastatementNode = metaproofStep.getMetastatementNode(),
-            conclusionMetastatementNode = conclusion.getMetastatementNode(),
-            metastatementNodeMatchesConclusionMetastatementNode = metastatementNode.match(conclusionMetastatementNode);
+    const lastMetaproofStep = localMetaContext.getLastMetaproofStep(),
+          metaproofStep = lastMetaproofStep, ///
+          metastatementNode = metaproofStep.getMetastatementNode(),
+          conclusionMetastatementNode = conclusion.getMetastatementNode(),
+          metastatementNodeMatchesConclusionMetastatementNode = metastatementNode.match(conclusionMetastatementNode);
 
-      metaproofVerified = metastatementNodeMatchesConclusionMetastatementNode;  ///
-    }
+    metaproofVerified = metastatementNodeMatchesConclusionMetastatementNode;  ///
   }
 
   return metaproofVerified;

package/src/verify/metastatement/qualified.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import verifyMetastatement from "../metastatement";
+import verifyMetastatement from "../../verify/metastatement";
 import verifyMetavariableAgainstMetastatement from "../../verify/metavariableAgainstMetastatement";
 
 import { nodeQuery } from "../../utilities/query";
@@ -8,57 +8,93 @@ import { nodeQuery } from "../../utilities/query";
 const metavariableNodeQuery = nodeQuery("/qualifiedMetastatement/reference!/metavariable!"),
       metastatementNodeQuery = nodeQuery("/qualifiedMetastatement/metastatement!");
 
-export default function verifyQualifiedMetastatement(qualifiedMetastatementNode, substitutions, assignments, derived, localMetaContext) {
-  let qualifiedMetastatementVerified = false;
+export default function verifyQualifiedMetastatement(qualifiedMetastatementNode, substitutions, assignments, localMetaContext) {
+  let qualifiedMetastatementVerified;
 
-  const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode);
+  const qualifiedMetastatementString = localMetaContext.nodeAsString(qualifiedMetastatementNode);
 
-  if (metastatementNode !== null) {
-    const metastatementString = localMetaContext.nodeAsString(metastatementNode),
-          metastatementLocalMetaContext = localMetaContext; ///
+  localMetaContext.trace(`Verifying the '${qualifiedMetastatementString}' qualified metastatement...`, qualifiedMetastatementNode);
 
-    localMetaContext.trace(`Verifying the '${metastatementString}' qualified metastatement...`, qualifiedMetastatementNode);
+  const derived = false,
+        metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
+        metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localMetaContext, () => {
+          const verifiedAhead = true;
 
-    const metavariableNode = metavariableNodeQuery(qualifiedMetastatementNode);
+          return verifiedAhead;
+        });
 
-    if (!qualifiedMetastatementVerified) {
-      const rule = localMetaContext.findRuleByMetavariableNode(metavariableNode);
+  if (metastatementVerified) {
+    const metavariableNode = metavariableNodeQuery(qualifiedMetastatementNode),
+          verifyQualifiedMetastatementFunctions = [
+            verifyQualifiedMetastatementAAgainstRule,
+            verifyQualifiedMetastatementAAgainstReference
+          ];
 
-      if (rule !== null) {
-        const ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, metastatementLocalMetaContext);
+    qualifiedMetastatementVerified = verifyQualifiedMetastatementFunctions.some((verifyQualifiedMetastatementFunction) => {  ///
+      const qualifiedMetastatementVerified = verifyQualifiedMetastatementFunction(qualifiedMetastatementNode, metavariableNode, substitutions, localMetaContext);
 
-        qualifiedMetastatementVerified = ruleMatchesMetastatement;  ///
+      if (qualifiedMetastatementVerified) {
+        return true;
       }
+    });
+  }
+
+  if (qualifiedMetastatementVerified) {
+    localMetaContext.debug(`...verified the '${qualifiedMetastatementString}' qualified metastatement.`, qualifiedMetastatementNode);
+  }
+
+  return qualifiedMetastatementVerified;
+}
+
+function verifyQualifiedMetastatementAAgainstRule(qualifiedMetastatementNode, metavariableNode, substitutions, localMetaContext) {
+  let qualifiedMetastatementVerifiedAgainstRule = false;
+
+  const rule = localMetaContext.findRuleByMetavariableNode(metavariableNode);
+
+  if (rule !== null) {
+    const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
+          metavariableString = localMetaContext.nodeAsString(metavariableNode),
+          qualifiedMetastatementString = localMetaContext.nodeAsString(qualifiedMetastatementNode);
+
+    localMetaContext.trace(`Verifying the '${qualifiedMetastatementString}' qualified metastatement against the '${metavariableString}' rule...`, qualifiedMetastatementNode);
+
+    const ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, localMetaContext);
+
+    qualifiedMetastatementVerifiedAgainstRule = ruleMatchesMetastatement;  ///
+
+    if (qualifiedMetastatementVerifiedAgainstRule) {
+      localMetaContext.debug(`...verified the '${qualifiedMetastatementString}' qualified metastatement against the '${metavariableString}' rule.`, qualifiedMetastatementNode);
     }
+  }
 
-    if (!qualifiedMetastatementVerified) {
-      if (substitutions !== null) {
-        const metavariablePresent = localMetaContext.isMetavariablePresentByMetavariableNode(metavariableNode, localMetaContext);
+  return qualifiedMetastatementVerifiedAgainstRule;
+}
+
+function verifyQualifiedMetastatementAAgainstReference(qualifiedMetastatementNode, metavariableNode, substitutions, localMetaContext) {
+  let qualifiedMetastatementVerifiedAgainstReference = false;
 
-        if (metavariablePresent) {
-          const metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localMetaContext, () => {
-            const verifiedAhead = true;
+  if (substitutions !== null) {
+    const metavariableString = localMetaContext.nodeAsString(metavariableNode),
+          metavariablePresent = localMetaContext.isMetavariablePresentByMetavariableNode(metavariableNode, localMetaContext),
+          qualifiedMetastatementString = localMetaContext.nodeAsString(qualifiedMetastatementNode);
 
-            return verifiedAhead;
-          });
+    localMetaContext.trace(`Verifying the '${qualifiedMetastatementString}' qualified metastatement against the '${metavariableString}' reference...`, qualifiedMetastatementNode);
 
-          if (metastatementVerified) {
-            const metavariableVerifiedAgainstMetastatement = verifyMetavariableAgainstMetastatement(metavariableNode, metastatementNode, substitutions, () => {
+    if (metavariablePresent) {
+      const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
+            metavariableVerifiedAgainstMetastatement = verifyMetavariableAgainstMetastatement(metavariableNode, metastatementNode, substitutions, () => {
               const verifiedAhead = true;
 
               return verifiedAhead;
             });
 
-            qualifiedMetastatementVerified = metavariableVerifiedAgainstMetastatement; ///
-          }
-        }
-      }
+      qualifiedMetastatementVerifiedAgainstReference = metavariableVerifiedAgainstMetastatement; ///
     }
 
-    if (qualifiedMetastatementVerified) {
-      localMetaContext.debug(`...verified the '${metastatementString}' qualified metastatement.`, qualifiedMetastatementNode);
+    if (qualifiedMetastatementVerifiedAgainstReference) {
+      localMetaContext.debug(`...verified the '${qualifiedMetastatementString}' qualified metastatement against the '${metavariableString}' reference.`, qualifiedMetastatementNode);
     }
   }
 
-  return qualifiedMetastatementVerified;
+  return qualifiedMetastatementVerifiedAgainstReference;
 }