occam-verify-cli 0.0.843 → 0.0.844

package/src/equivalence.js

@@ -107,35 +107,47 @@ export default class Equivalence {
     return termNodesMatch;
   }
 
-  getVariables(context) {
-    const variables = [];
-
+  getGroundedTerms(definedVariables, groundedTerms, context) {
     this.terms.forEach((term) => {
-      term.getVariables(variables, context);
-    });
+      const termGrounded = term.isGrounded(definedVariables, context);
+
+      if (termGrounded) {
+        const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
+          const termMatchesGroundedTerm = term.match(groundedTerm);
+
+          if (termMatchesGroundedTerm) {
+            return true;
+          }
+        })
 
-    return variables;
+        if (!termMatchesGroundedTerm) {
+          const groundedTerm = term;
+
+          groundedTerms.push(groundedTerm);
+        }
+      }
+    });
   }
 
-  isInitiallyGrounded() {
-    const initiallyGroundedTerms = this.getInitiallyGroundedTerms(),
+  isInitiallyGrounded(context) {
+    const initiallyGroundedTerms = this.getInitiallyGroundedTerms(context),
           initiallyGroundedTermsLength = initiallyGroundedTerms.length,
           initiallyGrounded = (initiallyGroundedTermsLength > 0);
 
     return initiallyGrounded;
   }
 
-  isImplicitlyGrounded(definedVariables) {
-    const implicitlyGroundedTerms = this.getImplicitlyGroundedTerms(definedVariables),
+  isImplicitlyGrounded(definedVariables, context) {
+    const implicitlyGroundedTerms = this.getImplicitlyGroundedTerms(definedVariables, context),
           implicitlyGroundedTermsLength = implicitlyGroundedTerms.length,
           implicitlyGrounded = (implicitlyGroundedTermsLength > 0);
 
     return implicitlyGrounded;
   }
 
-  getInitiallyGroundedTerms() {
+  getInitiallyGroundedTerms(context) {
     const initiallyGroundedTerms = this.terms.reduce((initiallyGroundedTerms, term) => {
-      const termInitiallyGrounded = term.isInitiallyGrounded();
+      const termInitiallyGrounded = term.isInitiallyGrounded(context);
 
       if (termInitiallyGrounded) {
         const initiallyGroundedTerm = term; ///
@@ -149,9 +161,9 @@ export default class Equivalence {
     return initiallyGroundedTerms;
   }
 
-  getImplicitlyGroundedTerms(definedVariables) {
+  getImplicitlyGroundedTerms(definedVariables, context) {
     const implicitlyGroundedTerms = this.terms.reduce((implicitlyGroundedTerms, term) => {
-      const termImplicitlyGrounded = term.isImplicitlyGrounded(definedVariables);
+      const termImplicitlyGrounded = term.isImplicitlyGrounded(definedVariables, context);
 
       if (termImplicitlyGrounded) {
         const implicitlyGroundedTerm = term; ///

package/src/term.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import { filter } from "./utilities/array";
 import { nodesQuery } from "./utilities/query"
 
 const variableNodesQuery = nodesQuery("//variable");
@@ -25,8 +26,9 @@ export default class Term {
     return matches;
   }
 
-  getVariables(variables, context) {
-    const variableNodes = variableNodesQuery(this.node);
+  getVariables(context) {
+    const variables = [],
+          variableNodes = variableNodesQuery(this.node);
 
     variableNodes.forEach((variableNode) => {
       const variable = context.findVariableByVariableNode(variableNode),
@@ -40,31 +42,35 @@ export default class Term {
     return variables;
   }
 
-  isInitiallyGrounded() {
-    const definedVariables = [],
-          implicitlyGrounded = this.isImplicitlyGrounded(definedVariables),
-          initiallyGrounded = implicitlyGrounded; ///
+  isGrounded(definedVariables, context) {
+    const variables = this.getVariables(context);
+
+    filter(variables, (variable) => {
+      const definedVariablesIncludesVariable = definedVariables.includes(variable);
+
+      if (!definedVariablesIncludesVariable) {
+        return true;
+      }
+    });
+
+    const undefinedVariables = variables, ///
+          undefinedVariablesLength = undefinedVariables.length,
+          grounded = (undefinedVariablesLength <= 1);
+
+    return grounded;
+  }
+
+  isInitiallyGrounded(context) {
+    const variables = this.getVariables(context),
+          variablesLength = variables.length,
+          initiallyGrounded = (variablesLength === 0);
 
     return initiallyGrounded;
   }
 
-  isImplicitlyGrounded(definedVariables) {
-    const variableNodes = variableNodesQuery(this.node),
-          variables = definedVariables, ///
-          nodes = variableNodes,  ///
-          implicitlyGrounded = nodes.every((node) => {
-            const variableMatchesNode = variables.some((variable) => {
-              const variableMatchesNode = variable.matchNode(node);
-
-              if (variableMatchesNode) {
-                return true;
-              }
-            });
-
-            if (variableMatchesNode) {
-              return true;
-            }
-          });
+  isImplicitlyGrounded(definedVariables, context) {
+    const grounded = this.isGrounded(definedVariables, context),
+          implicitlyGrounded = grounded;  ///
 
     return implicitlyGrounded;
   }

package/src/utilities/array.js

@@ -29,6 +29,12 @@ export function someSubArray(array, subArrayLength, callback) {
       permutations = permutationsMatrix[indexesLength][permutationLength];
     }
 
+    if (subArrayLength === 4) {
+      permutations = [
+        [ 0, 2, 3, 4 ]
+      ];
+    }
+
     if (permutations !== null) {
       found = permutations.some((permutation) => {
         if (permutation !== null) {

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/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;