occam-verify-cli 0.0.968 → 0.0.971

package/src/utilities/brackets.js

@@ -0,0 +1,56 @@
+"use strict";
+
+import bracketedTermNode from "../node/term/bracketed";
+import bracketedStatementNode from "../node/statement/bracketed";
+
+import { nodeQuery } from "../utilities/query";
+import { BRACKETED_TERM_DEPTH, BRACKETED_STATEMENT_DEPTH } from "../constants";
+
+const bracketedTermChildNodeQuery = nodeQuery("/term/argument/term!"),
+      bracketedStatementChildNodeQuery = nodeQuery("/statement/metaArgument/statement!");
+
+export function stripBracketsFromTerm(statementNode) {
+  const bracketedTermChildNode = bracketedTermChildNodeFromTermNode(statementNode);
+
+  if (bracketedTermChildNode !== null) {
+    statementNode = bracketedTermChildNode;  ///
+  }
+
+  return statementNode;
+}
+
+export function stripBracketsFromStatement(statementNode) {
+  const bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
+
+  if (bracketedStatementChildNode !== null) {
+    statementNode = bracketedStatementChildNode;  ///
+  }
+
+  return statementNode;
+}
+
+function bracketedTermChildNodeFromTermNode(termNode) {
+  let bracketedTermChildNode = null;
+
+  const depth = BRACKETED_TERM_DEPTH,
+        termNodeMatchBracketedTermNode = termNode.match(bracketedTermNode, depth);
+
+  if (termNodeMatchBracketedTermNode) {
+    bracketedTermChildNode = bracketedTermChildNodeQuery(termNode);
+  }
+
+  return bracketedTermChildNode;
+}
+
+function bracketedStatementChildNodeFromStatementNode(statementNode) {
+  let bracketedStatementChildNode = null;
+
+  const depth = BRACKETED_STATEMENT_DEPTH,
+        statementNodeMatchBracketedStatementNode = statementNode.match(bracketedStatementNode, depth);
+
+  if (statementNodeMatchBracketedStatementNode) {
+    bracketedStatementChildNode = bracketedStatementChildNodeQuery(statementNode);
+  }
+
+  return bracketedStatementChildNode;
+}

package/src/utilities/name.js

@@ -14,14 +14,6 @@ export function typeNameFromTypeNode(typeNode) {
   return typeName;
 }
 
-export function nameFromMetavariableNode(metavariableNode) {
-  const nameTerminalNode = nameTerminalNodeQuery(metavariableNode),
-        nameTerminalNodeContent = nameTerminalNode.getContent(),
-        name = nameTerminalNodeContent; ///
-
-  return name;
-}
-
 export function metaTypeNameFromMetaTypeNode(metaTypeNode) {
     const metaTypeTerminalNode = metaTypeTerminalNodeQuery(metaTypeNode),
           metaTypeTerminalNodeContent = metaTypeTerminalNode.getContent(),
@@ -29,3 +21,11 @@ export function metaTypeNameFromMetaTypeNode(metaTypeNode) {
 
   return metaTypeName;
 }
+
+export function metavariableNameFromMetavariableNode(metavariableNode) {
+  const nameTerminalNode = nameTerminalNodeQuery(metavariableNode),
+        nameTerminalNodeContent = nameTerminalNode.getContent(),
+        metavariableName = nameTerminalNodeContent; ///
+
+  return metavariableName;
+}

package/src/utilities/node.js

@@ -4,8 +4,8 @@ import { parsersUtilities } from "occam-custom-grammars";
 
 import { nodeQuery } from "../utilities/query";
 import { combinedCustomGrammarFromNothing } from "./customGrammar";
-import { unqualifiedStatementTokensFromStatementString } from "../utilities/tokens";
 import { UNQUALIFIED_STATEMENT_RULE_NAME, CONSTRUCTOR_DECLARATION_RULE_NAME } from "../ruleNames";
+import { constructorDeclarationTokensFromTermString, unqualifiedStatementTokensFromStatementString } from "../utilities/tokens";
 
 const { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
 
@@ -15,6 +15,13 @@ const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
 const termNodeQuery = nodeQuery("/constructorDeclaration/term!"),
       statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
 
+export function termNodeFromTermString(termString, lexer, parser) {
+  const constructorDeclarationTokens = constructorDeclarationTokensFromTermString(termString, lexer),
+        termNode = termNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser);
+
+  return termNode;
+}
+
 export function statementNodeFromStatementString(statementString, lexer, parser) {
   const unqualifiedStatementTokens = unqualifiedStatementTokensFromStatementString(statementString, lexer),
         statementNode = statementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser);
@@ -23,37 +30,27 @@ export function statementNodeFromStatementString(statementString, lexer, parser)
 }
 
 export function termNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser) {
-  let termNode = null;
-
-  const constructorDeclarationNode = constructorDeclarationNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser);
-
-  if (constructorDeclarationNode !== null) {
-    termNode = termNodeQuery(constructorDeclarationNode);
-  }
+  const constructorDeclarationNode = constructorDeclarationNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser),
+        termNode = termNodeQuery(constructorDeclarationNode);
 
   return termNode;
 }
 
 export function statementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser) {
-  let statementNode = null;
-
-  const unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser);
-
-  if (unqualifiedStatementNode !== null) {
-    statementNode = statementNodeQuery(unqualifiedStatementNode);
-  }
+  const unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser),
+        statementNode = statementNodeQuery(unqualifiedStatementNode);
 
   return statementNode;
 }
 
-export function unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser) {
+function unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser) {
   const ruleName = UNQUALIFIED_STATEMENT_RULE_NAME,
         unqualifiedStatementNode = nodeFromTokensRuleNameAndParser(unqualifiedStatementTokens, ruleName, parser);
 
   return unqualifiedStatementNode;
 }
 
-export function constructorDeclarationNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser) {
+function constructorDeclarationNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser) {
   const ruleName = CONSTRUCTOR_DECLARATION_RULE_NAME,
         constructorDeclarationNode = nodeFromTokensRuleNameAndParser(constructorDeclarationTokens, ruleName, parser);
 

package/src/utilities/string.js

@@ -36,14 +36,14 @@ export function nodesAsString(nodes, tokens) {
   return string;
 }
 
-export function terminalNodeAsString(terminalNode) {
+function terminalNodeAsString(terminalNode) {
   const content = terminalNode.getContent(),
         string = content; ///
 
   return string;
 }
 
-export function nonTerminalNodeAsString(nonTerminalNode, tokens) {
+function nonTerminalNodeAsString(nonTerminalNode, tokens) {
   const lastSignificantTokenIndex = nonTerminalNode.getLastSignificantTokenIndex(tokens),
         firstSignificantTokenIndex = nonTerminalNode.getFirstSignificantTokenIndex(tokens),
         start = firstSignificantTokenIndex, ///

package/src/utilities/subproof.js

@@ -0,0 +1,18 @@
+"use strict";
+
+import { nodeQuery, nodesQuery } from "./query";
+import { nodeAsString, nodesAsString } from "./string";
+
+const subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement/statement!"),
+      subproofLastProofStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/lastProofStep/unqualifiedStatement|qualifiedStatement/statement!");
+
+export function subproofNodeAsSubproofString(subproofNode, localContext) {
+  const tokens = localContext.getTokens(),
+        subproofSuppositionStatementNodes = subproofSuppositionStatementNodesQuery(subproofNode),
+        subproofLastProofStepStatementNode = subproofLastProofStepStatementNodeQuery(subproofNode),
+        subproofSuppositionStatementsString = nodesAsString(subproofSuppositionStatementNodes, tokens),
+        subproofLastProofStepStatementString = nodeAsString(subproofLastProofStepStatementNode, tokens),
+        subproofString = `[${subproofSuppositionStatementsString}]...${subproofLastProofStepStatementString}`;
+
+  return subproofString;
+}

package/src/utilities/unify.js

@@ -1,18 +1,30 @@
 "use strict";
 
-import { nodeQuery, nodesQuery } from "./query";
-import { nodeAsString, nodesAsString } from "./string";
+import { nodeQuery } from "../utilities/query";
 
-const subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement/statement!"),
-      subproofLastProofStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/lastProofStep/unqualifiedStatement|qualifiedStatement/statement!");
+const variableNodeQuery = nodeQuery("/term/variable"),
+      metavariableNodeQuery = nodeQuery("/statement/metavariable");
 
-export function subproofNodeAsSubproofString(subproofNode, localContext) {
-  const tokens = localContext.getTokens(),
-        subproofSuppositionStatementNodes = subproofSuppositionStatementNodesQuery(subproofNode),
-        subproofLastProofStepStatementNode = subproofLastProofStepStatementNodeQuery(subproofNode),
-        subproofSuppositionStatementsString = nodesAsString(subproofSuppositionStatementNodes, tokens),
-        subproofLastProofStepStatementString = nodeAsString(subproofLastProofStepStatementNode, tokens),
-        subproofString = `[${subproofSuppositionStatementsString}]...${subproofLastProofStepStatementString}`;
+export function variableFromTermNode(termNode, localContext) {
+  let variable = null;
 
-  return subproofString;
+  const variableNode = variableNodeQuery(termNode);
+
+  if (variableNode !== null) {
+    variable = localContext.findVariableByVariableNode(variableNode);
+  }
+
+  return variable;
+}
+
+export function metavariableFromStatementNode(statementNode, localContext) {
+  let metavariable = null;
+
+  const metavariableNode = metavariableNodeQuery(statementNode)
+
+  if (metavariableNode !== null) {
+    metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode);
+  }
+
+  return metavariable;
 }

package/src/variable.js

@@ -19,31 +19,31 @@ export default class Variable {
   match(variable) {
     const type = variable.getType(),
           node = variable.getNode(),
-          matchesType = this.matchType(type),
-          matchesNode = this.matchNode(node),
-          matches = matchesNode && matchesType;
+          typeMatches = this.matchType(type),
+          nodeMatches = this.matchNode(node),
+          matches = nodeMatches && typeMatches;
 
     return matches;
   }
 
   matchNode(node) {
-    const matchesNode = this.node.match(node);
+    const nodeMatches = this.node.match(node);
 
-    return matchesNode;
+    return nodeMatches;
   }
 
   matchType(type) {
-    const matchesType = this.type.match(type);
+    const typeMatches = this.type.match(type);
 
-    return matchesType;
+    return typeMatches;
   }
 
   matchNodeAndType(node, type) {
-    const matchesNode = this.matchNode(node),
-          matchesType = this.matchType(type),
-          matchesNodeAndType = matchesNode && matchesType;
+    const nodeMatches = this.matchNode(node),
+          typeNatches = this.matchType(type),
+          nodeAndTypeMatch = (nodeMatches && typeNatches);
 
-    return matchesNodeAndType;
+    return nodeAndTypeMatch;
   }
 
   asString(tokens) {

package/src/verifier/metaLevel.js

@@ -9,12 +9,12 @@ const termNodeQuery = nodeQuery("/term!"),
       statementNodeQuery = nodeQuery("/statement!");
 
 class MetaLevelVerifier extends Verifier {
-  verify(node, assignments, derived, localContext) {
+  verify(node, assignments, stated, localContext) {
     let verified;
 
     const nonTerminalNode = node, ///
           childNodes = nonTerminalNode.getChildNodes(),
-          nonTerminalNodeVerified = this.verifyChildNodes(childNodes, assignments, derived, localContext);
+          nonTerminalNodeVerified = this.verifyChildNodes(childNodes, assignments, stated, localContext);
 
     verified = nonTerminalNodeVerified;  ///
 
@@ -24,16 +24,16 @@ class MetaLevelVerifier extends Verifier {
   static maps = [
     {
       nodeQuery: statementNodeQuery,
-      verify: (statementNode, assignments, derived, localContext) => {
+      verify: (statementNode, assignments, stated, localContext) => {
         const { verifyStatement } = shim,
-              statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
+              statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
 
         return statementVerified;
       }
     },
     {
       nodeQuery: termNodeQuery,
-      verify: (termNode, assignments, derived, localContext) => {
+      verify: (termNode, assignments, stated, localContext) => {
         const { verifyTerm } = shim,
               terms = [],
               termVerified = verifyTerm(termNode, terms, localContext, () => {

package/src/verifier/statementAsCombinator.js

@@ -29,10 +29,10 @@ class StatementAsCombinatorVerifier extends Verifier {
       nodeQuery: statementNodeQuery,
       verify: (statementNode, fileContext) => {
         const { verifyStatement } = shim,
-              derived = true, ///
+              stated = false, ///
               assignments = [],
               localContext = LocalContext.fromFileContext(fileContext),
-              statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
+              statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
 
         return statementVerified;
       }

package/src/verify/assertion/contained.js

@@ -1,30 +1,45 @@
 "use strict";
 
-import { isAssertionNegated } from "../../utilities/verify";
+import metaLevelVerifier from "../../verifier/metaLevel";
+
+import { isAssertionNegated } from "../../utilities/assertion";
 import { nodeQuery, nodesQuery } from "../../utilities/query";
 
-const termNodeQuery = nodeQuery("/statement/term!"),
-      statementTermNodesQuery = nodesQuery("/statement/metaArgument/statement//term");
+const variableNodeQuery = nodeQuery("/containedAssertion/variable!"),
+      metavariableNodeQuery = nodeQuery("/containedAssertion/metavariable"),
+      statementVariableNodesQuery = nodesQuery("/containedAssertion/statement//variable"),
+      statementMetavariableNodesQuery = nodesQuery("/containedAssertion/statement//metavariable");
+
+const verifyContainedAssertionFunctions = [
+  verifyDerivedContainedAssertion,
+  verifyStatedContainedAssertion
+];
 
-export default function verifyContainedAssertion(containedAssertionNode, assignments, derived, localContext) {
-  let containedAssertionVerified;
+export default function verifyContainedAssertion(containedAssertionNode, assignments, stated, localContext) {
+  let containedAssertionVerified = false;
 
-  const containedAssertionString = localContext.nodeAsString(containedAssertionNode);
+  const containedAssertionString = localContext.nodeAsString(containedAssertionNode),
+        savedStated = stated; ///
 
   localContext.trace(`Verifying the '${containedAssertionString}' contained assertion...`, containedAssertionNode);
 
-  const verifyContainedAssertionFunctions = [
-    verifyDerivedContainedAssertion,
-    verifyStatedContainedAssertion
-  ];
+  assignments = []; ///
 
-  containedAssertionVerified = verifyContainedAssertionFunctions.some((verifyContainedAssertionFunction) => {
-    const containedAssertionVerified = verifyContainedAssertionFunction(containedAssertionNode, assignments, derived, localContext);
+  stated = true;  ///
 
-    if (containedAssertionVerified) {
-      return true;
-    }
-  });
+  const verified = metaLevelVerifier.verify(containedAssertionNode, assignments, stated, localContext);
+
+  stated = savedStated; ///
+
+  if (verified) {
+    containedAssertionVerified = verifyContainedAssertionFunctions.some((verifyContainedAssertionFunction) => {
+      const containedAssertionVerified = verifyContainedAssertionFunction(containedAssertionNode, assignments, stated, localContext);
+
+      if (containedAssertionVerified) {
+        return true;
+      }
+    });
+  }
 
   if (containedAssertionVerified) {
     localContext.debug(`...verified the '${containedAssertionString}' contained assertion.`, containedAssertionNode);
@@ -33,35 +48,62 @@ export default function verifyContainedAssertion(containedAssertionNode, assignm
   return containedAssertionVerified;
 }
 
-function verifyDerivedContainedAssertion(containedAssertionNode, assignments, derived, localContext) {
+function verifyDerivedContainedAssertion(containedAssertionNode, assignments, stated, localContext) {
   let derivedContainedAssertionVerified = false;
 
-  if (derived) {
+  if (!stated) {
     const containedAssertionString = localContext.nodeAsString(containedAssertionNode);
 
     localContext.trace(`Verifying the '${containedAssertionString}' derived contained assertion...`, containedAssertionNode);
 
     const assertionNegated = isAssertionNegated(containedAssertionNode),
-          termNode = termNodeQuery(containedAssertionNode),
-          negated = assertionNegated, ///
-          statementTermNodes = statementTermNodesQuery(containedAssertionNode),
-          termNodeMatchesMetaArgumentVariableNode = statementTermNodes.some((statementTermNode) => {
-            const termNodeMatchesMetaArgumentVariableNode = termNode.match(statementTermNode);
-
-            if (termNodeMatchesMetaArgumentVariableNode) {
-              return true;
-            }
-          });
-
-    if (!negated) {
-      if (termNodeMatchesMetaArgumentVariableNode) {
-        derivedContainedAssertionVerified = true;
+          metavariableNode = metavariableNodeQuery(containedAssertionNode),
+          variableNode = variableNodeQuery(containedAssertionNode),
+          negated = assertionNegated; ///
+
+    if (false) {
+      ///
+    } else if (metavariableNode !== null) {
+      const statementMetavariableNodes = statementMetavariableNodesQuery(containedAssertionNode),
+            variableNodeMatchesStatementMetavariableNode = statementMetavariableNodes.some((statementMetavariableNode) => {
+              const variableNodeMatchesStatementMetavariableNode = variableNode.match(statementMetavariableNode);
+
+              if (variableNodeMatchesStatementMetavariableNode) {
+                return true;
+              }
+            });
+
+      if (!negated) {
+        if (variableNodeMatchesStatementMetavariableNode) {
+          derivedContainedAssertionVerified = true;
+        }
+      }
+
+      if (negated) {
+        if (!variableNodeMatchesStatementMetavariableNode) {
+          derivedContainedAssertionVerified = true;
+        }
+      }
+    } else if (variableNode !== null) {
+      const statementVariableNodes = statementVariableNodesQuery(containedAssertionNode),
+            variableNodeMatchesStatementVariableNode = statementVariableNodes.some((statementVariableNode) => {
+              const variableNodeMatchesStatementVariableNode = variableNode.match(statementVariableNode);
+
+              if (variableNodeMatchesStatementVariableNode) {
+                return true;
+              }
+            });
+
+      if (!negated) {
+        if (variableNodeMatchesStatementVariableNode) {
+          derivedContainedAssertionVerified = true;
+        }
       }
-    }
 
-    if (negated) {
-      if (!termNodeMatchesMetaArgumentVariableNode) {
-        derivedContainedAssertionVerified = true;
+      if (negated) {
+        if (!variableNodeMatchesStatementVariableNode) {
+          derivedContainedAssertionVerified = true;
+        }
       }
     }
 
@@ -73,10 +115,10 @@ function verifyDerivedContainedAssertion(containedAssertionNode, assignments, de
   return derivedContainedAssertionVerified;
 }
 
-function verifyStatedContainedAssertion(containedAssertionNode, assignments, derived, localContext) {
+function verifyStatedContainedAssertion(containedAssertionNode, assignments, stated, localContext) {
   let statedContainedAssertionVerified;
 
-  if (!derived) {
+  if (stated) {
     const containedAssertionString = localContext.nodeAsString(containedAssertionNode);
 
     localContext.trace(`Verifying the '${containedAssertionString}' stated contained assertion...`, containedAssertionNode);

package/src/verify/assertion/defined.js

@@ -1,33 +1,40 @@
 "use strict";
 
 import verifyTerm from "../../verify/term";
+import metaLevelVerifier from "../../verifier/metaLevel";
 
 import { first } from "../../utilities/array";
 import { nodeQuery } from "../../utilities/query";
-import { isAssertionNegated } from "../../utilities/verify";
+import { isAssertionNegated } from "../../utilities/assertion";
 
-const termNodeQuery = nodeQuery("/statement/term!"),
-      variableNodeQuery = nodeQuery("/statement/term/variable!");
+const variableNodeQuery = nodeQuery("/definedAssertion/variable!"),
+      metavariableNodeQuery = nodeQuery("/definedAssertion/metavariable!");
 
-export default function verifyDefinedAssertion(definedAssertionNode, assignments, derived, localContext) {
+const verifyDefinedAssertionFunctions = [
+  verifyDerivedDefinedAssertion,
+  verifyStatedDefinedAssertion
+];
+
+export default function verifyDefinedAssertion(definedAssertionNode, assignments, stated, localContext) {
   let definedAssertionVerified;
 
   const definedAssertionString = localContext.nodeAsString(definedAssertionNode);
 
   localContext.trace(`Verifying the '${definedAssertionString}' defined assertion...`, definedAssertionNode);
 
-  const verifyDefinedAssertionFunctions = [
-    verifyDerivedDefinedAssertion,
-    verifyStatedDefinedAssertion
-  ];
+  assignments = []; ///
 
-  definedAssertionVerified = verifyDefinedAssertionFunctions.some((verifyDefinedAssertionFunction) => {
-    const definedAssertionVerified = verifyDefinedAssertionFunction(definedAssertionNode, assignments, derived, localContext);
+  const verified = metaLevelVerifier.verify(definedAssertionNode, assignments, stated, localContext);
 
-    if (definedAssertionVerified) {
-      return true;
-    }
-  });
+  if (verified) {
+    definedAssertionVerified = verifyDefinedAssertionFunctions.some((verifyDefinedAssertionFunction) => {
+      const definedAssertionVerified = verifyDefinedAssertionFunction(definedAssertionNode, assignments, stated, localContext);
+
+      if (definedAssertionVerified) {
+        return true;
+      }
+    });
+  }
 
   if (definedAssertionVerified) {
     localContext.debug(`...verified the '${definedAssertionString}' defined assertion.`, definedAssertionNode);
@@ -36,61 +43,48 @@ export default function verifyDefinedAssertion(definedAssertionNode, assignments
   return definedAssertionVerified;
 }
 
-function verifyDerivedDefinedAssertion(definedAssertionNode, assignments, derived, localContext) {
+function verifyDerivedDefinedAssertion(definedAssertionNode, assignments, stated, localContext) {
   let derivedDefinedAssertionVerified = false;
 
-  if (derived) {
+  if (!stated) {
     const definedAssertionString = localContext.nodeAsString(definedAssertionNode);
 
     localContext.trace(`Verifying the '${definedAssertionString}' derived defined assertion...`, definedAssertionNode);
 
-    const statementNegated = isAssertionNegated(definedAssertionNode),
-          variableNode = variableNodeQuery(definedAssertionNode),
-          termNode = termNodeQuery(definedAssertionNode);
+    const assertionNegated = isAssertionNegated(definedAssertionNode),
+          metavariableNode = metavariableNodeQuery(definedAssertionNode),
+          variableNode = variableNodeQuery(definedAssertionNode);
 
     if (false) {
       ///
-    } else if (variableNode !== null) {
-      const variable = localContext.findVariableByVariableNode(variableNode);
-
-      if (variable !== null) {
-        const variableDefined = localContext.isVariableDefined(variable);
+    } else if (metavariableNode !== null) {
+      const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode),
+            metavariableDefined = localContext.isMetavariableDefined(metavariable);
 
-        if (!statementNegated) {
-          if (variableDefined) {
-            derivedDefinedAssertionVerified = true;
-          }
+      if (!assertionNegated) {
+        if (metavariableDefined) {
+          derivedDefinedAssertionVerified = true;
         }
+      }
 
-        if (statementNegated) {
-          if (!variableDefined) {
-            derivedDefinedAssertionVerified = true;
-          }
+      if (assertionNegated) {
+        if (!metavariableDefined) {
+          derivedDefinedAssertionVerified = true;
         }
       }
-    } else if (termNode !== null) {
-      const terms = [],
-            termVerified = verifyTerm(termNode, terms, localContext, () => {
-              const verifiedAhead = true;
-
-              return verifiedAhead;
-            });
-
-      if (termVerified) {
-        const firstTerm = first(terms),
-              term = firstTerm, ///
-              termGrounded = localContext.isTermGrounded(term);
-
-        if (!statementNegated) {
-          if (termGrounded) {
-            derivedDefinedAssertionVerified = true;
-          }
+    } else if (variableNode !== null) {
+      const variable = localContext.findVariableByVariableNode(variableNode),
+            variableDefined = localContext.isVariableDefined(variable);
+
+      if (!assertionNegated) {
+        if (variableDefined) {
+          derivedDefinedAssertionVerified = true;
         }
+      }
 
-        if (statementNegated) {
-          if (!termGrounded) {
-            derivedDefinedAssertionVerified = true;
-          }
+      if (assertionNegated) {
+        if (!variableDefined) {
+          derivedDefinedAssertionVerified = true;
         }
       }
     }
@@ -103,10 +97,10 @@ function verifyDerivedDefinedAssertion(definedAssertionNode, assignments, derive
   return derivedDefinedAssertionVerified;
 }
 
-function verifyStatedDefinedAssertion(definedAssertionNode, assignments, derived, localContext) {
+function verifyStatedDefinedAssertion(definedAssertionNode, assignments, stated, localContext) {
   let statedDefinedAssertionVerified;
 
-  if (!derived) {
+  if (stated) {
     const definedAssertionString = localContext.nodeAsString(definedAssertionNode);
 
     localContext.trace(`Verifying the '${definedAssertionString}' stated defined assertion...`, definedAssertionNode);
@@ -120,3 +114,18 @@ function verifyStatedDefinedAssertion(definedAssertionNode, assignments, derived
 
   return statedDefinedAssertionVerified;
 }
+
+function termFromTermNode(termNode, localContext) {
+  const terms = [];
+
+  verifyTerm(termNode, terms, localContext, () => {
+    const verifiedAhead = true;
+
+    return verifiedAhead;
+  });
+
+  const firstTerm = first(terms),
+        term = firstTerm; ///
+
+  return term;
+}