occam-verify-cli 0.0.1111 → 0.0.1114

package/src/{term.js → dom/term.js}

@@ -2,16 +2,15 @@
 
 import { arrayUtilities } from "necessary";
 
-import shim from "./shim";
-import unifyMixins from "./mixins/term/unify";
-import verifyMixins from "./mixins/term/verify";
-import constructorVerifier from "./verifier/constructor";
+import dom from "../dom";
+import verifyMixins from "../mixins/term/verify";
+import constructorVerifier from "../verifier/constructor";
 
 import { objectType } from "./type";
-import { nodeQuery, nodesQuery } from "./utilities/query"
-import { termNodeFromTermString } from "./nodeAndTokens/term";
-import { variableNameFromVariableNode } from "./utilities/name";
-import { typeFromJSON, typeToTypeJSON } from "./utilities/json";
+import { domAssigned } from "../dom";
+import { nodeQuery, nodesQuery } from "../utilities/query"
+import { termNodeFromTermString } from "../nodeAndTokens/term";
+import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 
 const { filter, compress } = arrayUtilities;
 
@@ -19,7 +18,7 @@ const termNodeQuery = nodeQuery("/*/term[0]"),
       variableNodeQuery = nodeQuery("/term/variable!"),
       variableNodesQuery = nodesQuery("//variable");
 
-class Term {
+export default domAssigned(class Term {
   constructor(string, node, type) {
     this.string = string;
     this.node = node;
@@ -43,7 +42,7 @@ class Term {
   }
 
   getVariable(context) {
-    const { Variable } = shim,
+    const { Variable } = dom,
           termNode = this.node, ///
           variable = Variable.fromTermNode(termNode, context);
 
@@ -53,7 +52,7 @@ class Term {
   getVariables(context) {
     const variableNodes = variableNodesQuery(this.node),
           variables = variableNodes.map((variableNode) => {
-            const { Variable } = shim,
+            const { Variable } = dom,
                   variable = Variable.fromVariableNode(variableNode, context);
 
             return variable;
@@ -79,15 +78,13 @@ class Term {
   isEqualTo(term) {
     let equalTo = false;
 
-    if (term !== null) {
-      const termString = term.getString();
+    const termString = term.getString();
 
-      if (termString === this.string) {
-        const termType = term.getType();
+    if (termString === this.string) {
+      const termType = term.getType();
 
-        if (termType === this.type) {
-          equalTo = true;
-        }
+      if (termType === this.type) {
+        equalTo = true;
       }
     }
 
@@ -128,34 +125,20 @@ class Term {
   }
 
   verify(context, verifyAhead) {
-    let verified = false;
+    let verified;
 
     const term = this, ///
           termString = this.string;  ///
 
     context.trace(`Verifying the '${termString}' term...`);
 
-    if (!verified) {
-      verified = verifyMixins.some((verifyMixin) => {
-        const verified = verifyMixin(term, context, verifyAhead);
+    verified = verifyMixins.some((verifyMixin) => {
+      const verified = verifyMixin(term, context, verifyAhead);
 
-        if (verified) {
-          return true;
-        }
-      });
-    }
-
-    if (!verified) {
-      const unified = unifyMixins.some((unifyMixin) => { ///
-        const unified = unifyMixin(term, context, verifyAhead);
-
-        if (unified) {
-          return true;
-        }
-      });
-
-      verified = unified; ///
-    }
+      if (verified) {
+        return true;
+      }
+    });
 
     if (verified) {
       context.debug(`...verified the '${termString}' term.`);
@@ -257,6 +240,8 @@ class Term {
     return json;
   }
 
+  static name = "Term";
+
   static fromJSON(json, fileContext) {
     const { string } = json,
           context = fileContext,  ///
@@ -330,10 +315,4 @@ class Term {
 
     return term;
   }
-}
-
-Object.assign(shim, {
-  Term
 });
-
-export default Term;

package/src/{theorem.js → dom/theorem.js}

@@ -1,9 +1,10 @@
 "use strict";
 
-import shim from "./shim";
 import TopLevelAssertion from "./topLevelAssertion";
 
-class Theorem extends TopLevelAssertion {
+import { domAssigned } from "../dom";
+
+export default domAssigned(class Theorem extends TopLevelAssertion {
   verify() {
     let verified;
 
@@ -25,13 +26,9 @@ class Theorem extends TopLevelAssertion {
     return verified;
   }
 
+  static name = "Theorem";
+
   static fromJSON(json, fileContext) { return TopLevelAssertion.fromJSON(Theorem, json, fileContext); }
 
   static fromTheoremNode(metaLemmaNode, fileContext) { return TopLevelAssertion.fromNode(Theorem, metaLemmaNode, fileContext); }
-}
-
-Object.assign(shim, {
-  Theorem
 });
-
-export default Theorem;

package/src/{topLevelAssertion.js → dom/topLevelAssertion.js}

@@ -2,11 +2,12 @@
 
 import { arrayUtilities } from "necessary";
 
-import shim from "./shim";
-import LocalContext from "./context/local";
+import dom from "../dom";
+import LocalContext from "../context/local";
+import Substitutions from "../substitutions";
 
-import { EMPTY_STRING } from "./constants";
-import { nodeQuery, nodesQuery } from "./utilities/query";
+import { EMPTY_STRING } from "../constants";
+import { nodeQuery, nodesQuery } from "../utilities/query";
 import { labelsFromJSON,
          labelsToLabelsJSON,
          consequentFromJSON,
@@ -14,9 +15,9 @@ import { labelsFromJSON,
          substitutionsFromJSON,
          consequentToConsequentJSON,
          suppositionsToSuppositionsJSON,
-         substitutionsToSubstitutionsJSON } from "./utilities/json";
+         substitutionsToSubstitutionsJSON } from "../utilities/json";
 
-const { extract, reverse, backwardsEvery } = arrayUtilities;
+const { reverse, extract, backwardsEvery } = arrayUtilities;
 
 const proofNodeQuery = nodeQuery("/*/proof"),
       labelNodesQuery = nodesQuery("/*/label"),
@@ -85,8 +86,7 @@ export default class TopLevelAssertion {
 
     context.trace(`Unifying the '${referenceString}' reference with the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture...`);
 
-    const { Substitutions } = shim,
-          substitutions = Substitutions.fromNothing(),
+    const substitutions = Substitutions.fromNothing(),
           fileContext = this.getFileContext(),
           localContext = LocalContext.fromFileContext(fileContext),
           generalContext = localContext,  ///
@@ -123,8 +123,7 @@ export default class TopLevelAssertion {
           suppositionsLength = suppositions.length;
 
     if (suppositionsLength === 0) {
-      const { Substitutions } = shim,
-            substitutions = Substitutions.fromNothing(),
+      const substitutions = Substitutions.fromNothing(),
             localContext = LocalContext.fromFileContext(this.fileContext),
             generalContext = localContext,  ///
             specificContext = context,  ///
@@ -147,8 +146,7 @@ export default class TopLevelAssertion {
           generalContext = localContext, ///
           specificContext = context; ///
 
-    const { Substitutions } = shim,
-          substitutions = Substitutions.fromNothing(),
+    const substitutions = Substitutions.fromNothing(),
           statementUnifiedWithConsequent = this.unifyStatementWithConsequent(statement, substitutions, generalContext, specificContext);
 
     if (statementUnifiedWithConsequent) {
@@ -291,7 +289,7 @@ export default class TopLevelAssertion {
   }
 
   static fromNode(Class, node, fileContext) {
-    const { Label, Proof, Consequent, Supposition, Substitutions } = shim,
+    const { Label, Proof, Consequent, Supposition } = dom,
           proofNode = proofNodeQuery(node),
           labelNodes = labelNodesQuery(node),
           consequentNode = consequentNodeQuery(node),
@@ -322,7 +320,7 @@ export function stringFromLabels(labels) {
 
     string = (string === EMPTY_STRING) ?
                labelString: ///
-                 `${labelString}, ${labelString}`;
+                 `${string}, ${labelString}`;
 
     return string;
   }, EMPTY_STRING);

package/src/{type.js → dom/type.js}

@@ -1,11 +1,10 @@
 "use strict";
 
-import shim from "./shim";
-
-import { nodeQuery } from "./utilities/query";
-import { OBJECT_TYPE_NAME } from "./typeNames";
-import { typeNameFromTypeNode } from "./utilities/name";
-import { superTypeFromJSON, superTypeToSuperTypeJSON } from "./utilities/json";
+import { nodeQuery } from "../utilities/query";
+import { domAssigned } from "../dom";
+import { OBJECT_TYPE_NAME } from "../typeNames";
+import { typeNameFromTypeNode } from "../utilities/name";
+import { superTypeFromJSON, superTypeToSuperTypeJSON } from "../utilities/json";
 
 const typeDeclarationTypeNodeQuery = nodeQuery("/typeDeclaration/type[0]"),
       typeDeclarationSuperTypeNodeQuery = nodeQuery("/typeDeclaration/type[1]"),
@@ -149,6 +148,8 @@ class Type {
     return json;
   }
 
+  static name = "Type";
+
   static fromJSON(json, fileContext) {
     const { name } = json,
           typeName = name,  ///
@@ -206,6 +207,8 @@ class Type {
   }
 }
 
+export default domAssigned(Type);
+
 function stringFromTypeNameAndSuperType(typeName, superType) {
   let string = typeName;  ///
 
@@ -219,12 +222,6 @@ function stringFromTypeNameAndSuperType(typeName, superType) {
   return string;
 }
 
-Object.assign(shim, {
-  Type
-});
-
-export default Type;
-
 class ObjectType extends Type {
   toJSON() {
     const superType = null,

package/src/{variable.js → dom/variable.js}

@@ -1,20 +1,21 @@
 "use strict";
 
-import shim from "./shim";
-import LocalContext from "./context/local";
-import TermSubstitution from "./substitution/term";
+import dom from "../dom";
+import LocalContext from "../context/local";
+import TermSubstitution from "../substitution/term";
 
-import { nodeQuery } from "./utilities/query";
+import { nodeQuery } from "../utilities/query";
 import { objectType } from "./type";
-import { variableNameFromVariableNode} from "./utilities/name";
-import { typeFromJSON, typeToTypeJSON } from "./utilities/json";
-import { variableNodeFromVariableString } from "./nodeAndTokens/variable";
+import { domAssigned } from "../dom";
+import { variableNameFromVariableNode} from "../utilities/name";
+import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
+import { variableNodeFromVariableString } from "../nodeAndTokens/variable";
 
 const termVariableNodeQuery = nodeQuery("/term/variable!"),
       variableDeclarationTypeNodeQuery = nodeQuery("/variableDeclaration/type"),
       variableDeclarationVariableNodeQuery = nodeQuery("/variableDeclaration/variable");
 
-class Variable {
+export default domAssigned(class Variable {
   constructor(string, node, name, type) {
     this.string = string;
     this.node = node;
@@ -49,19 +50,14 @@ class Variable {
   }
 
   isEqualTo(variable) {
-    let equalTo = false;
-
-    if (variable !== null) {
-      const variableString = variable.getString();
-
-      equalTo = (variableString === this.string);
-    }
+    const variableString = variable.getString(),
+          equalTo = (variableString === this.string);
 
     return equalTo;
   }
 
-  isEssentiallyEqualToTerm(term, generalContext, specificContext) {
-    let essentiallyEqualToTerm = false;
+  isEffectivelyEqualToTerm(term, generalContext, specificContext) {
+    let effectivelyEqualToTerm = false;
 
     const generalContextFilePath = generalContext.getFilePath(),
           specificContextFilePath = specificContext.getFilePath();
@@ -70,11 +66,11 @@ class Variable {
       const termString = term.getString();
 
       if (termString === this.string) {
-        essentiallyEqualToTerm = true;
+        effectivelyEqualToTerm = true;
       }
     }
 
-    return essentiallyEqualToTerm;
+    return effectivelyEqualToTerm;
   }
 
   verify(context) {
@@ -174,9 +170,9 @@ class Variable {
 
     specificContext.trace(`Unifying the '${termString}' term with the '${variableString}' variable...`);
 
-    const essentiallyEqualToTerm = this.isEssentiallyEqualToTerm(term, generalContext, specificContext);
+    const effectivelyEqualToTerm = this.isEffectivelyEqualToTerm(term, generalContext, specificContext);
 
-    if (essentiallyEqualToTerm) {
+    if (effectivelyEqualToTerm) {
       termUnified = true;
     } else {
       const variable = this, ///
@@ -225,6 +221,8 @@ class Variable {
     return json;
   }
 
+  static name = "Variable";
+
   static fromJSON(json, fileContext) {
     const { string } = json,
           localContext = LocalContext.fromFileContext(fileContext),
@@ -291,7 +289,7 @@ class Variable {
   }
 
   static fromVariableDeclarationNode(variableDeclarationNode, fileContext) {
-    const { Type } = shim,
+    const { Type } = dom,
           variableDeclarationTypeNode = variableDeclarationTypeNodeQuery(variableDeclarationNode),
           variableDeclarationVariableNode = variableDeclarationVariableNodeQuery(variableDeclarationNode),
           typeNode = variableDeclarationTypeNode, ///
@@ -307,10 +305,4 @@ class Variable {
 
     return variable;
   }
-}
-
-Object.assign(shim, {
-  Variable
 });
-
-export default Variable;

package/src/dom.js

@@ -0,0 +1,13 @@
+"use strict";
+
+const dom = {};
+
+export function domAssigned(Class) {
+  const { name } = Class;
+
+  dom[name] = Class;
+
+  return Class;
+}
+
+export default dom;

package/src/equivalences.js

@@ -0,0 +1,278 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import Equivalence from "./equivalence";
+
+const { push, compress, separate } = arrayUtilities;
+
+export default class Equivalences {
+  constructor(array) {
+    this.array = array;
+  }
+
+  getArray() {
+    return this.array;
+  }
+
+  getLength() { return this.array.length; }
+
+  getTypes() {
+    const types = this.array.map((equivalence) => {
+      const type = equivalence.getType();
+
+      return type;
+    });
+
+    return types;
+  }
+
+  pushEquivalences(equivalences) {
+    const array = equivalences.getArray();
+
+    push(this.array, array);
+  }
+
+  forEachEquivalence(callback) { this.array.forEach(callback); }
+
+  separateEquivalences(equivalencesA, equivalencesB, callback) {
+    const arrayA = equivalencesA.getArray(),
+          arrayB = equivalencesB.getArray();
+
+    separate(this.array, arrayA, arrayB, callback);
+  }
+
+  addEquivalence(equivalence, context) {
+    const equivalenceString = equivalence.getString();
+
+    context.trace(`Added the '${equivalenceString}' equivalence.`);
+
+    this.array.push(equivalence);
+  }
+
+  removeEquivalence(equivalence, context) {
+    const index = this.array.indexOf(equivalence),
+          start = index,  ///
+          deleteCount = 1,
+          equivalenceString = equivalence.getString();
+
+    context.trace(`Removed the '${equivalenceString}' equivalence.`);
+
+    this.array.splice(start, deleteCount);
+  }
+
+  findEquivalenceByType(type) {
+    const equivalence = this.array.find((equivalence) => {
+      const equivalenceMatchesType = equivalence.matchType(type);
+
+      if (equivalenceMatchesType) {
+        return true;
+      }
+    }) || null;
+
+    return equivalence;
+  }
+
+  findEquivalenceByTerm(equivalences, term) {
+    const equivalence = this.array.find((equivalence) => {
+      const termEquates = equivalence.equateTerm(term);
+
+      if (termEquates) {
+        return true;
+      }
+    }) || null;
+
+    return equivalence;
+  }
+
+  findEquivalenceByTermNodes(equivalences, termNodes) {
+    const equivalence = this.array.find((equivalence) => {
+      const equivalenceMatchesTerms = equivalence.matchTermNodes(termNodes);
+
+      if (equivalenceMatchesTerms) {
+        return true;
+      }
+    }) || null;
+
+    return equivalence;
+  }
+
+  separateInitiallyGroundedEquivalences(remainingEquivalences, initiallyGroundedEquivalences, context) {
+    this.separateEquivalences(remainingEquivalences, initiallyGroundedEquivalences, (equivalence) => {
+      const equivalenceInitiallyGrounded = equivalence.isInitiallyGrounded(context);
+
+      if (!equivalenceInitiallyGrounded) {
+        return true;
+      }
+    });
+  }
+
+  separateImplicitlyGroundedEquivalences(remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, context) {
+    this.separateEquivalences(remainingEquivalences, implicitlyGroundedEquivalences, (equivalence) => {
+      const equivalenceImplicitlyGrounded = equivalence.isImplicitlyGrounded(definedVariables, context);
+
+      if (!equivalenceImplicitlyGrounded) {
+        return true;
+      }
+    });
+  }
+
+  separateGroundedTermsAndDefinedVariables(groundedTerms, definedVariables, context) {
+    let equivalences = this,
+        groundedEquivalences,
+        remainingEquivalences,
+        initiallyGroundedEquivalences,
+        implicitlyGroundedEquivalences;
+
+    remainingEquivalences =Equivalences.fromNothing();
+
+    initiallyGroundedEquivalences = Equivalences.fromNothing();
+
+    equivalences.separateInitiallyGroundedEquivalences(remainingEquivalences, initiallyGroundedEquivalences, context);
+
+    const initiallyGroundedEquivalencesLength = initiallyGroundedEquivalences.getLength();
+
+    if (initiallyGroundedEquivalencesLength > 0) {
+      groundedEquivalences = initiallyGroundedEquivalences; ///
+
+      let implicitlyGroundedEquivalencesLength = 1;
+
+      while (implicitlyGroundedEquivalencesLength > 0) {
+        let definedVariablesLength = 0,
+            previousDefinedVariablesLength = -1;
+
+        while (definedVariablesLength > previousDefinedVariablesLength) {
+          previousDefinedVariablesLength = definedVariablesLength;  ///
+
+          groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, context);
+
+          definedVariablesFromGroundedTerms(groundedTerms, definedVariables, context);
+
+          definedVariablesLength = definedVariables.length;
+        }
+
+        equivalences = remainingEquivalences; ///
+
+        remainingEquivalences = [];
+
+        implicitlyGroundedEquivalences = [];
+
+        equivalences.separateImplicitlyGroundedEquivalences(remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, context);
+
+        groundedEquivalences.pushEquivalences(implicitlyGroundedEquivalences);
+
+        implicitlyGroundedEquivalencesLength = implicitlyGroundedEquivalences.getLength();  ///
+      }
+    }
+  }
+
+  unifySubstitutions(substitutions) {
+    const substitutionsUnified = substitutions.everySubstitution((substitution) => {
+      const substitutionUnified = this.unifySubstitution(substitution);
+
+      if (substitutionUnified) {
+        return true;
+      }
+    });
+
+    return substitutionsUnified;
+  }
+
+  unifySubstitution(substitution) {
+    const substitutionUnified = this.array.some((equivalence) => {
+      const substitutionUnifiedWithEquivalence = substitution.unifyWithEquivalence(equivalence);
+
+      if (substitutionUnifiedWithEquivalence) {
+        return true;
+      }
+    });
+
+    return substitutionUnified;
+  }
+
+  mergedWith(equivalences) {
+    const equivalencesA = this, ///
+          equivalencesB = equivalences;
+
+    equivalences = mergeEquivalences(equivalencesA, equivalencesB); ///
+
+    return equivalences;
+  }
+
+  static fromArray(array) {
+    const equivalences = new Equivalences(array);
+
+    return equivalences;
+  }
+
+  static fromNothing() {
+    const array = [],
+          equivalences = new Equivalences(array);
+
+    return equivalences;
+  }
+}
+
+function mergeEquivalences(equivalencesA, equivalencesB) {
+  const typesA = equivalencesA.getTypes(),
+        typesB = equivalencesB.getTypes(),
+        types = [
+          ...typesA,
+          ...typesB
+        ];
+
+  compress(types, (typeA, typeB) => {
+    if (typeA === typeB) {
+      return true;
+    }
+  });
+
+  const array = types.map((type) => {
+    let equivalence;
+
+    const equivalenceA = equivalencesA.findEquivalenceByType(type), ///
+          equivalenceB = equivalencesB.findEquivalenceByType(type); ///
+
+    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;
+  });
+
+  const equivalences = Equivalences.fromArray(array);
+
+  return equivalences;
+}
+
+function definedVariablesFromGroundedTerms(groundedTerms, definedVariables, context) {
+  const terms = groundedTerms,  ///
+        variables = definedVariables; ///
+
+  terms.forEach((term) => {
+    const termVariables = term.getVariables(context);
+
+    termVariables.forEach((termVariable) => {
+      const variablesIncludesTermVariable = variables.includes(termVariable);
+
+      if (!variablesIncludesTermVariable) {
+        const variable = termVariable;  ///
+
+        variables.push(variable);
+      }
+    });
+  });
+}
+
+function groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, context) {
+  groundedEquivalences.forEachEquivalence((groundedEquivalence) => {
+    groundedEquivalence.getGroundedTerms(definedVariables, groundedTerms, context);
+  });
+}