occam-verify-cli 0.0.918 → 0.0.920

package/src/verify/metastatement.js

@@ -2,6 +2,8 @@
 
 import verifyJudgement from "../verify/judgement";
 import metaLevelNodeVerifier from "../verifier/node/metaLevel";
+import verifyMetastatementAsDefinedAssertion from "./metastatementAsDefinedAssertion";
+import verifyMetastatementAsContainedAssertion from "./metastatementAsContainedAssertion";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -16,6 +18,8 @@ function verifyMetastatement(metastatementNode, assignments, derived, localConte
 
   const verifyMetaStatementFunctions = [
     verifyMetastatementAsJudgement,
+    verifyMetastatementAsDefinedAssertion,
+    verifyMetastatementAsContainedAssertion,
     verifyMetastatementAsIs
   ];
 

package/src/verify/metastatementAsContainedAssertion.js

@@ -0,0 +1,127 @@
+"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;
+}

package/src/verify/metastatementAsDefinedAssertion.js

@@ -0,0 +1,156 @@
+"use strict";
+
+import verifyTerm from "./term";
+import metaLevelNodeVerifier from "../verifier/node/metaLevel";
+
+import { first } from "../utilities/array";
+import { DEFINED } from "../constants";
+import { nodeQuery, nodesQuery } from "../utilities/query";
+import { isMetastatementNegated } from "../utilities/verify";
+
+const termNodeQuery = nodeQuery("/metastatement/term!"),
+      variableNodeQuery = nodeQuery("/metastatement/term/variable!"),
+      operatorTerminalNodesQuery = nodesQuery("/metastatement/@operator");
+
+export default function verifyMetastatementAsDefinedAssertion(metastatementNode, assignments, derived, localContext) {
+  let metastatementVerifiedAsDefinedAssertion = false;
+
+  const metastatementDefinedAssertion = isMetastatementDefinedAssertion(metastatementNode);
+
+  if (metastatementDefinedAssertion) {
+    const metastatementString = localContext.nodeAsString(metastatementNode);
+
+    localContext.trace(`Verifying the '${metastatementString}' metastatement as a defined assertion...`, metastatementNode);
+
+    const definedAssertionFunctions = [
+      verifyDerivedMetastatementAsDefinedAssertion,
+      verifyStatedMetastatementAsDefinedAssertion
+    ];
+
+    metastatementVerifiedAsDefinedAssertion = definedAssertionFunctions.some((definedAssertionFunction) => {
+      const metastatementVerifiedAsDefinedAssertion = definedAssertionFunction(metastatementNode, assignments, derived, localContext);
+
+      if (metastatementVerifiedAsDefinedAssertion) {
+        return true;
+      }
+    });
+
+    if (metastatementVerifiedAsDefinedAssertion) {
+      localContext.debug(`...verified the '${metastatementString}' metastatement as a defined assertion.`, metastatementNode);
+    }
+  }
+
+  return metastatementVerifiedAsDefinedAssertion;
+}
+
+function verifyDerivedMetastatementAsDefinedAssertion(metastatementNode, assignments, derived, localContext) {
+  let derivedMetastatementVerifiedAsDefeindAssertion = false;
+
+  if (derived) {
+    const metastatementString = localContext.nodeAsString(metastatementNode);
+
+    localContext.trace(`Verifying the derived '${metastatementString}' metastatement as a defined assertion...`, metastatementNode);
+
+    const metastatementNegated = isMetastatementNegated(metastatementNode),
+          variableNode = variableNodeQuery(metastatementNode),
+          termNode = termNodeQuery(metastatementNode);
+
+    if (false) {
+      ///
+    } else if (variableNode !== null) {
+      const variable = localContext.findVariableByVariableNode(variableNode);
+
+      if (variable !== null) {
+        const variableDefined = localContext.isVariableDefined(variable);
+
+        if (!metastatementNegated) {
+          if (variableDefined) {
+            derivedMetastatementVerifiedAsDefeindAssertion = true;
+          }
+        }
+
+        if (metastatementNegated) {
+          if (!variableDefined) {
+            derivedMetastatementVerifiedAsDefeindAssertion = 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 (!metastatementNegated) {
+          if (termGrounded) {
+            derivedMetastatementVerifiedAsDefeindAssertion = true;
+          }
+        }
+
+        if (metastatementNegated) {
+          if (!termGrounded) {
+            derivedMetastatementVerifiedAsDefeindAssertion = true;
+          }
+        }
+      }
+    }
+
+    if (derivedMetastatementVerifiedAsDefeindAssertion) {
+      localContext.debug(`...verified the derived '${metastatementString}' metastatement as a defined assertion.`, metastatementNode);
+    }
+  }
+
+  return derivedMetastatementVerifiedAsDefeindAssertion;
+}
+
+function verifyStatedMetastatementAsDefinedAssertion(metastatementNode, assignments, derived, localContext) {
+  let statedMetastatementVerifiedAsDefinedAssertion = false;
+
+  if (!derived) {
+    const metastatementString = localContext.nodeAsString(metastatementNode);
+
+    localContext.trace(`Verifying the stated '${metastatementString}' metastatement as a defined assertion...`, metastatementNode);
+
+    const intrinsicLevel = localContext.isIntrinsicLevel();
+
+    if (intrinsicLevel) {
+      localContext.debug(`The stated '${metastatementString}' metastatement as a defined assertion cannot be verified at intrinsic level.`, metastatementNode);
+    } else {
+      const nonTerminalNode = metastatementNode, ///
+            nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
+              const verifiedAhead = true;
+
+              return verifiedAhead;
+            });
+
+      statedMetastatementVerifiedAsDefinedAssertion = nonTerminalNodeVerified; ///
+    }
+
+    if (statedMetastatementVerifiedAsDefinedAssertion) {
+      localContext.debug(`...verified the stated '${metastatementString}' metastatement as a defined assertion.`, metastatementNode);
+    }
+  }
+
+  return statedMetastatementVerifiedAsDefinedAssertion;
+}
+
+export function isMetastatementDefinedAssertion(metastatementNode) {
+  const operatorTerminalNodes = operatorTerminalNodesQuery(metastatementNode),
+        metastatementDefinedAssertion = operatorTerminalNodes.some((operatorTerminalNode) => {
+          const content = operatorTerminalNode.getContent(),
+                contentDefined = (content === DEFINED);
+
+          if (contentDefined) {
+            return true;
+          }
+        });
+
+  return metastatementDefinedAssertion;
+}

package/src/verify/premise.js

@@ -41,8 +41,7 @@ export default function verifyPremise(premiseNode, premises, localContext) {
           unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localContext);
 
     if (unqualifiedMetastatementVerified) {
-      const localContext = localContext,  ///
-            assignmentAssigned = assignAssignment(assignments, localContext);
+      const assignmentAssigned = assignAssignment(assignments, localContext);
 
       premiseVerified = assignmentAssigned; ///
     }

package/src/verify/statement.js

@@ -7,12 +7,12 @@ import verifyStatementAsDefinedAssertion from "../verify/statementAsDefinedAsser
 import verifyStatementAsContainedAssertion from "../verify/statementAsContainedAssertion";
 import statementAgainstCombinatorNodesVerifier from "../verifier/nodes/statementAgainstCombinator";
 
-import { DEFINED, CONTAINED } from "../constants";
-import { nodeQuery, nodesQuery } from "../utilities/query";
+import { nodeQuery } from "../utilities/query";
+import { isStatementDefinedAssertion } from "../verify/statementAsDefinedAssertion";
+import { isStatementContainedAssertion } from "../verify/statementAsContainedAssertion";
 
 const equalityNodeQuery = nodeQuery("/statement/equality!"),
-      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!"),
-      operatorTerminalNodesQuery = nodesQuery("/statement/@operator");
+      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
 
 function verifyStatement(statementNode, assignments, derived, localContext) {
   let statementVerified;
@@ -191,35 +191,7 @@ function isStatementEquality(statementNode) {
 
 function isStatementTypeAssertion(statementNode) {
   const typeAssertionNode = typeAssertionNodeQuery(statementNode),
-        statementTypeAssertion = (typeAssertionNode === null);
+        statementTypeAssertion = (typeAssertionNode !== null);
 
   return statementTypeAssertion;
 }
-
-function isStatementDefinedAssertion(statementNode) {
-  const operatorTerminalNodes = operatorTerminalNodesQuery(statementNode),
-        statementDefinedAssertion = operatorTerminalNodes.some((operatorTerminalNode) => {
-          const content = operatorTerminalNode.getContent(),
-                contentDefined = (content === DEFINED);
-
-          if (contentDefined) {
-            return true;
-          }
-        });
-
-  return statementDefinedAssertion;
-}
-
-function isStatementContainedAssertion(statementNode) {
-  const operatorTerminalNodes = operatorTerminalNodesQuery(statementNode),
-        statementContainedAssertion = operatorTerminalNodes.some((operatorTerminalNode) => {
-          const content = operatorTerminalNode.getContent(),
-                contentContained = (content === CONTAINED);
-
-          if (contentContained) {
-            return true;
-          }
-        });
-
-  return statementContainedAssertion;
-}

package/src/verify/statementAsContainedAssertion.js

@@ -2,34 +2,40 @@
 
 import metaLevelNodeVerifier from "../verifier/node/metaLevel";
 
-import { isAssertionNegated } from "../utilities/verify";
+import { CONTAINED } from "../constants";
+import { isStatementNegated } from "../utilities/verify";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const variableNodeQuery = nodeQuery("/statement/term/variable!"),
-      metastatementVariableNodesQuery = nodesQuery("/statement/statement//variable");
+const termNodeQuery = nodeQuery("/statement/term!"),
+      statementTermNodesQuery = nodesQuery("/statement/metaArgument/statement//term"),
+      operatorTerminalNodesQuery = nodesQuery("/statement/@operator");
 
 export default function verifyStatementAsContainedAssertion(statementNode, assignments, derived, localContext) {
   let statementVerifiedAsContainedAssertion;
 
-  const statementString = localContext.nodeAsString(statementNode);
+  const statementContainedAssertion = isStatementContainedAssertion(statementNode);
 
-  localContext.trace(`Verifying the '${statementString}' statement as a contained assertion...`, statementNode);
+  if (statementContainedAssertion) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the '${statementString}' statement as a contained assertion...`, statementNode);
 
-  const statementFunctions = [
-    verifyStatementAsDerivedContainedAssertion,
-    verifyStatementAsStatedContainedAssertion
-  ];
+    const statementFunctions = [
+      verifyStatementAsDerivedContainedAssertion,
+      verifyStatementAsStatedContainedAssertion
+    ];
 
-  statementVerifiedAsContainedAssertion = statementFunctions.some((statementFunction) => {
-    const statementVerifiedAsContainedAssertion = statementFunction(statementNode, assignments, derived, localContext);
+    statementVerifiedAsContainedAssertion = statementFunctions.some((statementFunction) => {
+      const statementVerifiedAsContainedAssertion = statementFunction(statementNode, assignments, derived, localContext);
+
+      if (statementVerifiedAsContainedAssertion) {
+        return true;
+      }
+    });
 
     if (statementVerifiedAsContainedAssertion) {
-      return true;
+      localContext.debug(`...verified the '${statementString}' statement as a contained assertion.`, statementNode);
     }
-  });
-
-  if (statementVerifiedAsContainedAssertion) {
-    localContext.debug(`...verified the '${statementString}' statement as a contained assertion.`, statementNode);
   }
 
   return statementVerifiedAsContainedAssertion;
@@ -43,32 +49,27 @@ function verifyStatementAsDerivedContainedAssertion(statementNode, assignments,
 
     localContext.trace(`Verifying the derived '${statementString}' statement as a contained assertion...`, statementNode);
 
-    const statementNegated = isAssertionNegated(statementNode),
-          variableNode = variableNodeQuery(statementNode),
-          negated = statementNegated;  ///
-
-    if (false) {
-      ///
-    } else if (variableNode !== null) {
-      const metastatementVariableNodes = metastatementVariableNodesQuery(statementNode),
-            variableNodeMatchesMetaArgumentVariableNode = metastatementVariableNodes.some((metastatementVariableNode) => {
-              const variableNodeMatchesMetaArgumentVariableNode = variableNode.match(metastatementVariableNode);
-
-              if (variableNodeMatchesMetaArgumentVariableNode) {
-                return true;
-              }
-            });
-
-      if (!negated) {
-        if (variableNodeMatchesMetaArgumentVariableNode) {
-          statementVerifiedAsDefinedContainedAssertion = true;
-        }
+    const statementNegated = isStatementNegated(statementNode),
+          termNode = termNodeQuery(statementNode),
+          negated = statementNegated, ///
+          statementTermNodes = statementTermNodesQuery(statementNode),
+          termNodeMatchesMetaArgumentVariableNode = statementTermNodes.some((statementTermNode) => {
+            const termNodeMatchesMetaArgumentVariableNode = termNode.match(statementTermNode);
+
+            if (termNodeMatchesMetaArgumentVariableNode) {
+              return true;
+            }
+          });
+
+    if (!negated) {
+      if (termNodeMatchesMetaArgumentVariableNode) {
+        statementVerifiedAsDefinedContainedAssertion = true;
       }
+    }
 
-      if (negated) {
-        if (!variableNodeMatchesMetaArgumentVariableNode) {
-          statementVerifiedAsDefinedContainedAssertion = true;
-        }
+    if (negated) {
+      if (!termNodeMatchesMetaArgumentVariableNode) {
+        statementVerifiedAsDefinedContainedAssertion = true;
       }
     }
 
@@ -110,3 +111,17 @@ function verifyStatementAsStatedContainedAssertion(statementNode, assignments, d
 
   return statementVerifiedAsStatedContainedAssertion;
 }
+
+export function isStatementContainedAssertion(statementNode) {
+  const operatorTerminalNodes = operatorTerminalNodesQuery(statementNode),
+        statementContainedAssertion = operatorTerminalNodes.some((operatorTerminalNode) => {
+          const content = operatorTerminalNode.getContent(),
+                contentContained = (content === CONTAINED);
+
+          if (contentContained) {
+            return true;
+          }
+        });
+
+  return statementContainedAssertion;
+}

package/src/verify/statementAsDefinedAssertion.js

@@ -4,34 +4,40 @@ import verifyTerm from "./term";
 import metaLevelNodeVerifier from "../verifier/node/metaLevel";
 
 import { first } from "../utilities/array";
-import { nodeQuery } from "../utilities/query";
+import { DEFINED } from "../constants";
 import { isStatementNegated } from "../utilities/verify";
+import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const termNodeQuery = nodeQuery("/statement/term!"),
-      variableNodeQuery = nodeQuery("/statement/term/variable!");
+      variableNodeQuery = nodeQuery("/statement/term/variable!"),
+      operatorTerminalNodesQuery = nodesQuery("/statement/@operator");
 
 export default function verifyStatementAsDefinedAssertion(statementNode, assignments, derived, localContext) {
-  let statementVerifiedAsDefinedAssertion;
+  let statementVerifiedAsDefinedAssertion = false;
 
-  const statementString = localContext.nodeAsString(statementNode);
+  const statementDefinedAssertion = isStatementDefinedAssertion(statementNode);
 
-  localContext.trace(`Verifying the '${statementString}' statement as a defined assertion...`, statementNode);
+  if (statementDefinedAssertion) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the '${statementString}' statement as a defined assertion...`, statementNode);
 
-  const definedAssertionFunctions = [
-    verifyDerivedStatementAsDefinedAssertion,
-    verifyStatedStatementAsDefinedAssertion
-  ];
+    const definedAssertionFunctions = [
+      verifyDerivedStatementAsDefinedAssertion,
+      verifyStatedStatementAsDefinedAssertion
+    ];
 
-  statementVerifiedAsDefinedAssertion = definedAssertionFunctions.some((definedAssertionFunction) => {
-    const statementVerifiedAsDefinedAssertion = definedAssertionFunction(statementNode, assignments, derived, localContext);
+    statementVerifiedAsDefinedAssertion = definedAssertionFunctions.some((definedAssertionFunction) => {
+      const statementVerifiedAsDefinedAssertion = definedAssertionFunction(statementNode, assignments, derived, localContext);
+
+      if (statementVerifiedAsDefinedAssertion) {
+        return true;
+      }
+    });
 
     if (statementVerifiedAsDefinedAssertion) {
-      return true;
+      localContext.debug(`...verified the '${statementString}' statement as a defined assertion.`, statementNode);
     }
-  });
-
-  if (statementVerifiedAsDefinedAssertion) {
-    localContext.debug(`...verified the '${statementString}' statement as a defined assertion.`, statementNode);
   }
 
   return statementVerifiedAsDefinedAssertion;
@@ -134,3 +140,17 @@ function verifyStatedStatementAsDefinedAssertion(statementNode, assignments, der
 
   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;
+}