occam-verify-cli 0.0.262

package/bin/verify/metaAntecedent.js

@@ -0,0 +1,35 @@
+"use strict";
+
+const MetaAntecedent = require("../metaAntecedent"),
+      verifyUnqualifiedMetastatement = require("../verify/metastatement/unqualified");
+
+const { nodeQuery, nodesQuery } = require("../utilities/query");
+
+const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement"),
+      unqualifiedMetastatementNodesQuery = nodesQuery("/metaAntecedent/unqualifiedMetastatement");
+
+function verifyMetaAntecedent(metaAntecedentNode, metaAntecedents, context) {
+  const unqualifiedMetastatementNodes = unqualifiedMetastatementNodesQuery(metaAntecedentNode),
+        metaAntecedentVerified = unqualifiedMetastatementNodes.every((unqualifiedMetastatementNode) => {
+          const unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
+
+          if (unqualifiedMetastatementVerified) {
+            return true;
+          }
+        });
+
+  if (metaAntecedentVerified) {
+    const metastatementNodes = unqualifiedMetastatementNodes.map((unqualifiedMetastatementNode) => {
+            const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
+
+            return metastatementNode;
+          }),
+          metaAntecedent = MetaAntecedent.fromMetastatementNodes(metastatementNodes);
+
+    metaAntecedents.push(metaAntecedent);
+  }
+
+  return metaAntecedentVerified;
+}
+
+module.exports = verifyMetaAntecedent;

package/bin/verify/metaConsequent.js

@@ -0,0 +1,32 @@
+"use strict";
+
+const MetaConsequent = require("../metaConsequent"),
+      verifyUnqualifiedMetaStatement = require("../verify/metastatement/unqualified");
+
+const { nodeQuery } = require("../utilities/query");
+
+const metastatementNodeQuery = nodeQuery("/unqualifiedMetaStatement/metastatement!"),
+      unqualifiedMetaStatementNodeQuery = nodeQuery("/metaConsequent/unqualifiedMetaStatement!");
+
+function verifyMetaConsequent(metaConsequentNode, metaConsequents, context) {
+  let metaConsequentVerified = false;
+
+  const unqualifiedMetaStatementNode = unqualifiedMetaStatementNodeQuery(metaConsequentNode);
+
+  if (unqualifiedMetaStatementNode !== null) {
+    const unqualifiedMetaStatementVerified = verifyUnqualifiedMetaStatement(unqualifiedMetaStatementNode, context);
+
+    if (unqualifiedMetaStatementVerified) {
+      const metastatementNode = metastatementNodeQuery(unqualifiedMetaStatementNode),
+            metaConsequent = MetaConsequent.fromMetaStatementNode(metastatementNode);
+
+      metaConsequents.push(metaConsequent);
+
+      metaConsequentVerified = true;
+    }
+  }
+
+  return metaConsequentVerified;
+}
+
+module.exports = verifyMetaConsequent;

package/bin/verify/metaDerivation.js

@@ -0,0 +1,105 @@
+"use strict";
+
+const MetaproofContext = require("../context/metaproof"),
+      verifyMetaAntecedent = require("../verify/metaAntecedent"),
+      verifyQualifiedMetastatement = require("../verify/metastatement/qualified"),
+      verifyUnqualifiedMetastatement = require("../verify/metastatement/unqualified");
+
+const { nodeQuery, nodesQuery } = require("../utilities/query"),
+      { META_SUBLEMMA_RULE_NAME, QUALIFIED_METASTATEMENT_RULE_NAME, UNQUALIFIED_METASTATEMENT_RULE_NAME } = require("../ruleNames");
+
+const metaAntecedentNodeQuery = nodeQuery("/metaSublemma/metaAntecedent!"),
+      metaDerivationNodeQuery = nodeQuery("/metaSublemma/metaDerivation!"),
+      metaSublemmaChildNodesQuery = nodesQuery("/metaDerivation/*"),
+      qualifiedMetastatementNodeQuery = nodeQuery("/metaSublemma/qualifiedMetastatement!"),
+      unqualifiedMetastatementNodeQuery = nodeQuery("/metaSublemma/unqualifiedMetastatement!");
+
+function verifyMetaDerivation(metaNode, context) {
+  const derived = true;
+
+  context.setDerived(derived);
+
+  const metaSublemmaChildNodes = metaSublemmaChildNodesQuery(metaNode),
+        metaSublemmaChildNodesVerified = metaSublemmaChildNodes.every((metaSublemmaChildNode) => {
+          let metaSublemmaChildNodeVerified;
+
+          const ruleName = metaSublemmaChildNode.getRuleName();
+
+          switch (ruleName) {
+            case META_SUBLEMMA_RULE_NAME: {
+              const metaSublemmaNode = metaSublemmaChildNode,  ///
+                    metaSublemmaVerified = verifyMetaSublemma(metaSublemmaNode, context);
+
+              metaSublemmaChildNodeVerified = metaSublemmaVerified;  ///
+
+              break;
+            }
+
+            case QUALIFIED_METASTATEMENT_RULE_NAME: {
+              const qualifiedMetastatementNode = metaSublemmaChildNode,  ///
+                    qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, context);
+
+              metaSublemmaChildNodeVerified = qualifiedMetastatementVerified;  ///
+
+              break;
+            }
+
+            case UNQUALIFIED_METASTATEMENT_RULE_NAME: {
+              const unqualifiedMetastatementNode = metaSublemmaChildNode,  ///
+                    unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
+
+              metaSublemmaChildNodeVerified = unqualifiedMetastatementVerified;  ///
+
+              break;
+            }
+          }
+
+          return metaSublemmaChildNodeVerified;
+        }),
+        metaDerivationVerified = metaSublemmaChildNodesVerified;  ///
+
+  return metaDerivationVerified;
+}
+
+module.exports = verifyMetaDerivation;
+
+function verifyMetaSublemma(metaSublemmaNode, context) {
+  let metaSublemmaVerified = false;
+
+  const metaproofContext = MetaproofContext.fromContext(context);
+
+  context = metaproofContext; ///
+
+  const metaAntecedents = [],
+        metaAntecedentNode = metaAntecedentNodeQuery(metaSublemmaNode),
+        metaAntecedentVerified = verifyMetaAntecedent(metaAntecedentNode, metaAntecedents, context);
+
+  if (metaAntecedentVerified) {
+    let metaDerivationVerified = true;
+
+    const metaDerivationNode = metaDerivationNodeQuery(metaSublemmaNode);
+
+    if (metaDerivationNode !== null) {
+      metaDerivationVerified = verifyMetaDerivation(metaDerivationNode, context);
+    }
+
+    if (metaDerivationVerified) {
+      const qualifiedMetastatementNode = qualifiedMetastatementNodeQuery(metaSublemmaNode),
+            unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(metaSublemmaNode);
+
+      if (qualifiedMetastatementNode !== null) {
+        const qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, context);
+
+        metaSublemmaVerified = qualifiedMetastatementVerified;  ///
+      }
+
+      if (unqualifiedMetastatementNode !== null) {
+        const unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
+
+        metaSublemmaVerified = unqualifiedMetastatementVerified;  ///
+      }
+    }
+  }
+
+  return metaSublemmaVerified;
+}

package/bin/verify/metaproof.js

@@ -0,0 +1,46 @@
+"use strict";
+
+const verifyMetaDerivation = require("../verify/metaDerivation"),
+      verifyQualifiedMetastatement = require("../verify/metastatement/qualified");
+
+const { first } = require("../utilities/array"),
+      { nodeQuery } = require("../utilities/query"),
+      { nodeAsString } = require("../utilities/string");
+
+const metastatementNodeQuery = nodeQuery("/qualifiedMetastatement!/metastatement!"),
+      metaDerivationNodeQuery = nodeQuery("/metaproof/metaDerivation!"),
+      qualifiedStatementNodeQuery = nodeQuery("/metaproof/qualifiedMetastatement!");
+
+function verifyMetaproof(metaproofNode, rules, context) {
+  let metaproofVerified = false;
+
+  const metaDerivationNode = metaDerivationNodeQuery(metaproofNode);
+
+  let metaDerivationVerified = false;
+
+  if (metaDerivationNode !== null) {
+    metaDerivationVerified = verifyMetaDerivation(metaDerivationNode, context);
+  }
+
+  if (metaDerivationVerified) {
+    const qualifiedMetastatementNode = qualifiedStatementNodeQuery(metaproofNode),
+          qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, context);
+
+    if (qualifiedMetastatementVerified) {
+      const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
+            firstRule = first(rules),
+            rule = firstRule, ///
+            metastatementString = nodeAsString(metastatementNode),
+            conclusionMetastatementNode = rule.getConclusionMetastatementNode(),
+            conclusionMetastatementString = nodeAsString(conclusionMetastatementNode);
+
+      if (metastatementString === conclusionMetastatementString) {
+        metaproofVerified = true;
+      }
+    }
+  }
+
+  return metaproofVerified;
+}
+
+module.exports = verifyMetaproof;

package/bin/verify/metastatement/qualified.js

@@ -0,0 +1,43 @@
+"use strict";
+
+const { loggingUtilities } = require("necessary");
+
+const { matchRule } = require("../../utilities/rule"),
+      { nodeAsString } = require("../../utilities/string"),
+      { nodeQuery, referenceNameFromReferenceNode } = require("../../utilities/query");
+
+const { log } = loggingUtilities;
+
+const referenceNodeQuery = nodeQuery("/qualifiedMetastatement/qualification!/reference!"),
+      metastatementNodeQuery = nodeQuery("/qualifiedMetastatement/metastatement!");
+
+function verifyQualifiedMetastatement(qualifiedMetastatementNode, context) {
+  let qualifiedMetastatementVerified = false;
+
+  const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode);
+
+  if (metastatementNode !== null) {
+    const referenceNode = referenceNodeQuery(qualifiedMetastatementNode),
+          referenceName = referenceNameFromReferenceNode(referenceNode),
+          rule = context.findRuleByReferenceName(referenceName);
+
+    if (rule !== null) {
+      const ruleMatches = matchRule(rule, metastatementNode, context);
+
+      if (ruleMatches) {
+        context.addMetastatementNode(metastatementNode);
+
+        const metastatementString = nodeAsString(metastatementNode);
+
+        log.info(`Verified the '${metastatementString}' qualified metastatement.`);
+
+        qualifiedMetastatementVerified = true;
+      }
+    }
+  }
+
+  return qualifiedMetastatementVerified;
+}
+
+module.exports = verifyQualifiedMetastatement;
+

package/bin/verify/metastatement/unqualified.js

@@ -0,0 +1,40 @@
+"use strict";
+
+const { loggingUtilities } = require("necessary");
+
+const { nodeQuery } = require("../../utilities/query"),
+      { nodeAsString } = require("../../utilities/string");
+
+const { log } = loggingUtilities;
+
+const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
+
+function verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context) {
+  let unqualifiedMetastatementVerified = false;
+
+  const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
+
+  if (metastatementNode !== null) {
+    const derived = context.isDerived();
+
+    let metastatementPresent = true;  ///
+
+    if (derived) {
+      metastatementPresent = context.isMetastatementNodePresent(metastatementNode);
+    }
+
+    if (metastatementPresent) {
+      context.addMetastatementNode(metastatementNode);
+    }
+
+    const metastatementString = nodeAsString(metastatementNode);
+
+    log.info(`Verified the '${metastatementString}' unqualified metastatement.`);
+
+    unqualifiedMetastatementVerified = true;
+  }
+
+  return unqualifiedMetastatementVerified;
+}
+
+module.exports = verifyUnqualifiedMetastatement;

package/bin/verify/package.js

@@ -0,0 +1,81 @@
+"use strict";
+
+const { loggingUtilities } = require("necessary");
+
+const verifyFiles = require("../verify/files");
+
+const { log } = loggingUtilities;
+
+function verifyPackage(packageName, packageContextMap, packageContexts = []) {
+  const packageContext = packageContextMap[packageName];
+
+  let packageVerified = packageContext.isPackageVerified();
+
+  if (!packageVerified) {
+    log.debug(`Verifying the '${packageName}' package...`);
+
+    const dependencyPackageNames = packageContext.getDependencyPackageNames(),
+          dependencyPackagesVVerified = dependencyPackageNames.every((dependencyPackageName) => {
+            const packageName = dependencyPackageName,  ///
+                  packageVerified = verifyPackage(packageName, packageContextMap, packageContexts);
+
+            if (packageVerified) {
+              return true;
+            }
+          });
+
+    if (dependencyPackagesVVerified) {
+      const packageNames = dependencyPackageNames,  ///
+            packageContexts = packageNames.map((packageName) => {
+              const packageContext = packageContextMap[packageName];
+
+              return packageContext;
+            });
+
+      const dependencyPackageContexts = retrieveDependencyPackageContexts(dependencyPackageNames, packageContextMap);
+
+      sortDependencyPackageContexts(dependencyPackageContexts, packageContexts);
+
+      packageContext.initialise(packageContexts, dependencyPackageContexts);
+
+      const filesVerified = verifyFiles(packageContext);
+
+      packageVerified = filesVerified;  ///
+
+      if (packageVerified) {
+        packageContexts.push(packageContext);
+
+        log.info(`Verified the '${packageName}' package.`);
+      }
+    }
+  }
+
+  return packageVerified;
+}
+
+module.exports = verifyPackage;
+
+function sortDependencyPackageContexts(dependencyPackageContexts, packageContexts) {
+  dependencyPackageContexts.sort((dependencyPackageContextA, dependencyPackageContextB) => {
+    const indexA = packageContexts.indexOf(dependencyPackageContextA),
+          indexB = packageContexts.indexOf(dependencyPackageContextB),
+          difference = (indexB - indexA);
+
+    return difference;
+  });
+}
+
+function retrieveDependencyPackageContexts(dependencyPackageNames, packageContextMap, dependencyPackageContexts = []) {
+  dependencyPackageNames.forEach((dependencyPackageName) => {
+    const dependencyPackageContext = packageContextMap[dependencyPackageName],
+          dependencyPackageContextsIncludesDependencyPackageContext = dependencyPackageContexts.includes(dependencyPackageContext);
+
+    if (!dependencyPackageContextsIncludesDependencyPackageContext) {
+      dependencyPackageContexts.push(dependencyPackageContext);
+
+      retrieveDependencyPackageContexts(dependencyPackageNames, packageContextMap, dependencyPackageContexts);
+    }
+  });
+
+  return dependencyPackageContexts;
+}

package/bin/verify/premise.js

@@ -0,0 +1,35 @@
+"use strict";
+
+const Premise = require("../premise"),
+      verifyUnqualifiedMetastatement = require("../verify/metastatement/unqualified");
+
+const { nodeQuery, nodesQuery } = require("../utilities/query");
+
+const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement"),
+      unqualifiedMetastatementNodesQuery = nodesQuery("/premise|premises/unqualifiedMetastatement");
+
+function verifyPremise(premiseNode, premises, context) {
+  const unqualifiedMetastatementNodes = unqualifiedMetastatementNodesQuery(premiseNode),
+        premiseVerified = unqualifiedMetastatementNodes.every((unqualifiedMetastatementNode) => {
+          const unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
+
+          if (unqualifiedMetastatementVerified) {
+            return true;
+          }
+        });
+
+  if (premiseVerified) {
+    const metastatementNodes = unqualifiedMetastatementNodes.map((unqualifiedMetastatementNode) => {
+            const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
+
+            return metastatementNode;
+          }),
+          premise = Premise.fromMetastatementNodes(metastatementNodes);
+
+    premises.push(premise);
+  }
+
+  return premiseVerified;
+}
+
+module.exports = verifyPremise;

package/bin/verify/rule/inferenceConditional.js

@@ -0,0 +1,54 @@
+"use strict";
+
+const Rule = require("../../rule"),
+      verifyLabels = require("../../verify/labels"),
+      verifyPremise = require("../../verify/premise"),
+      verifyConclusion = require("../../verify/conclusion");
+
+const { first } = require("../../utilities/array"),
+      { nodeQuery, nodesQuery } = require("../../utilities/query");
+
+const labelNodesQuery = nodesQuery("/rule/label"),
+      premiseNodeQuery = nodeQuery("/inferenceConditional/premise|premises!"),
+      conclusionNodeQuery = nodeQuery("/inferenceConditional/conclusion!"),
+      inferenceConditionalNodeQuery = nodeQuery("/rule/inferenceConditional!");
+
+function verifyInferenceConditionalRule(ruleNode, rules, context) {
+  let inferenceConditionalRuleVerified = false;
+
+  const inferenceConditionalNode = inferenceConditionalNodeQuery(ruleNode);
+
+  if (inferenceConditionalNode !== null) {
+    const labels = [],
+          labelNodes = labelNodesQuery(ruleNode),
+          labelsVerified = verifyLabels(labelNodes, labels, context);
+
+    if (labelsVerified) {
+      const premises = [],
+            premiseNode = premiseNodeQuery(inferenceConditionalNode),
+            premiseVerified = verifyPremise(premiseNode, premises, context);
+
+      if (premiseVerified) {
+        const conclusions = [],
+              conclusionNode = conclusionNodeQuery(inferenceConditionalNode),
+              conclusionVerified = verifyConclusion(conclusionNode, conclusions, context);
+
+        if (conclusionVerified) {
+          const firstPremise = first(premises),
+                firstConclusion = first(conclusions),
+                premise = firstPremise, ///
+                conclusion = firstConclusion, ///
+                rule = Rule.fromPremiseConclusionAndLabels(premise, conclusion, labels);
+
+          rules.push(rule);
+
+          inferenceConditionalRuleVerified = true;
+        }
+      }
+    }
+  }
+
+  return inferenceConditionalRuleVerified;
+}
+
+module.exports = verifyInferenceConditionalRule;

package/bin/verify/rule/unqualifiedMetastatement.js

@@ -0,0 +1,40 @@
+"use strict";
+
+const Rule = require("../../rule"),
+      verifyLabels = require("../../verify/labels"),
+      verifyUnqualifiedMetastatement = require("../../verify/metastatement/unqualified");
+
+const { nodeQuery, nodesQuery } = require("../../utilities/query");
+
+const labelNodesQuery = nodesQuery("/rule/label"),
+      metastatementNodeQuery = nodeQuery("/*/metastatement"),
+      unqualifiedMetastatementNodeQuery = nodeQuery("/rule/unqualifiedMetastatement!");
+
+function verifyUnqualifiedMetastatementRule(ruleNode, rules, context) {
+  let unqualifiedMetastatementRuleVerified = false;
+
+  const unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(ruleNode);
+
+  if (unqualifiedMetastatementNode !== null) {
+    const labels = [],
+          labelNodes = labelNodesQuery(ruleNode),
+          labelsVerified = verifyLabels(labelNodes, labels, context);
+
+    if (labelsVerified) {
+      const unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
+
+      if (unqualifiedMetastatementVerified) {
+        const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
+              rule = Rule.fromMetastatementNodeAndLabels(metastatementNode, labels);
+
+        rules.push(rule);
+
+        unqualifiedMetastatementRuleVerified = true;
+      }
+    }
+  }
+
+  return unqualifiedMetastatementRuleVerified;
+}
+
+module.exports = verifyUnqualifiedMetastatementRule;

package/bin/verify/rule.js

@@ -0,0 +1,61 @@
+"use strict";
+
+const { loggingUtilities } = require("necessary");
+
+const verifyMetaproof = require("../verify/metaproof"),
+      MetaproofContext = require("../context/metaproof"),
+      verifyInferenceConditionalRule = require("../verify/rule/inferenceConditional"),
+      verifyUnqualifiedMetastatementRule = require("../verify/rule/unqualifiedMetastatement");
+
+const { first } = require("../utilities/array"),
+      { nodesAsString } = require("../utilities/string"),
+      { nodeQuery, nodesQuery } = require("../utilities/query");
+
+const { log } = loggingUtilities;
+
+const labelNodesQuery = nodesQuery("/rule/label"),
+      metaproofNodeQuery = nodeQuery("/rule/metaproof!");
+
+function verifyRule(ruleNode, context) {
+  let ruleVerified = false;
+
+  const labelNodes = labelNodesQuery(ruleNode),
+        labelsString = nodesAsString(labelNodes);
+
+  log.debug(`Verifying the '${labelsString}' rule...`);
+
+  const metaproofContext = MetaproofContext.fromContext(context);
+
+  context = metaproofContext; ///
+
+  const rules = [],
+        inferenceConditionalRuleVerified = verifyInferenceConditionalRule(ruleNode, rules, context),
+        unqualifiedMetastatementRuleVerified = verifyUnqualifiedMetastatementRule(ruleNode, rules, context);
+
+  if (inferenceConditionalRuleVerified || unqualifiedMetastatementRuleVerified) {
+    const metaproofNode = metaproofNodeQuery(ruleNode);
+
+    let metaproofVerified = true;
+
+    if (metaproofNode !== null) {
+      metaproofVerified = verifyMetaproof(metaproofNode, rules, context);
+    }
+
+    if (metaproofVerified) {
+      ruleVerified = true;
+    }
+  }
+
+  if (ruleVerified) {
+    const firstRule = first(rules),
+          rule = firstRule; ///
+
+    context.addRule(rule);
+
+    log.info(`Verified the '${labelsString}' rule.`);
+  }
+
+  return ruleVerified;
+}
+
+module.exports = verifyRule;

package/bin/verify/statement/qualified.js

@@ -0,0 +1,17 @@
+"use strict";
+
+const verifyStatement = require("../../verify/statement");
+
+const { nodeQuery } = require("../../utilities/query");
+
+const statementNodeQuery = nodeQuery("/qualifiedStatement/statement!");
+
+function verifyQualifiedStatement(qualifiedStatementNode, context) {
+  const statementNode = statementNodeQuery(qualifiedStatementNode),
+        statementVerified = verifyStatement(statementNode, context),
+        qualifiedStatementVerified = statementVerified; ///
+
+  return qualifiedStatementVerified;
+}
+
+module.exports = verifyQualifiedStatement;

package/bin/verify/statement/unqualified.js

@@ -0,0 +1,27 @@
+"use strict";
+
+const verifyStatement = require("../../verify/statement");
+
+const { nodeQuery } = require("../../utilities/query");
+
+const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
+
+function verifyUnqualifiedStatement(unqualifiedStatementNode, context) {
+  let unqualifiedStatementVerified = false;
+
+  const statementNode = statementNodeQuery(unqualifiedStatementNode);
+
+  if (statementNode !== null) {
+    const statementVerified = verifyStatement(statementNode, context);
+
+    if (statementVerified) {
+      context.addStatementNode(statementNode);
+
+      unqualifiedStatementVerified = true;
+    }
+  }
+
+  return unqualifiedStatementVerified;
+}
+
+module.exports = verifyUnqualifiedStatement;

package/bin/verify/statement.js

@@ -0,0 +1,47 @@
+"use strict";
+
+const { loggingUtilities } = require("necessary");
+
+const verifyEquality = require("../verify/equality"),
+      verifyTypeAssertion = require("../verify/typeAssertion");
+
+const { nodeQuery } = require("../utilities/query"),
+      { nodeAsString } = require("../utilities/string");
+
+const equalityNodeQuery = nodeQuery("/statement/equality!"),
+      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
+
+const { log } = loggingUtilities;
+
+function verifyStatement(statementNode, context) {
+  let statementVerified = false;
+
+  const statementString = nodeAsString(statementNode);
+
+  log.debug(`Verifying the '${statementString}' statement...`);
+
+  const equalityNode = equalityNodeQuery(statementNode),
+        typeAssertionNode = typeAssertionNodeQuery(statementNode);
+
+  if (false) {
+    ///
+  } else if (equalityNode !== null) {
+    const equalityVerified = verifyEquality(equalityNode, context);
+
+    statementVerified = equalityVerified; ///
+  } else if (typeAssertionNode !== null) {
+    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, context);
+
+    statementVerified = typeAssertionVerified; ///
+  } else {
+    debugger
+  }
+
+  if (statementVerified) {
+    log.info(`Verified the '${statementString}' statement.`);
+  }
+
+  return statementVerified;
+}
+
+module.exports = verifyStatement;