occam-verify-cli 0.0.836 → 0.0.839

package/src/context/local.js

@@ -1,18 +1,23 @@
 "use strict";
 
 import Variable from "../variable";
-import Collection from "../collection";
+import Equivalence from "../equivalence";
 import contextMixins from "../mixins/context";
 
 import { last } from "../utilities/array";
-import { mergeCollections, findCollectionByTerm } from "../utilities/collection";
+import { mergeEquivalences,
+         separateEquivalences,
+         findEquivalenceByTerm,
+         compressDefinedVariables,
+         definedVariablesFromGroundedEquivalences,
+         implicitlyGroundedEquivalencesFromRemainingEquivalencesAndDefinedVariables } from "../utilities/equivalences";
 
 class LocalContext {
-  constructor(context, variables, proofSteps, collections) {
+  constructor(context, variables, proofSteps, equivalences) {
     this.context = context;
     this.variables = variables;
     this.proofSteps = proofSteps;
-    this.collections = collections;
+    this.equivalences = equivalences;
   }
 
   getContext() {
@@ -23,8 +28,8 @@ class LocalContext {
     let variables = this.context.getVariables();
 
     variables = [ ///
-      ...this.variables,
-      ...variables
+      ...variables,
+      ...this.variables
     ];
 
     return variables;
@@ -34,23 +39,23 @@ class LocalContext {
     let proofSteps = this.context.getProofSteps();
 
     proofSteps = [  ///
-      ...this.proofSteps,
-      ...proofSteps
+      ...proofSteps,
+      ...this.proofSteps
     ];
 
     return proofSteps;
   }
 
-  getCollections() {
-    let collections = this.context.getCollections();
+  getEquivalences() {
+    let equivalences = this.context.getEquivalences();
 
-    const collectionsA = this.collections, ///
-          collectionsB = collections,
+    const equivalencesA = this.equivalences, ///
+          equivalencesB = equivalences,
           localContext = this;  ///
 
-    collections = mergeCollections(collectionsA, collectionsB, localContext); ///
+    equivalences = mergeEquivalences(equivalencesA, equivalencesB, localContext); ///
 
-    return collections;
+    return equivalences;
   }
 
   getLastProofStep() {
@@ -70,14 +75,14 @@ class LocalContext {
   getTermType(term) {
     let termType;
 
-    const collections = this.getCollections(),
-          collection = findCollectionByTerm(collections, term);
+    const equivalences = this.getEquivalences(),
+          equivalence = findEquivalenceByTerm(equivalences, term);
 
-    if (collection !== null) {
+    if (equivalence !== null) {
       const localContext = this,  ///
-            collectionType = collection.getType(localContext);
+            equivalenceType = equivalence.getType(localContext);
 
-      termType = collectionType;  ///
+      termType = equivalenceType;  ///
     } else {
       termType = term.getType();
     }
@@ -85,6 +90,53 @@ class LocalContext {
     return termType;
   }
 
+  isVariableDefined(variable) {
+    let variableDefined = false;
+
+    const equivalences = this.getEquivalences(),
+          remainingEquivalences = [],
+          initiallyGroundedEquivalences = [];
+
+    separateEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences);
+
+    const initiallyGroundedEquivalencesLength = initiallyGroundedEquivalences.length;
+
+    if (initiallyGroundedEquivalencesLength > 0) {
+      let groundedEquivalences,
+          implicitlyGroundedEquivalences,
+          implicitlyGroundedEquivalencesLength;
+
+      const context = this,
+            definedVariables = [];
+
+      groundedEquivalences = initiallyGroundedEquivalences; ///
+
+      definedVariablesFromGroundedEquivalences(groundedEquivalences, definedVariables, context);
+
+      implicitlyGroundedEquivalences = implicitlyGroundedEquivalencesFromRemainingEquivalencesAndDefinedVariables(remainingEquivalences, definedVariables);
+
+      implicitlyGroundedEquivalencesLength = implicitlyGroundedEquivalences.length;
+
+      while (implicitlyGroundedEquivalencesLength > 0) {
+        groundedEquivalences = implicitlyGroundedEquivalences;  ///
+
+        definedVariablesFromGroundedEquivalences(groundedEquivalences, definedVariables, context);
+
+        implicitlyGroundedEquivalences = implicitlyGroundedEquivalencesFromRemainingEquivalencesAndDefinedVariables(remainingEquivalences, definedVariables);
+
+        implicitlyGroundedEquivalencesLength = implicitlyGroundedEquivalences.length;
+      }
+
+      compressDefinedVariables(definedVariables);
+
+      const definedVariablesIncludesVariable = definedVariables.includes(variable);
+
+      variableDefined = definedVariablesIncludesVariable;  ///
+    }
+
+    return variableDefined;
+  }
+
   addEquality(equality) {
     let equalityAdded;
 
@@ -95,36 +147,45 @@ class LocalContext {
     } else {
       const leftTerm = equality.getLeftTerm(),
             rightTerm = equality.getRightTerm(),
-            leftCollection = findCollectionByTerm(this.collections, leftTerm),
-            rightCollection = findCollectionByTerm(this.collections, rightTerm);
+            leftEquivalence = findEquivalenceByTerm(this.equivalences, leftTerm),
+            rightEquivalence = findEquivalenceByTerm(this.equivalences, rightTerm);
 
       if (false) {
         ///
-      } else if ((leftCollection === null) && (rightCollection === null)) {
-        const collection = Collection.fromEquality(equality);
+      } else if ((leftEquivalence === null) && (rightEquivalence === null)) {
+        const equivalence = Equivalence.fromLeftTermAndRightTerm(leftTerm, rightTerm);
 
-        this.addCollection(collection);
+        this.addEquivalence(equivalence);
 
         equalityAdded = true;
-      } else if ((leftCollection !== null) && (rightCollection === null)) {
-        leftCollection.addTerm(rightTerm);
+      } else if ((leftEquivalence !== null) && (rightEquivalence === null)) {
+        leftEquivalence.addTerm(rightTerm);
 
         equalityAdded = true;
-      } else if ((leftCollection === null) && (rightCollection !== null)) {
-        rightCollection.addTerm(leftTerm);
+      } else if ((leftEquivalence === null) && (rightEquivalence !== null)) {
+        rightEquivalence.addTerm(leftTerm);
 
         equalityAdded = true;
-      } else if ((leftCollection !== null) && (rightCollection !== null)) {
-        if (leftCollection === rightCollection) {
-          const collection = leftCollection;  ///
-
-          collection.addTerm(leftTerm);
-          collection.addTerm(rightTerm);
+      } else if ((leftEquivalence !== null) && (rightEquivalence !== null)) {
+        let equivalence;
 
-          equalityAdded = true;
+        if (leftEquivalence === rightEquivalence) {
+          equivalence = leftEquivalence;  ///
         } else {
-          debugger
+          equivalence = Equivalence.merge(leftEquivalence, rightEquivalence);
+
+          this.removeEquivalence(leftEquivalence);
+
+          this.removeEquivalence(rightEquivalence);
+
+          this.addEquivalence(equivalence);
         }
+
+        equivalence.addTerm(leftTerm);
+
+        equivalence.addTerm(rightTerm);
+
+        equalityAdded = true;
       }
     }
 
@@ -156,8 +217,8 @@ class LocalContext {
     this.proofSteps.push(proofStep);
   }
 
-  addCollection(collection) {
-    this.collections.push(collection);
+  addEquivalence(equivalence) {
+    this.equivalences.push(equivalence);
   }
 
   matchStatement(statementNode) {
@@ -182,6 +243,14 @@ class LocalContext {
     return statementMatches;
   }
 
+  removeEquivalence(equivalence) {
+    const index = this.equivalences.indexOf(equivalence),
+          start = index,  ///
+          deleteCount = 1;
+
+    this.equivalences.splice(start, deleteCount);
+  }
+
   findVariableByVariableNode(variableNode) {
     const node = variableNode,  ///
           variables = this.getVariables(),
@@ -222,8 +291,8 @@ class LocalContext {
     const context = fileContext,  ///
           variables = [],
           proofSteps = [],
-          collections = [],
-          localContext = new LocalContext(context, variables, proofSteps, collections);
+          equivalences = [],
+          localContext = new LocalContext(context, variables, proofSteps, equivalences);
 
     return localContext;
   }
@@ -232,9 +301,9 @@ class LocalContext {
     const context = localContext,  ///
           variables = [],
           proofSteps = [],
-          collections = [];
+          equivalences = [];
 
-    localContext = new LocalContext(context, variables, proofSteps, collections);
+    localContext = new LocalContext(context, variables, proofSteps, equivalences);
 
     return localContext;
   }
@@ -253,8 +322,8 @@ class LocalContext {
 
     const context = fileContext,  ///
           proofSteps = [],
-          collections = [],
-          localContext = new LocalContext(context, variables, proofSteps, collections);
+          equivalences = [],
+          localContext = new LocalContext(context, variables, proofSteps, equivalences);
 
     return localContext;
   }

package/src/context/localMeta.js

@@ -25,8 +25,8 @@ class LocalMetaContext {
     let metavariables = this.context.getMetavariables();
 
     metavariables = [ ///
-      ...this.metavariables,
       ...metavariables,
+      ...this.metavariables
     ]
 
     return metavariables;
@@ -36,8 +36,8 @@ class LocalMetaContext {
     let metaproofSteps = this.context.getMetaproofSteps();
 
     metaproofSteps = [  ///
-      ...this.metaproofSteps,
-      ...metaproofSteps
+      ...metaproofSteps,
+      ...this.metaproofSteps
     ];
 
     return metaproofSteps;

package/src/context/release.js

@@ -343,16 +343,16 @@ export default class ReleaseContext {
     releaseContexts = releaseContexts.slice();  ///
 
     const combinedCustomGrammar = combinedCustomGrammarFromReleaseContexts(releaseContexts),
-          releaseContext = releaseContexts.shift(),
-          dependencyReleaseContexts = releaseContexts;  ///
-
-    const florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar),
+          florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar),
           florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);
 
     this.lexer = florenceLexer; ///
 
     this.parser = florenceParser; ///
 
+    const releaseContext = releaseContexts.shift(),
+          dependencyReleaseContexts = releaseContexts;  ///
+
     this.dependencyReleaseContexts = dependencyReleaseContexts;
 
     if (this.json !== null) {
@@ -360,10 +360,7 @@ export default class ReleaseContext {
 
       fileContextsJSON.forEach((fileContextJSON) => {
         const json = fileContextJSON, ///
-              { filePath } = json,
-              fileContext = FileContext.fromFilePathAndReleaseContext(filePath, releaseContext);
-
-        fileContext.initialise(json);
+              fileContext = FileContext.fromJSONAndReleaseContext(json, releaseContext);
 
         this.fileContexts.push(fileContext);
       });
@@ -394,4 +391,4 @@ export default class ReleaseContext {
 
     return releaseContext;
   }
-}
+}

package/src/equality.js

@@ -35,9 +35,9 @@ export default class Equality {
           rightTermNode = rightTerm.getNode(),
           nonTerminalNodeA = leftTermNode,  ///
           nonTerminalNodeB = rightTermNode, ///
-          collections = context.getCollections(),
+          equivalences = context.getEquivalences(),
           localContext = this,  ///
-          nonTerminalNodeVerified = equalityNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, collections, localContext, () => {
+          nonTerminalNodeVerified = equalityNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, equivalences, localContext, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;

package/src/{collection.js → equivalence.js}

@@ -4,7 +4,7 @@ import { nodeQuery } from "./utilities/query";
 
 const variableNodeQuery = nodeQuery("/term/variable!");
 
-export default class Collection {
+export default class Equivalence {
   constructor(terms) {
     this.terms = terms;
   }
@@ -68,6 +68,18 @@ export default class Collection {
     return termMatches;
   }
 
+  matchTerms(terms) {
+    const termsMatch = terms.every((term) => {
+      const termMatches = this.matchTerm(term);
+
+      if (termMatches) {
+        return true;
+      }
+    })
+
+    return termsMatch;
+  }
+
   matchTermNode(termNode) {
     const termNodeA = termNode, ///
           termNodeMatches = this.terms.some((term) => {
@@ -83,18 +95,6 @@ export default class Collection {
     return termNodeMatches;
   }
 
-  matchTerms(terms) {
-    const termsMatch = terms.every((term) => {
-      const termMatches = this.matchTerm(term);
-
-      if (termMatches) {
-        return true;
-      }
-    })
-
-    return termsMatch;
-  }
-
   matchTermNodes(termNodes) {
     const termNodesMatch = termNodes.every((termNode) => {
       const termNodeMatches = this.matchTermNode(termNode);
@@ -107,28 +107,84 @@ export default class Collection {
     return termNodesMatch;
   }
 
-  static fromEquality(equality) {
-    const leftTerm = equality.getLeftTerm(),
-          rightTerm = equality.getRightTerm(),
+  getVariables(context) {
+    const variables = [];
+
+    this.terms.forEach((term) => {
+      term.getVariables(variables, context);
+    });
+
+    return variables;
+  }
+
+  isInitiallyGrounded() {
+    const initiallyGroundedTerms = this.getInitiallyGroundedTerms(),
+          initiallyGroundedTermsLength = initiallyGroundedTerms.length,
+          initiallyGrounded = (initiallyGroundedTermsLength > 0);
+
+    return initiallyGrounded;
+  }
+
+  isImplicitlyGrounded(definedVariables) {
+    const implicitlyGroundedTerms = this.getImplicitlyGroundedTerms(definedVariables),
+          implicitlyGroundedTermsLength = implicitlyGroundedTerms.length,
+          implicitlyGrounded = (implicitlyGroundedTermsLength > 0);
+
+    return implicitlyGrounded;
+  }
+
+  getInitiallyGroundedTerms() {
+    const initiallyGroundedTerms = this.terms.reduce((initiallyGroundedTerms, term) => {
+      const termInitiallyGrounded = term.isInitiallyGrounded();
+
+      if (termInitiallyGrounded) {
+        const initiallyGroundedTerm = term; ///
+
+        initiallyGroundedTerms.push(initiallyGroundedTerm);
+      }
+
+      return initiallyGroundedTerms;
+    }, []);
+
+    return initiallyGroundedTerms;
+  }
+
+  getImplicitlyGroundedTerms(definedVariables) {
+    const implicitlyGroundedTerms = this.terms.reduce((implicitlyGroundedTerms, term) => {
+      const termImplicitlyGrounded = term.isImplicitlyGrounded(definedVariables);
+
+      if (termImplicitlyGrounded) {
+        const implicitlyGroundedTerm = term; ///
+
+        implicitlyGroundedTerms.push(implicitlyGroundedTerm);
+      }
+
+      return implicitlyGroundedTerms;
+    }, []);
+
+    return implicitlyGroundedTerms;
+  }
+
+  static merge(leftEquivalence, rightEquivalence) {
+    const leftEquivalenceTerms = leftEquivalence.getTerms(),
+          rightEquivalenceTerms = rightEquivalence.getTerms(),
           terms = [
-            leftTerm,
-            rightTerm
+            ...leftEquivalenceTerms,
+            ...rightEquivalenceTerms
           ],
-          collection = new Collection(terms);
+          equivalence = new Equivalence(terms);
 
-    return collection;
+    return equivalence;
   }
 
-  static fromCollections(collectionA, collectionB) {
-    const collectionATerms = collectionA.getTerms(),
-          collectionBTerms = collectionB.getTerms(),
-          terms = [
-            ...collectionATerms,
-            ...collectionBTerms
+  static fromLeftTermAndRightTerm(leftTerm, rightTerm) {
+    const terms = [
+            leftTerm,
+            rightTerm
           ],
-          collection = new Collection(terms);
+          equivalence = new Equivalence(terms);
 
-    return collection;
+    return equivalence;
   }
 }
 

package/src/log.js

@@ -106,8 +106,8 @@ export default class Log {
 function formatMessage(level, message, node = null, tokens = null, filePath = null) {
   const upperCaseLevel = level.toUpperCase();
 
-  if (node === null) {
-    message = `${upperCaseLevel}: ${message}`;
+  if ((node === null) || (tokens === null)) {
+    message = `${upperCaseLevel}: ${filePath} - ${message}`;
   } else {
     const leastLineIndex = leastLineIndexFromNodeAndTokens(node, tokens),
           leastLineNumber = leastLineIndex, ///

package/src/term.js

@@ -1,5 +1,9 @@
 "use strict";
 
+import { nodesQuery } from "./utilities/query"
+
+const variableNodesQuery = nodesQuery("//variable");
+
 export default class Term {
   constructor(node, type) {
     this.node = node;
@@ -21,6 +25,50 @@ export default class Term {
     return matches;
   }
 
+  getVariables(variables, context) {
+    const variableNodes = variableNodesQuery(this.node);
+
+    variableNodes.forEach((variableNode) => {
+      const variable = context.findVariableByVariableNode(variableNode),
+            variablesIncludesVariable = variables.includes(variable);
+
+      if (!variablesIncludesVariable) {
+        variables.push(variable);
+      }
+    });
+
+    return variables;
+  }
+
+  isInitiallyGrounded() {
+    const definedVariables = [],
+          implicitlyGrounded = this.isImplicitlyGrounded(definedVariables),
+          initiallyGrounded = implicitlyGrounded; ///
+
+    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;
+            }
+          });
+
+    return implicitlyGrounded;
+  }
+
   static fromTermNodeAndType(termNode, type) {
     const node = termNode,  ///
           term = new Term(node, type);

package/src/utilities/array.js

@@ -6,7 +6,7 @@ import permutationsMatrix from "../permutationsMatrix";
 
 import { MAXIMUM_INDEXES_LENGTH, MAXIMUM_PERMUTATION_LENGTH } from "../constants";
 
-export const { first, second, third, last, push, prune, match, filter, compress } = arrayUtilities;
+export const { first, second, last, push, prune, match, filter, compress, separate } = arrayUtilities;
 
 export function someSubArray(array, subArrayLength, callback) {
   let found = false;