occam-verify-cli 0.0.923 → 0.0.925

package/src/metaLemma.js

@@ -1,9 +1,9 @@
 "use strict";
 
-import MetalemmaMetatheorem from "./metalemmaMetatheorem";
+import TopLevelAssertion from "./topLevelAssertion";
 
-export default class MetaLemma extends MetalemmaMetatheorem {
-  static fromJSONAndFileContext(json, fileContext) { return MetalemmaMetatheorem.fromJSONAndFileContext(MetaLemma, json, fileContext); }
+export default class MetaLemma extends TopLevelAssertion {
+  static fromJSONAndFileContext(json, fileContext) { return TopLevelAssertion.fromJSONAndFileContext(MetaLemma, json, fileContext); }
 
-  static fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(labels, metaSuppositions, metaConsequent, substitutions, fileContext) { return MetalemmaMetatheorem.fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(MetaLemma, labels, metaSuppositions, metaConsequent, substitutions, fileContext); }
+  static fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(labels, metaSuppositions, metaConsequent, substitutions, fileContext) { return TopLevelAssertion.fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(MetaLemma, labels, metaSuppositions, metaConsequent, substitutions, fileContext); }
 }

package/src/metatheorem.js

@@ -1,9 +1,9 @@
 "use strict";
 
-import MetaLemmaMetatheorem from "./metaLemmaMetatheorem";
+import TopLevelAssertion from "./topLevelAssertion";
 
-export default class Metatheorem extends MetaLemmaMetatheorem {
-  static fromJSONAndFileContext(json, fileContext) { return MetaLemmaMetatheorem.fromJSONAndFileContext(Metatheorem, json, fileContext); }
+export default class Metatheorem extends TopLevelAssertion {
+  static fromJSONAndFileContext(json, fileContext) { return TopLevelAssertion.fromJSONAndFileContext(Metatheorem, json, fileContext); }
 
-  static fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, fileContext) { return MetaLemmaMetatheorem.fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(Metatheorem, labels, suppositions, consequent, fileContext); }
+  static fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, fileContext) { return TopLevelAssertion.fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(Metatheorem, labels, suppositions, consequent, fileContext); }
 }

package/src/metavariable.js

@@ -36,6 +36,12 @@ export default class Metavariable {
     return this.metaType;
   }
 
+  getMetaTypeName() {
+    const metaTypeName = this.metaType.getName();
+
+    return metaTypeName;
+  }
+
   matchName(name) {
     const matchesName = (this.name === name);
 

package/src/mixins/nodesVerifier/metaLevel.js

@@ -2,7 +2,7 @@
 
 import StatementForMetavariableSubstitution from "../../substitution/statementForMetavariable";
 
-function verifyMetavariableNode(metavariableNodeA, statementNodeB, substitutions, localContextA, localMetaContextB, verifyAhead) {
+function verifyMetavariableNode(metavariableNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead) {
   let metavariableNodeVerified;
 
   const substitution = substitutions.find((substitution) => {

package/src/premise.js

@@ -10,17 +10,17 @@ import { nodeQuery, nodesQuery } from "./utilities/query";
 import { statementNodeFromStatementString } from "./utilities/node";
 
 const subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
-      subproofPremiseStatementNodesQuery = nodesQuery("/subproof/premise/unqualifiedStatement!/statement!"),
       subproofAssertionStatementNodesQuery = nodesQuery("/subproofAssertion/statement"),
+      subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement!/statement!"),
       subproofLastProofStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/lastProofStep/unqualifiedStatement|qualifiedStatement/statement!");
 
 export default class Premise {
   constructor(statementNode) {
-    this.statementnode = statementNode;
+    this.statementNode = statementNode;
   }
 
   getStatementNode() {
-    return this.statementnode;
+    return this.statementNode;
   }
 
   matchStatementNode(statementNode, substitutions, fileContext, localContext) {
@@ -51,10 +51,10 @@ export default class Premise {
       const subproofAssertionNode = subproofAssertionNodeQuery(this.statementNode);
 
       if (subproofAssertionNode !== null) {
-        const subproofPremiseStatementNodes = subproofPremiseStatementNodesQuery(subproofNode),
+        const subproofSuppositionStatementNodes = subproofSuppositionStatementNodesQuery(subproofNode),
               subproofLastProofStepStatementNode = subproofLastProofStepStatementNodeQuery(subproofNode),
               subproofStatementNodes = [
-                ...subproofPremiseStatementNodes,
+                ...subproofSuppositionStatementNodes,
                 subproofLastProofStepStatementNode
               ],
               subproofAssertionStatementNodes = subproofAssertionStatementNodesQuery(subproofAssertionNode);
@@ -82,7 +82,7 @@ export default class Premise {
   }
 
   toJSON(tokens) {
-    const statementString = nodeAsString(this.statementnode, tokens),
+    const statementString = nodeAsString(this.statementNode, tokens),
           statement = statementString,  ///
           json = {
             statement

package/src/theorem.js

@@ -1,9 +1,9 @@
 "use strict";
 
-import AxiomLemmaTheoremConjecture from "./axiomLemmaTheoremConjecture";
+import TopLevelAssertion from "./topLevelAssertion";
 
-export default class Theorem extends AxiomLemmaTheoremConjecture {
-  static fromJSONAndFileContext(json, fileContext) { return AxiomLemmaTheoremConjecture.fromJSONAndFileContext(Theorem, json, fileContext); }
+export default class Theorem extends TopLevelAssertion {
+  static fromJSONAndFileContext(json, fileContext) { return TopLevelAssertion.fromJSONAndFileContext(Theorem, json, fileContext); }
 
-  static fromLabelsSuppositionsConsequentAndLocalContext(labels, suppositions, consequent, localContext) { return AxiomLemmaTheoremConjecture.fromLabelsSuppositionsConsequentAndLocalContext(Theorem, labels, suppositions, consequent, localContext); }
+  static fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext) { return TopLevelAssertion.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(Theorem, labels, suppositions, consequent, substitutions, fileContext); }
 }

package/src/{metaLemmaMetatheorem.js → topLevelAssertion.js}

@@ -7,7 +7,7 @@ import StatementForMetavariableSubstitution from "./substitution/statementForMet
 
 import { reverse, correlate } from "./utilities/array";
 
-export default class MetaLemmaMetatheorem {
+export default class TopLevelAssertion {
   constructor(labels, suppositions, consequent, substitutions, fileContext) {
     this.labels = labels;
     this.suppositions = suppositions;
@@ -39,9 +39,9 @@ export default class MetaLemmaMetatheorem {
   matchStatement(statementNode, localContext) {
     let statementNatches = false;
 
-    const metaproofSteps = localContext.getProofSteps(),
+    const proofSteps = localContext.getProofSteps(),
           substitutions = [],
-          suppositionsMatch = matchSuppositions(this.suppositions, metaproofSteps, substitutions, this.fileContext, localContext);
+          suppositionsMatch = matchSuppositions(this.suppositions, proofSteps, substitutions, this.fileContext, localContext);
 
     if (suppositionsMatch) {
       const consequentMatches = matchConsequent(this.consequent, statementNode, substitutions, this.fileContext, localContext);
@@ -77,22 +77,19 @@ export default class MetaLemmaMetatheorem {
           }),
           consequentJSON = this.consequent.toJSON(tokens),
           substitutionsJSON = this.substitutions.map((substitution) => {
-            const substitutionJSON = substitution.toJSON();
+        const substitutionJSON = substitution.toJSON();
 
-            return substitutionJSON;
-          }),
-          localContextJSON = this.fileContext.toJSON(tokens),
+        return substitutionJSON;
+      }),
           labels = labelsJSON,  ///
           suppositions = suppositionsJSON,  ///
           consequent = consequentJSON,  ///
           substitutions = substitutionsJSON,  ///
-          fileContext = localContextJSON,  ///
           json = {
             labels,
             suppositions,
             consequent,
-            substitutions,
-            fileContext
+            substitutions
           };
 
     return json;
@@ -143,13 +140,13 @@ export default class MetaLemmaMetatheorem {
   static fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(Class, labels, suppositions, consequent, substitutions, fileContext) { return new Class(labels, suppositions, consequent, substitutions, fileContext); }
 }
 
-function matchSuppositions(suppositions, metaproofSteps, substitutions, fileContext, localContext) {
+function matchSuppositions(suppositions, proofSteps, substitutions, fileContext, localContext) {
   suppositions = reverse(suppositions); ///
 
-  metaproofSteps = reverse(metaproofSteps); ///
+  proofSteps = reverse(proofSteps); ///
 
-  const suppositionsMatch = correlate(suppositions, metaproofSteps, (supposition, metaproofStep) => {
-    const suppositionMatches = matchSupposition(supposition, metaproofStep, substitutions, fileContext, localContext);
+  const suppositionsMatch = correlate(suppositions, proofSteps, (supposition, proofStep) => {
+    const suppositionMatches = matchSupposition(supposition, proofStep, substitutions, fileContext, localContext);
 
     if (suppositionMatches) {
       return true;
@@ -159,25 +156,18 @@ function matchSuppositions(suppositions, metaproofSteps, substitutions, fileCont
   return suppositionsMatch;
 }
 
-function matchSupposition(supposition, metaproofStep, substitutions, fileContext, localContext) {
-  let matchesSupposition = false;
-
-  const metaSubproofNode = metaproofStep.getSubproofNode(),
-        statementNode = metaproofStep.getStatementNode();
+function matchSupposition(supposition, proofStep, substitutions, fileContext, localContext) {
+  let suppositionMatches = false;
 
-  if (metaSubproofNode !== null) {
-    const suppositionMatchesSubproofNode = supposition.matchSubproofNode(metaSubproofNode, substitutions, fileContext, localContext);
-
-    matchesSupposition - suppositionMatchesSubproofNode; ///
-  }
+  const statementNode = proofStep.getStatementNode();
 
   if (statementNode !== null) {
     const suppositionMatchesStatementNode = supposition.matchStatementNode(statementNode, substitutions, fileContext, localContext);
 
-    matchesSupposition - suppositionMatchesStatementNode; ///
+    suppositionMatches = suppositionMatchesStatementNode;  ///
   }
 
-  return matchesSupposition;
+  return suppositionMatches;
 }
 
 function matchConsequent(consequent, statementNode, substitutions, fileContext, localContext) {

package/src/verifier/nodes/intrinsicLevel.js

@@ -35,7 +35,7 @@ class IntrinsicLevelNodesVerifier extends NodesVerifier {
       {
         nodeQueryA: nonTerminalNodeQuery,
         nodeQueryB: nonTerminalNodeQuery,
-        verifyNodes: (nodeA, nodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead) => {
+        verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const nonTerminalNodeA = nodeA, ///
@@ -43,7 +43,7 @@ class IntrinsicLevelNodesVerifier extends NodesVerifier {
 
           nonTerminalNodeVerified =
 
-            super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead);
+            super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
           return nonTerminalNodeVerified;
         }

package/src/verifier/nodes/intrinsicLevelAgainstMetaLevel.js

@@ -93,7 +93,7 @@ class IntrinsicLevelAgainstMetaLevelNodesVerifier extends NodesVerifier {
       {
         nodeQueryA: nonTerminalNodeQuery,
         nodeQueryB: nonTerminalNodeQuery,
-        verifyNodes: (nodeA, nodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead) => {
+        verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const nonTerminalNodeA = nodeA, ///
@@ -101,7 +101,7 @@ class IntrinsicLevelAgainstMetaLevelNodesVerifier extends NodesVerifier {
 
           nonTerminalNodeVerified =
 
-            super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead);
+            super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
           return nonTerminalNodeVerified;
         }
@@ -133,7 +133,7 @@ class IntrinsicLevelAgainstMetaLevelNodesVerifier extends NodesVerifier {
 
     const substitutionNode = statementSubstitutionNodeA,  ///
           metavariableNodeA = statementMetavariableNodeA,  ///
-          metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNode, substitutions, localContextA, localContextB, verifyAhead)
+          metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNode, substitutions, localContextA, localContextB, verifyAhead);
 
     statementMetavariableNodeVerifiedAgainstStatementNode = metavariableVerifiedAgainstStatement; ///
 

package/src/verifier/nodes/metaLevel.js

@@ -8,29 +8,29 @@ import { nodeQuery } from "../../utilities/query";
 import { verifyNodes } from "../../utilities/verifier";
 
 const termNodeQuery = nodeQuery("/term!"),
-      nonTerminalNodeQuery = nodeQuery("/*"),
       statementNodeQuery = nodeQuery("/statement!"),
+      nonTerminalNodeQuery = nodeQuery("/*"),
       termVariableNodeQuery = nodeQuery("/term/variable!"),
-      statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!");
+      metavariableNodeQuery = nodeQuery("/metavariable!");
 
 class MetaLevelNodesVerifier extends NodesVerifier {
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead) {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead) {
     let nonTerminalNodeVerified;
 
     const nodeQueryMaps = [
       {
-        nodeQueryA: statementMetavariableNodeQuery,
+        nodeQueryA: metavariableNodeQuery,
         nodeQueryB: statementNodeQuery,
-        verifyNodes: (nodeA, nodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead) => {
+        verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const statementNodeB = nodeB, ///
-                statementMetavariableNodeA = nodeA, ///
-                statementMetavariableNodeVerifiedAgainstStatementNode =
+                metavariableNodeA = nodeA, ///
+                metavariableNodeVerifiedAgainstStatementNode =
 
-                  this.verifyStatementMetavariableNodeAgainstStatementNode(statementMetavariableNodeA, statementNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead);
+                  this.verifyMetavariableNodeAgainstStatementNode(metavariableNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
-          nonTerminalNodeVerified = statementMetavariableNodeVerifiedAgainstStatementNode;  ///
+          nonTerminalNodeVerified = metavariableNodeVerifiedAgainstStatementNode;  ///
 
           return nonTerminalNodeVerified;
         }
@@ -55,7 +55,7 @@ class MetaLevelNodesVerifier extends NodesVerifier {
       {
         nodeQueryA: nonTerminalNodeQuery,
         nodeQueryB: nonTerminalNodeQuery,
-        verifyNodes: (nodeA, nodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead) => {
+        verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const nonTerminalNodeA = nodeA, ///
@@ -63,30 +63,29 @@ class MetaLevelNodesVerifier extends NodesVerifier {
 
           nonTerminalNodeVerified =
 
-            super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead);
+            super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
           return nonTerminalNodeVerified;
         }
       }
     ];
 
-    const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead);
+    const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
     nonTerminalNodeVerified = nodesVerified;  ///
 
     return nonTerminalNodeVerified;
   }
 
-  verifyStatementMetavariableNodeAgainstStatementNode(statementMetavariableNodeA, statementNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead) {
-    let statementMetavariableNodeVerifiedAgainstStatementNode;
+  verifyMetavariableNodeAgainstStatementNode(metavariableNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead) {
+    let metavariableNodeVerifiedAgainstStatementNode;
 
-    const metavariableNode = statementMetavariableNodeA, ///
-          statementNode = statementNodeB, ///
-          metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNode, statementNode, substitutions, verifyAhead);
+    const substitutionNode = null,
+          metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNode, substitutions, localContextA, localContextB, verifyAhead);
 
-    statementMetavariableNodeVerifiedAgainstStatementNode = metavariableVerifiedAgainstStatement;  ///
+    metavariableNodeVerifiedAgainstStatementNode = metavariableVerifiedAgainstStatement;  ///
 
-    return statementMetavariableNodeVerifiedAgainstStatementNode;
+    return metavariableNodeVerifiedAgainstStatementNode;
   }
 
   verifyTermVariableNodeAgainstTermNode(termVariableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {

package/src/verify/assertion/contained.js

@@ -0,0 +1,111 @@
+"use strict";
+
+import metaLevelNodeVerifier from "../../verifier/node/metaLevel";
+
+import { isStatementNegated } from "../../utilities/verify";
+import { nodeQuery, nodesQuery } from "../../utilities/query";
+
+const termNodeQuery = nodeQuery("/statement/term!"),
+      statementTermNodesQuery = nodesQuery("/statement/metaArgument/statement//term");
+
+export default function verifyContainedAssertion(containedAssertionNode, assignments, derived, localContext) {
+  let statementVerifiedAsContainedAssertion;
+
+  const statementContainedAssertion = isStatementContainedAssertion(containedAssertionNode);
+
+  if (statementContainedAssertion) {
+    const containedAssertionString = localContext.nodeAsString(containedAssertionNode);
+
+    localContext.trace(`Verifying the '${containedAssertionString}' statement as a contained assertion...`, containedAssertionNode);
+
+    const statementFunctions = [
+      verifyStatementAsDerivedContainedAssertion,
+      verifyStatementAsStatedContainedAssertion
+    ];
+
+    statementVerifiedAsContainedAssertion = statementFunctions.some((statementFunction) => {
+      const statementVerifiedAsContainedAssertion = statementFunction(containedAssertionNode, assignments, derived, localContext);
+
+      if (statementVerifiedAsContainedAssertion) {
+        return true;
+      }
+    });
+
+    if (statementVerifiedAsContainedAssertion) {
+      localContext.debug(`...verified the '${containedAssertionString}' statement as a contained assertion.`, containedAssertionNode);
+    }
+  }
+
+  return statementVerifiedAsContainedAssertion;
+}
+
+function verifyStatementAsDerivedContainedAssertion(containedAssertionNode, assignments, derived, localContext) {
+  let statementVerifiedAsDefinedContainedAssertion = false;
+
+  if (derived) {
+    const containedAssertionString = localContext.nodeAsString(containedAssertionNode);
+
+    localContext.trace(`Verifying the '${containedAssertionString}' derived statement as a contained assertion...`, containedAssertionNode);
+
+    const statementNegated = isStatementNegated(containedAssertionNode),
+          termNode = termNodeQuery(containedAssertionNode),
+          negated = statementNegated, ///
+          statementTermNodes = statementTermNodesQuery(containedAssertionNode),
+          termNodeMatchesMetaArgumentVariableNode = statementTermNodes.some((statementTermNode) => {
+            const termNodeMatchesMetaArgumentVariableNode = termNode.match(statementTermNode);
+
+            if (termNodeMatchesMetaArgumentVariableNode) {
+              return true;
+            }
+          });
+
+    if (!negated) {
+      if (termNodeMatchesMetaArgumentVariableNode) {
+        statementVerifiedAsDefinedContainedAssertion = true;
+      }
+    }
+
+    if (negated) {
+      if (!termNodeMatchesMetaArgumentVariableNode) {
+        statementVerifiedAsDefinedContainedAssertion = true;
+      }
+    }
+
+    if (statementVerifiedAsDefinedContainedAssertion) {
+      localContext.debug(`...verified the '${containedAssertionString}' derived statement as a contained assertion.`, containedAssertionNode);
+    }
+  }
+
+  return statementVerifiedAsDefinedContainedAssertion;
+}
+
+function verifyStatementAsStatedContainedAssertion(containedAssertionNode, assignments, derived, localContext) {
+  let statementVerifiedAsStatedContainedAssertion = false;
+
+  if (!derived) {
+    const containedAssertionString = localContext.nodeAsString(containedAssertionNode);
+
+    localContext.trace(`Verifying the '${containedAssertionString}' stated statement as a contained assertion...`, containedAssertionNode);
+
+    const intrinsicLevel = localContext.isIntrinsicLevel();
+
+    if (intrinsicLevel) {
+      localContext.debug(`The '${containedAssertionString}' stated statement as a contained assertion cannot be verified at intrinsic level.`, containedAssertionNode);
+    } else {
+      const nonTerminalNode = containedAssertionNode, ///
+            nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
+              const verifiedAhead = true;
+
+              return verifiedAhead;
+            });
+
+      statementVerifiedAsStatedContainedAssertion = nonTerminalNodeVerified; ///
+    }
+
+    if (statementVerifiedAsStatedContainedAssertion) {
+      localContext.debug(`...verified the '${containedAssertionString}' stated statement as a contained assertion.`, containedAssertionNode);
+    }
+  }
+
+  return statementVerifiedAsStatedContainedAssertion;
+}

package/src/verify/{statementAsDefinedAssertion.js → assertion/defined.js}

@@ -1,26 +1,24 @@
 "use strict";
 
-import verifyTerm from "./term";
-import metaLevelNodeVerifier from "../verifier/node/metaLevel";
+import verifyTerm from "../../verify/term";
+import metaLevelNodeVerifier from "../../verifier/node/metaLevel";
 
-import { first } from "../utilities/array";
-import { DEFINED } from "../constants";
-import { isStatementNegated } from "../utilities/verify";
-import { nodeQuery, nodesQuery } from "../utilities/query";
+import { first } from "../../utilities/array";
+import { nodeQuery } from "../../utilities/query";
+import { isAssertionNegated } from "../../utilities/verify";
 
 const termNodeQuery = nodeQuery("/statement/term!"),
-      variableNodeQuery = nodeQuery("/statement/term/variable!"),
-      operatorTerminalNodesQuery = nodesQuery("/statement/@operator");
+      variableNodeQuery = nodeQuery("/statement/term/variable!");
 
-export default function verifyStatementAsDefinedAssertion(statementNode, assignments, derived, localContext) {
+export default function verifyDefinedAssertion(definedAssertionNode, assignments, derived, localContext) {
   let statementVerifiedAsDefinedAssertion = false;
 
-  const statementDefinedAssertion = isStatementDefinedAssertion(statementNode);
+  const statementDefinedAssertion = isStatementDefinedAssertion(definedAssertionNode);
 
   if (statementDefinedAssertion) {
-    const statementString = localContext.nodeAsString(statementNode);
+    const definedAssertionString = localContext.nodeAsString(definedAssertionNode);
 
-    localContext.trace(`Verifying the '${statementString}' statement as a defined assertion...`, statementNode);
+    localContext.trace(`Verifying the '${definedAssertionString}' statement as a defined assertion...`, definedAssertionNode);
 
     const definedAssertionFunctions = [
       verifyDerivedStatementAsDefinedAssertion,
@@ -28,7 +26,7 @@ export default function verifyStatementAsDefinedAssertion(statementNode, assignm
     ];
 
     statementVerifiedAsDefinedAssertion = definedAssertionFunctions.some((definedAssertionFunction) => {
-      const statementVerifiedAsDefinedAssertion = definedAssertionFunction(statementNode, assignments, derived, localContext);
+      const statementVerifiedAsDefinedAssertion = definedAssertionFunction(definedAssertionNode, assignments, derived, localContext);
 
       if (statementVerifiedAsDefinedAssertion) {
         return true;
@@ -36,24 +34,24 @@ export default function verifyStatementAsDefinedAssertion(statementNode, assignm
     });
 
     if (statementVerifiedAsDefinedAssertion) {
-      localContext.debug(`...verified the '${statementString}' statement as a defined assertion.`, statementNode);
+      localContext.debug(`...verified the '${definedAssertionString}' statement as a defined assertion.`, definedAssertionNode);
     }
   }
 
   return statementVerifiedAsDefinedAssertion;
 }
 
-function verifyDerivedStatementAsDefinedAssertion(statementNode, assignments, derived, localContext) {
+function verifyDerivedStatementAsDefinedAssertion(definedAssertionNode, assignments, derived, localContext) {
   let derivedStatementVerifiedAsDefeindAssertion = false;
 
   if (derived) {
-    const statementString = localContext.nodeAsString(statementNode);
+    const definedAssertionString = localContext.nodeAsString(definedAssertionNode);
 
-    localContext.trace(`Verifying the derived '${statementString}' statement as a defined assertion...`, statementNode);
+    localContext.trace(`Verifying the '${definedAssertionString}' derived statement as a defined assertion...`, definedAssertionNode);
 
-    const statementNegated = isStatementNegated(statementNode),
-          variableNode = variableNodeQuery(statementNode),
-          termNode = termNodeQuery(statementNode);
+    const statementNegated = isAssertionNegated(definedAssertionNode),
+          variableNode = variableNodeQuery(definedAssertionNode),
+          termNode = termNodeQuery(definedAssertionNode);
 
     if (false) {
       ///
@@ -103,27 +101,27 @@ function verifyDerivedStatementAsDefinedAssertion(statementNode, assignments, de
     }
 
     if (derivedStatementVerifiedAsDefeindAssertion) {
-      localContext.debug(`...verified the derived '${statementString}' statement as a defined assertion.`, statementNode);
+      localContext.debug(`...verified the '${definedAssertionString}' derived statement as a defined assertion.`, definedAssertionNode);
     }
   }
 
   return derivedStatementVerifiedAsDefeindAssertion;
 }
 
-function verifyStatedStatementAsDefinedAssertion(statementNode, assignments, derived, localContext) {
+function verifyStatedStatementAsDefinedAssertion(definedAssertionNode, assignments, derived, localContext) {
   let statedStatementVerifiedAsDefinedAssertion = false;
 
   if (!derived) {
-    const statementString = localContext.nodeAsString(statementNode);
+    const definedAssertionString = localContext.nodeAsString(definedAssertionNode);
 
-    localContext.trace(`Verifying the stated '${statementString}' statement as a defined assertion...`, statementNode);
+    localContext.trace(`Verifying the '${definedAssertionString}' stated statement as a defined assertion...`, definedAssertionNode);
 
     const intrinsicLevel = localContext.isIntrinsicLevel();
 
     if (intrinsicLevel) {
-      localContext.debug(`The stated '${statementString}' statement as a defined assertion cannot be verified at intrinsic level.`, statementNode);
+      localContext.debug(`The '${definedAssertionString}' stated statement as a defined assertion cannot be verified at intrinsic level.`, definedAssertionNode);
     } else {
-      const nonTerminalNode = statementNode, ///
+      const nonTerminalNode = definedAssertionNode, ///
             nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
               const verifiedAhead = true;
 
@@ -134,23 +132,9 @@ function verifyStatedStatementAsDefinedAssertion(statementNode, assignments, der
     }
 
     if (statedStatementVerifiedAsDefinedAssertion) {
-      localContext.debug(`...verified the stated '${statementString}' statement as a defined assertion.`, statementNode);
+      localContext.debug(`...verified the '${definedAssertionString}' stated statement as a defined assertion.`, definedAssertionNode);
     }
   }
 
   return statedStatementVerifiedAsDefinedAssertion;
 }
-
-export function isStatementDefinedAssertion(statementNode) {
-  const operatorTerminalNodes = operatorTerminalNodesQuery(statementNode),
-        statementDefinedAssertion = operatorTerminalNodes.some((operatorTerminalNode) => {
-          const content = operatorTerminalNode.getContent(),
-                contentDefined = (content === DEFINED);
-
-          if (contentDefined) {
-            return true;
-          }
-        });
-
-  return statementDefinedAssertion;
-}