occam-verify-cli 0.0.921 → 0.0.923

package/src/verify/metaSubproof.js

@@ -1,34 +0,0 @@
-"use strict";
-
-import MetaLevelLocalContext from "../context/local/metaLevel";
-import verifyMetaSuppositions from "../verify/metaSuppositions";
-import verifyMetaSubDerivation from "../verify/metaSubDerivation";
-
-import { nodeQuery, nodesQuery } from "../utilities/query";
-
-const metaSuppositionNodesQuery = nodesQuery("/metaSubproof/metaSupposition"),
-      metaSubDerivationNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation");
-
-export default function verifyMetaSubproof(metaSubproofNode, substitutions, localContext) {
-  let metaSubproofVerified = false;
-
-  const metaLevelLocalContext = MetaLevelLocalContext.fromLocalContext(localContext);
-
-  localContext = metaLevelLocalContext; ///
-
-  const metaSuppositions = [],
-        metaSuppositionNodes = metaSuppositionNodesQuery(metaSubproofNode),
-        metaSuppositionsVerified = verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, substitutions, localContext);
-
-  if (metaSuppositionsVerified) {
-    const metaSubDerivationNode = metaSubDerivationNodeQuery(metaSubproofNode),
-          metaSubDerivationVerified = verifyMetaSubDerivation(metaSubDerivationNode, substitutions, localContext);
-
-    if (metaSubDerivationVerified) {
-      metaSubproofVerified = true;
-    }
-  }
-
-  return metaSubproofVerified;
-}
-

package/src/verify/metaSupposition.js

@@ -1,78 +0,0 @@
-"use strict";
-
-import MetaproofStep from "../step/metaproof";
-import MetaSupposition from "../metaSupposition";
-import verifyUnqualifiedStatement from "./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("/metaSupposition/unqualifiedStatement!"),
-      unqualifiedMetastatementNodeQuery = nodeQuery("/metaSupposition/unqualifiedMetastatement!");
-
-export default function verifyMetaSupposition(metaSuppositionNode, metaSuppositions, localContext) {
-  let metaSuppositionVerified = false;
-
-  const metaSuppositionString = localContext.nodeAsString(metaSuppositionNode);
-
-  localContext.trace(`Verifying the '${metaSuppositionString}' meta-supposition...`, metaSuppositionNode);
-
-  const unqualifiedStatementNode = unqualifiedStatementNodeQuery(metaSuppositionNode),
-        unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(metaSuppositionNode);
-
-  if (unqualifiedStatementNode !== null) {
-    const derived = false,
-          assignments = [],
-          unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
-
-    if (unqualifiedStatementVerified) {
-      const assignmentAssigned = assignAssignment(assignments, localContext);
-
-      metaSuppositionVerified = assignmentAssigned; ///
-    }
-  }
-
-  if (unqualifiedMetastatementNode !== null) {
-    const derived = false,
-          assignments = [],
-          unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localContext);
-
-    if (unqualifiedMetastatementVerified) {
-      const assignmentAssigned = assignAssignment(assignments, localContext);
-
-      metaSuppositionVerified = assignmentAssigned; ///
-    }
-  }
-
-  if (metaSuppositionVerified) {
-    let metaSupposition,
-        metaproofStep;
-
-    if (unqualifiedStatementNode !== null) {
-      const statementNode = statementNodeQuery(unqualifiedStatementNode);
-
-      metaSupposition = MetaSupposition.fromStatementNode(statementNode);
-
-      metaproofStep = MetaproofStep.fromMetastatementNode(statementNode);
-    }
-
-    if (unqualifiedMetastatementNode !== null) {
-      const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
-
-      metaSupposition = MetaSupposition.fromMetastatementNode(metastatementNode);
-
-      metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
-    }
-
-    metaSuppositions.push(metaSupposition);
-
-    localContext.addMetaproofStep(metaproofStep);
-
-    localContext.debug(`...verified the '${metaSuppositionString}' meta-supposition.`, metaSuppositionNode);
-  }
-
-  return metaSuppositionVerified;
-}

package/src/verify/metaSuppositions.js

@@ -1,17 +0,0 @@
-"use strict";
-
-import verifyMetaSupposition from "../verify/metaSupposition";
-
-export default function verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, substitutions, localContext) {
-  let metaSuppositionsVerified;
-
-  metaSuppositionsVerified = metaSuppositionNodes.every((metaSuppositionNode) => {
-    const metaSuppositionVerified = verifyMetaSupposition(metaSuppositionNode, metaSuppositions, localContext);
-
-    if (metaSuppositionVerified) {
-      return true;
-    }
-  });
-
-  return metaSuppositionsVerified;
-}

package/src/verify/metaproof.js

@@ -1,30 +0,0 @@
-"use strict";
-
-import verifyMetaDerivation from "../verify/metaDerivation";
-import MetaLevelLocalContext from "../context/local/metaLevel";
-
-import { nodeQuery } from "../utilities/query";
-
-const metaDerivationNodeQuery = nodeQuery("/metaproof/metaDerivation!");
-
-export default function verifyMetaproof(metaproofNode, metastatementNode, substitutions, localContext) {
-  let metaproofVerified = false;
-
-  const metaLevelLocalContext = MetaLevelLocalContext.fromLocalContext(localContext);
-
-  localContext = metaLevelLocalContext; ///
-
-  const metaDerivationNode = metaDerivationNodeQuery(metaproofNode),
-        metaDerivationVerified = verifyMetaDerivation(metaDerivationNode, substitutions, localContext);
-
-  if (metaDerivationVerified) {
-    const lastMetaproofStep = localContext.getLastMetaproofStep(),
-          lastMetaproofStepMetastatementNode = lastMetaproofStep.getMetastatementNode(),
-          lastMetastatementNode = lastMetaproofStepMetastatementNode, ///
-          lastMetastatementNodeMatchesMetastatementNode = lastMetastatementNode.match(metastatementNode);
-
-    metaproofVerified = lastMetastatementNodeMatchesMetastatementNode;  ///
-  }
-
-  return metaproofVerified;
-}

package/src/verify/metaproofStep.js

@@ -1,137 +0,0 @@
-"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, localContext) {
-  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, substitutions, localContext);
-
-    if (metaSubproofVerified) {
-      const metaproofStep = MetaproofStep.fromMetaSubproofNode(metaSubproofNode);
-
-      localContext.addMetaproofStep(metaproofStep);
-
-      metaproofStepVerified = true;
-    }
-  } else if (qualifiedStatementNode !== null) {
-    let qualifiedStatementVerified;
-
-    const assignments = [];  ///
-
-    qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, assignments, localContext);
-
-    if (qualifiedStatementVerified) {
-      const assignmentAssigned = assignAssignment(assignments, localContext);
-
-      qualifiedStatementVerified = assignmentAssigned; ///
-    }
-
-    if (qualifiedStatementVerified) {
-      const statementNode = statementNodeQuery(qualifiedStatementNode),
-            metaproofStep = MetaproofStep.fromStatementNode(statementNode);
-
-      localContext.addMetaproofStep(metaproofStep);
-
-      metaproofStepVerified = true;
-    }
-  } else if (unqualifiedStatementNode !== null) {
-    let unqualifiedStatementVerified;
-
-    const derived = true,
-          assignments = [];
-
-    unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
-
-    if (unqualifiedStatementVerified) {
-      const assignmentAssigned = assignAssignment(assignments, localContext);
-
-      unqualifiedStatementVerified = assignmentAssigned; ///
-    }
-
-    if (unqualifiedStatementVerified) {
-      const statementNode = statementNodeQuery(unqualifiedStatementNode),
-            metaproofStep = MetaproofStep.fromStatementNode(statementNode);
-
-      localContext.addMetaproofStep(metaproofStep);
-
-      metaproofStepVerified = unqualifiedStatementVerified; ///
-    }
-  } else if (qualifiedMetastatementNode !== null) {
-    let qualifiedMetastatementVerified;
-
-    const assignments = [];
-
-    qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, substitutions, assignments, localContext);
-
-    if (qualifiedMetastatementVerified) {
-      const assignmentAssigned = assignAssignment(assignments, localContext);
-
-      qualifiedMetastatementVerified = assignmentAssigned; ///
-    }
-
-    if (qualifiedMetastatementVerified) {
-      const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
-            metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
-
-      localContext.addMetaproofStep(metaproofStep);
-
-      metaproofStepVerified = qualifiedMetastatementVerified; ///
-    }
-  } else if (unqualifiedMetastatementNode !== null) {
-    let unqualifiedMetastatementVerified;
-
-    const derived = true,
-          assignments = [];
-
-    unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localContext);
-
-    if (unqualifiedMetastatementVerified) {
-      const assignmentAssigned = assignAssignment(assignments, localContext);
-
-      unqualifiedMetastatementVerified = assignmentAssigned; ///
-    }
-
-    if (unqualifiedMetastatementVerified) {
-      const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
-            metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
-
-      localContext.addMetaproofStep(metaproofStep);
-
-      metaproofStepVerified = true;
-    }
-  }
-
-  return metaproofStepVerified;
-}
-
-Object.assign(verifyMetaSubDerivation, {
-  verifyMetaproofStep
-});

package/src/verify/metastatement/qualified.js

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

package/src/verify/metastatement/unqualified.js

@@ -1,34 +0,0 @@
-"use strict";
-
-import verifyMetastatement from "../../verify/metastatement";
-
-import { nodeQuery } from "../../utilities/query";
-
-const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
-
-export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localContext) {
-  let unqualifiedMetastatementVerified = false;
-
-  const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
-        unqualifiedMetastatementString = localContext.nodeAsString(unqualifiedMetastatementNode);
-
-  localContext.trace(`Verifying the '${unqualifiedMetastatementString}' unqualified metastatement...`, unqualifiedMetastatementNode);
-
-  if (derived) {
-    const matchesMetastatementNode = localContext.matchMetastatementNode(metastatementNode);
-
-    unqualifiedMetastatementVerified = matchesMetastatementNode;  ///
-  }
-
-  if (!unqualifiedMetastatementVerified) {
-    const metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localContext);
-
-    unqualifiedMetastatementVerified = metastatementVerified; ///
-  }
-
-  if (unqualifiedMetastatementVerified) {
-    localContext.debug(`...verified the '${unqualifiedMetastatementString}' unqualified metastatement.`, unqualifiedMetastatementNode);
-  }
-
-  return unqualifiedMetastatementVerified;
-}

package/src/verify/metastatementAsContainedAssertion.js

@@ -1,127 +0,0 @@
-"use strict";
-
-import metaLevelNodeVerifier from "../verifier/node/metaLevel";
-
-import { CONTAINED } from "../constants";
-import { nodeQuery, nodesQuery } from "../utilities/query";
-import { isMetastatementNegated } from "../utilities/verify";
-
-const termNodeQuery = nodeQuery("/metastatement/term!"),
-      operatorTerminalNodesQuery = nodesQuery("/metastatement/@operator"),
-      metastatementTermNodesQuery = nodesQuery("/metastatement/metastatement//term");
-
-export default function verifyMetastatementAsContainedAssertion(metastatementNode, assignments, derived, localContext) {
-  let metastatementVerifiedAsContainedAssertion;
-
-  const metastatementContainedAssertion = isMetastatementContainedAssertion(metastatementNode);
-
-  if (metastatementContainedAssertion) {
-    const metastatementString = localContext.nodeAsString(metastatementNode);
-
-    localContext.trace(`Verifying the '${metastatementString}' metastatement as a contained assertion...`, metastatementNode);
-
-    const metastatementFunctions = [
-      verifyMetastatementAsDerivedContainedAssertion,
-      verifyMetastatementAsStatedContainedAssertion
-    ];
-
-    metastatementVerifiedAsContainedAssertion = metastatementFunctions.some((metastatementFunction) => {
-      const metastatementVerifiedAsContainedAssertion = metastatementFunction(metastatementNode, assignments, derived, localContext);
-
-      if (metastatementVerifiedAsContainedAssertion) {
-        return true;
-      }
-    });
-
-    if (metastatementVerifiedAsContainedAssertion) {
-      localContext.debug(`...verified the '${metastatementString}' metastatement as a contained assertion.`, metastatementNode);
-    }
-  }
-
-  return metastatementVerifiedAsContainedAssertion;
-}
-
-function verifyMetastatementAsDerivedContainedAssertion(metastatementNode, assignments, derived, localContext) {
-  let metastatementVerifiedAsDefinedContainedAssertion = false;
-
-  if (derived) {
-    const metastatementString = localContext.nodeAsString(metastatementNode);
-
-    localContext.trace(`Verifying the derived '${metastatementString}' metastatement as a contained assertion...`, metastatementNode);
-
-    const metastatementNegated = isMetastatementNegated(metastatementNode),
-          negated = metastatementNegated,
-          termNode = termNodeQuery(metastatementNode),
-          metastatementTermNodes = metastatementTermNodesQuery(metastatementNode),
-          termNodeMatchesMetaArgumentTermNode = metastatementTermNodes.some((metastatementTermNode) => {
-            const termNodeMatchesMetaArgumentTermNode = termNode.match(metastatementTermNode);
-
-            if (termNodeMatchesMetaArgumentTermNode) {
-              return true;
-            }
-          });
-
-    if (!negated) {
-      if (termNodeMatchesMetaArgumentTermNode) {
-        metastatementVerifiedAsDefinedContainedAssertion = true;
-      }
-    }
-
-    if (negated) {
-      if (!termNodeMatchesMetaArgumentTermNode) {
-        metastatementVerifiedAsDefinedContainedAssertion = true;
-      }
-    }
-
-    if (metastatementVerifiedAsDefinedContainedAssertion) {
-      localContext.debug(`...verified the derived '${metastatementString}' metastatement as a contained assertion.`, metastatementNode);
-    }
-  }
-
-  return metastatementVerifiedAsDefinedContainedAssertion;
-}
-
-function verifyMetastatementAsStatedContainedAssertion(metastatementNode, assignments, derived, localContext) {
-  let metastatementVerifiedAsStatedContainedAssertion = false;
-
-  if (!derived) {
-    const metastatementString = localContext.nodeAsString(metastatementNode);
-
-    localContext.trace(`Verifying the stated '${metastatementString}' metastatement as a contained assertion...`, metastatementNode);
-
-    const intrinsicLevel = localContext.isIntrinsicLevel();
-
-    if (intrinsicLevel) {
-      localContext.debug(`The stated '${metastatementString}' metastatement as a contained assertion cannot be verified at intrinsic level.`, metastatementNode);
-    } else {
-      const nonTerminalNode = metastatementNode, ///
-            nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
-              const verifiedAhead = true;
-
-              return verifiedAhead;
-            });
-
-      metastatementVerifiedAsStatedContainedAssertion = nonTerminalNodeVerified; ///
-    }
-
-    if (metastatementVerifiedAsStatedContainedAssertion) {
-      localContext.debug(`...verified the stated '${metastatementString}' metastatement as a contained assertion.`, metastatementNode);
-    }
-  }
-
-  return metastatementVerifiedAsStatedContainedAssertion;
-}
-
-export function isMetastatementContainedAssertion(metastatementNode) {
-  const operatorTerminalNodes = operatorTerminalNodesQuery(metastatementNode),
-        metastatementContainedAssertion = operatorTerminalNodes.some((operatorTerminalNode) => {
-          const content = operatorTerminalNode.getContent(),
-                contentContained = (content === CONTAINED);
-
-          if (contentContained) {
-            return true;
-          }
-        });
-
-  return metastatementContainedAssertion;
-}