occam-verify-cli 0.0.842 → 0.0.844

package/src/utilities/equivalences.js

@@ -1,6 +1,43 @@
 "use strict";
 
-import { push, filter, compress, separate } from "../utilities/array";
+import { push, compress, separate } from "../utilities/array";
+
+export function mergeEquivalences(equivalencesA, equivalencesB, localContext) {
+  const typesA = typesFromEquivalences(equivalencesA, localContext),
+        typesB = typesFromEquivalences(equivalencesB, localContext),
+        types = [
+          ...typesA,
+          ...typesB
+        ];
+
+  compress(types, (typeA, typeB) => {
+    if (typeA === typeB) {
+      return true;
+    }
+  });
+
+  const equivalences = types.map((type) => {
+    let equivalence;
+
+    const equivalenceA = findEquivalenceByType(equivalencesA, type, localContext),
+          equivalenceB = findEquivalenceByType(equivalencesB, type, localContext);
+
+    if ((equivalenceA !== null) && (equivalenceB !== null)) {
+      const leftEquivalence = equivalenceA, ///
+            rightEquivalence = equivalenceB;  ///
+
+      equivalence = Equivalence.merge(leftEquivalence, rightEquivalence);
+    } else if (equivalenceA !== null) {
+      equivalence = equivalenceA; ///
+    } else if (equivalenceB !== null) {
+      equivalence = equivalenceB; ///
+    }
+
+    return equivalence;
+  });
+
+  return equivalences;
+}
 
 export function areTermNodesEqual(leftTermNode, rightTermNode, equivalences) {
   let termNodesEqual;
@@ -46,87 +83,62 @@ export function findEquivalenceByTerm(equivalences, term) {
   return equivalence;
 }
 
-export function mergeEquivalences(equivalencesA, equivalencesB, localContext) {
-  const typesA = typesFromEquivalences(equivalencesA, localContext),
-        typesB = typesFromEquivalences(equivalencesB, localContext),
-        types = [
-          ...typesA,
-          ...typesB
-        ];
+export function groundedTermsAndDefinedVariablesFromFromEquivalences(equivalences, groundedTerms, definedVariables, context) {
+  let groundedEquivalences,
+      remainingEquivalences,
+      initiallyGroundedEquivalences,
+      implicitlyGroundedEquivalences;
 
-  compress(types, (typeA, typeB) => {
-    if (typeA === typeB) {
-      return true;
-    }
-  });
+  remainingEquivalences = [];
 
-  const equivalences = types.map((type) => {
-    let equivalence;
+  initiallyGroundedEquivalences = [];
 
-    const equivalenceA = findEquivalenceByType(equivalencesA, type, localContext),
-          equivalenceB = findEquivalenceByType(equivalencesB, type, localContext);
+  separateInitiallyGroundedEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences, context);
 
-    if ((equivalenceA !== null) && (equivalenceB !== null)) {
-      const leftEquivalence = equivalenceA, ///
-            rightEquivalence = equivalenceB;  ///
+  const initiallyGroundedEquivalencesLength = initiallyGroundedEquivalences.length;
 
-      equivalence = Equivalence.merge(leftEquivalence, rightEquivalence);
-    } else if (equivalenceA !== null) {
-      equivalence = equivalenceA; ///
-    } else if (equivalenceB !== null) {
-      equivalence = equivalenceB; ///
-    }
+  if (initiallyGroundedEquivalencesLength > 0) {
+    groundedEquivalences = initiallyGroundedEquivalences; ///
 
-    return equivalence;
-  });
+    let implicitlyGroundedEquivalencesLength = 1;
 
-  return equivalences;
-}
+    while (implicitlyGroundedEquivalencesLength > 0) {
+      let definedVariablesLength = 0,
+          previousDefinedVariablesLength = -1;
 
-export function separateEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences) {
-  separate(equivalences, remainingEquivalences, initiallyGroundedEquivalences, (equivalence) => {
-    const equivalenceInitiallyGrounded = equivalence.isInitiallyGrounded();
+      while (definedVariablesLength > previousDefinedVariablesLength) {
+        previousDefinedVariablesLength = definedVariablesLength;  ///
 
-    if (!equivalenceInitiallyGrounded) {
-      return true;
-    }
-  });
-}
+        groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, context);
 
-export function compressDefinedVariables(definedVariables) {
-  compress(definedVariables, (definedVariableA, definedVariableB) => {
-    if (definedVariableA === definedVariableB) {
-      return true;
-    }
-  });
-}
+        definedVariablesFromGroundedTerms(groundedTerms, definedVariables, context);
 
-export function definedVariablesFromGroundedEquivalences(groundedEquivalences, definedVariables, context) {
-  groundedEquivalences.forEach((groundedEquivalence) => {
-    const variables = groundedEquivalence.getVariables(context);
+        definedVariablesLength = definedVariables.length;
+      }
 
-    push(definedVariables, variables);
-  });
-}
+      equivalences = remainingEquivalences; ///
 
-export function implicitlyGroundedEquivalencesFromRemainingEquivalencesAndDefinedVariables(remainingEquivalences, definedVariables) {
-  const implicitlyGroundedEquivalences = [];
+      remainingEquivalences = [];
 
-  filter(remainingEquivalences, (remainingEquivalence) => {
-    const remainingEquivalenceImplicitlyGrounded = remainingEquivalence.isImplicitlyGrounded(definedVariables);
+      implicitlyGroundedEquivalences = [];
 
-    if (remainingEquivalenceImplicitlyGrounded) {
-      const implicitlyGroundedEquivalence = remainingEquivalence; ///
+      separateImplicitlyGroundedEquivalences(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, context);
 
-      implicitlyGroundedEquivalences.push(implicitlyGroundedEquivalence);
-    }
+      push(groundedEquivalences, implicitlyGroundedEquivalences);
 
-    if (!remainingEquivalenceImplicitlyGrounded) {
-      return true;
+      implicitlyGroundedEquivalencesLength = implicitlyGroundedEquivalences.length;  ///
     }
+  }
+}
+
+function typesFromEquivalences(equivalences, localContext) {
+  const types = equivalences.map((equivalence) => {
+    const type = equivalence.getType(localContext);
+
+    return type;
   });
 
-  return implicitlyGroundedEquivalences;
+  return types;
 }
 
 function findEquivalenceByTermNodes(equivalences, termNodes) {
@@ -141,12 +153,47 @@ function findEquivalenceByTermNodes(equivalences, termNodes) {
   return equivalence;
 }
 
-function typesFromEquivalences(equivalences, localContext) {
-  const types = equivalences.map((equivalence) => {
-    const type = equivalence.getType(localContext);
+function definedVariablesFromGroundedTerms(groundedTerms, definedVariables, context) {
+  const terms = groundedTerms,  ///
+        variables = definedVariables; ///
 
-    return type;
+  terms.forEach((term) => {
+    const termVariables = term.getVariables(context);
+
+    termVariables.forEach((termVariable) => {
+      const variablesIncludesTermVariable = variables.includes(termVariable);
+
+      if (!variablesIncludesTermVariable) {
+        const variable = termVariable;  ///
+
+        variables.push(variable);
+      }
+    });
   });
+}
 
-  return types;
+function separateInitiallyGroundedEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences, context) {
+  separate(equivalences, remainingEquivalences, initiallyGroundedEquivalences, (equivalence) => {
+    const equivalenceInitiallyGrounded = equivalence.isInitiallyGrounded(context);
+
+    if (!equivalenceInitiallyGrounded) {
+      return true;
+    }
+  });
+}
+
+function separateImplicitlyGroundedEquivalences(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, context) {
+  separate(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, (equivalence) => {
+    const equivalenceImplicitlyGrounded = equivalence.isImplicitlyGrounded(definedVariables, context);
+
+    if (!equivalenceImplicitlyGrounded) {
+      return true;
+    }
+  });
+}
+
+function groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, context) {
+  groundedEquivalences.forEach((groundedEquivalence) => {
+    groundedEquivalence.getGroundedTerms(definedVariables, groundedTerms, context);
+  });
 }

package/src/verifier/nodes/metaLevelToIntrinsicLevel.js

@@ -2,14 +2,15 @@
 
 import LocalContext from "../../context/local";
 import NodesVerifier from "../../verifier/nodes";
+import TermForVariableSubstitution from "../../substitution/termForVariable";
 import intrinsicLevelNodesVerifierMixins from "../../mixins/nodesVerifier/intrinsiclevel";
 import StatementForMetavariableSubstitution from "../../substitution/statementForMetavariable";
 
 import { nodeQuery } from "../../utilities/query";
+import { matchStatementNode } from "../../substitution/statementForMetavariable";
 import { TERM_RULE_NAME, STATEMENT_RULE_NAME, METASTATEMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from "../../ruleNames";
 
-const termNodeQuery = nodeQuery("/substitution/term!"),
-      variableNodeQuery = nodeQuery("/*/variable!"),
+const variableNodeQuery = nodeQuery("/*/variable!"),
       statementNodeQuery = nodeQuery("/metaArgument/statement"),
       metavariableNodeQuery = nodeQuery("/metastatement/metavariable!"),
       substitutionNodeQuery = nodeQuery("/metastatement/substitution!");
@@ -83,22 +84,8 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
           metavariableNodeA = metavariableNodeQuery(metastatementNodeA);
 
     if ((metavariableNodeA !== null) && (statementNodeB !== null)) {
-      const substitutionNodeA = substitutionNodeQuery(metastatementNodeA);
-
-      if (substitutionNodeA !== null) {
-        const variableNode = variableNodeQuery(substitutionNode),
-              variable = fileContextA.findVariableByVariableNode(variableNode);
-
-        if (variable !== null) {
-          const termNode = termNodeQuery(substitutionNode);
-
-          debugger
-
-
-        }
-      }
-
-      const metavariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, statementNodeB, substitutions, fileContextA, localContextB, verifyAhead);
+      const substitutionNodeA = substitutionNodeQuery(metastatementNodeA),
+            metavariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, substitutionNodeA, statementNodeB, substitutions, fileContextA, localContextB, verifyAhead);
 
       metaArgumentNodeVerified = metavariableNodeVerified;  ///
     }
@@ -106,7 +93,7 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
     return metaArgumentNodeVerified;
   }
 
-  verifyMetavariableNode(metavariableNodeA, statementNodeB, substitutions, fileContextA, localContextB, verifyAhead) {
+  verifyMetavariableNode(metavariableNodeA, substitutionNodeA, statementNodeB, substitutions, fileContextA, localContextB, verifyAhead) {
     let metavariableNodeVerified;
 
     const substitution = substitutions.find((substitution) => {
@@ -118,15 +105,28 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
     }) || null;
 
     if (substitution !== null) {
-      const statementNode = statementNodeB, ///
-            statementNodeMatches = substitution.matchStatementNode(statementNode);
+      const statementNode = substitution.getStatementNode(),
+            localContextA = LocalContext.fromFileContext(fileContextA);
 
-      metavariableNodeVerified = statementNodeMatches;  ///
+      if (substitutionNodeA !== null) {
+        const substitutionNode = substitutionNodeA, ///
+              termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionNode(substitutionNode),
+              substitution = termForVariableSubstitution, ///
+              statementNodeA = statementNode, ///
+              statementNodeMatches = matchStatementNode(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
+
+        metavariableNodeVerified = statementNodeMatches;  ///
+      } else {
+        const statementNode = statementNodeB, ///
+              statementNodeMatches = substitution.matchStatementNode(statementNode, substitutions, localContextA, localContextB);
+
+        metavariableNodeVerified = statementNodeMatches;  ///
+      }
     } else {
-      const metavariableNode = metavariableNodeA, ///
+      const substitutionNode = substitutionNodeA, ///
+            metavariableNode = metavariableNodeA, ///
             statementNode = statementNodeB, ///
-            statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode),
-            substitution = statementForMetavariableSubstitution;  ///
+            substitution = substitutionFromSubstitutionNodeMetavariableNodeAndStatementNode(substitutionNode, metavariableNode, statementNode);
 
       substitutions.push(substitution);
 
@@ -142,7 +142,8 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
     const metavariableNodeA = metavariableNodeQuery(metastatementNodeA);
 
     if (metavariableNodeA !== null) {
-      const metavariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, statementNodeB, substitutions, fileContextA, localContextB, verifyAhead);
+      const substitutionNodeA = null, ///
+            metavariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, substitutionNodeA, statementNodeB, substitutions, fileContextA, localContextB, verifyAhead);
 
       statementNodeVerified = metavariableNodeVerified;  ///
     } else {
@@ -194,3 +195,20 @@ Object.assign(MetaLevelToIntrinsicLevelNodesVerifier.prototype, intrinsicLevelNo
 const metaLevelToIntrinsicLevelNodesVerifier = new MetaLevelToIntrinsicLevelNodesVerifier();
 
 export default metaLevelToIntrinsicLevelNodesVerifier;
+
+function substitutionFromSubstitutionNodeMetavariableNodeAndStatementNode(substitutionNode, metavariableNode, statementNode) {
+  let statementForMetavariableSubstitution;
+
+  if (substitutionNode !== null) {
+    const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionNode(substitutionNode),
+          substitution = termForVariableSubstitution; ///
+
+    statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNodeStatementNodeAndSubstitution(metavariableNode, statementNode, substitution);
+  } else {
+    statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode);
+  }
+
+  const substitution = statementForMetavariableSubstitution;  ///
+
+  return substitution;
+}

package/src/verify/defining.js

@@ -1,32 +1,67 @@
 "use strict";
 
-import { second } from "../utilities/array";
+import verifyTerm from "./term";
+
 import { DEFINED } from "../constants";
 import { nodeQuery } from "../utilities/query";
+import { first, second } from "../utilities/array";
 
-const definedVariableNodeQuery = nodeQuery("/argument/term/variable!");
+const termNodeQuery = nodeQuery("/argument/term!"),
+      variableNodeQuery = nodeQuery("/argument/term/variable!");
 
 export default function verifyDefining(argumentNode, definingNode, context) {
   let definingVerified = false;
 
-  const definedVariableNode = definedVariableNodeQuery(argumentNode);
+  const defined = definedFromDefiningNode(definingNode),
+        termNode = termNodeQuery(argumentNode),
+        variableNode = variableNodeQuery(argumentNode);
+
+  if (false) {
+    ///
+  } else if (variableNode !== null) {
+    const variable = context.findVariableByVariableNode(variableNode);
 
-  if (definedVariableNode !== null) {
-    const defined = definedFromDefiningNode(definingNode),
-          variableNode = definedVariableNode, ///
-          variableDefined = context.isVariableDefined(variableNode);
+    if (variable !== null) {
+      const variableDefined = context.isVariableDefined(variable);
 
-    if (defined) {
-      if (variableDefined) {
-        definingVerified = true;
+      if (defined) {
+        if (variableDefined) {
+          definingVerified = true;
+        }
       }
-    }
 
-    if (!defined) {
-      if (!variableDefined) {
-        definingVerified = true;
+      if (!defined) {
+        if (!variableDefined) {
+          definingVerified = true;
+        }
       }
     }
+  } else if (termNode !== null) {
+    const terms = [],
+          termVerified = verifyTerm(termNode, terms, context, () => {
+            let verifiedAhead;
+
+            const firstTerm = first(terms),
+                  term = firstTerm, ///
+                  termGrounded = context.isTermGrounded(term);
+
+            if (defined) {
+              if (termGrounded) {
+                verifiedAhead = true;
+              }
+            }
+
+            if (!defined) {
+              if (!termGrounded) {
+                verifiedAhead = true;
+              }
+            }
+
+            return verifiedAhead;
+          });
+
+    definingVerified = termVerified;  ///
+
   }
 
   return definingVerified;