occam-verify-cli 1.0.220 → 1.0.224

package/src/equivalence.js

@@ -1,7 +1,11 @@
 "use strict";
 
+import { arrayUtilities } from "necessary";
+
 import { stripBracketsFromTermNode } from "./utilities/brackets";
 
+const { compress } = arrayUtilities;
+
 export default class Equivalence {
   constructor(terms) {
     this.terms = terms;
@@ -15,9 +19,23 @@ export default class Equivalence {
     const termString = term.getString(),
           equivalenceString = this.asString(); ///
 
-    context.trace(`Adding the '${termString}' term to the '${equivalenceString}' equivalence.`);
+    context.trace(`Adding the '${termString}' term to the '${equivalenceString}' equivalence....`);
 
-    this.terms.push(term);
+    const termA = term, ///
+          termPresent = this.someTerm((term) => {
+            const termB = term, ///
+                  termAEqualToTermB = termA.isEqualTo(termB);
+
+            if (termAEqualToTermB) {
+              return true;
+            }
+          });
+
+    if (!termPresent) {
+      this.terms.push(term);
+
+      context.debug(`...added the '${termString}' term to the '${equivalenceString}' equivalence.`);
+    }
   }
 
   getType() {
@@ -40,19 +58,6 @@ export default class Equivalence {
     return type;
   }
 
-  matchType(type) {
-    const typeA = type; ///
-
-    type = this.getType();
-
-    const typeB = type; ///
-
-    const typeAEqualToTypeB = typeA.isEqualTo(typeB),
-          typeMatches = typeAEqualToTypeB;  ///
-
-    return typeMatches;
-  }
-
   equateTerm(term) {
     const termA = term, ///
           termEquates = this.someTerm((term) => {
@@ -112,8 +117,45 @@ export default class Equivalence {
     return variableNodeMatches;
   }
 
+  isDisjointFrom(equivalence) {
+    const disjointFrom = equivalence.everyTerm((term) => {
+      const termEquates = this.equateTerm(term);
+
+      if (!termEquates) {
+        return true;
+      }
+    });
+
+    return disjointFrom;
+  }
+
+  mergedWith(equivalence) {
+    const equivalenceA = this,
+          equivalenceB = equivalence, ///
+          equivalenceATerms = equivalenceA.getTerms(),
+          equivalenceTermsB = equivalenceB.getTerms(),
+          terms = [
+            ...equivalenceATerms,
+            ...equivalenceTermsB
+          ];
+
+    compress(terms, (termA, termB) => {
+      const termAEqualToTermB = termA.isEqualTo(termB);
+
+      if (termAEqualToTermB) {
+        return true;
+      }
+    });
+
+    equivalence = new Equivalence(terms);
+
+    return equivalence;
+  }
+
   someTerm(callback) { return this.terms.some(callback); }
 
+  everyTerm(callback) { return this.terms.every(callback); }
+
   someOtherTerm(term, callback) {
     const termA = term, ///
           terms = this.terms.filter((term) => {
@@ -201,43 +243,24 @@ export default class Equivalence {
   }
 
   asString() {
-    let string;
-
-    string = this.terms.reduce((string, term) => {
-      const termString = term.getString();
-
-      string = (string === null) ?
-                 termString :
-                    `${string} = ${termString}`;
-
-      return string;
-    }, null);
-
     const type = this.getType(),
-          typeString = type.getString();
-
-    string = `${string}:${typeString}`;
+          typeString = type.getString(),
+          termsString = this.terms.reduce((termsString, term) => {
+            const termString = term.getString();
 
-    return string;
-  }
+            termsString = (termsString === null) ?
+                            termString :
+                             `${termsString} = ${termString}`;
 
-  static merge(leftEquivalence, rightEquivalence) {
-    const leftEquivalenceTerms = leftEquivalence.getTerms(),
-          rightEquivalenceTerms = rightEquivalence.getTerms(),
-          terms = [
-            ...leftEquivalenceTerms,
-            ...rightEquivalenceTerms
-          ],
-          equivalence = new Equivalence(terms);
+            return termsString;
+          }, null),
+          string = `${termsString}:${typeString}`;
 
-    return equivalence;
+    return string;
   }
 
-  static fromLeftTermAndRightTerm(leftTerm, rightTerm) {
-    const terms = [
-            leftTerm,
-            rightTerm
-          ],
+  static fromEquality(equality) {
+    const terms = equality.getTerms(),
           equivalence = new Equivalence(terms);
 
     return equivalence;

package/src/equivalences.js

@@ -2,9 +2,7 @@
 
 import { arrayUtilities } from "necessary";
 
-import Equivalence from "./equivalence";
-
-const { push, compress, separate } = arrayUtilities;
+const { push, separate } = arrayUtilities;
 
 export default class Equivalences {
   constructor(array) {
@@ -27,51 +25,21 @@ export default class Equivalences {
     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.asString();
-
-    context.trace(`Added the '${equivalenceString}' equivalence.`);
-
+  addEquivalence(equivalence) {
     this.array.push(equivalence);
   }
 
-  removeEquivalence(equivalence, context) {
-    const index = this.array.indexOf(equivalence),
-          start = index,  ///
-          deleteCount = 1,
-          equivalenceString = equivalence.asString();
-
-    context.trace(`Removed the '${equivalenceString}' equivalence.`);
+  addEquivalences(equivalences) {
+    const array = equivalences.getArray();
 
-    this.array.splice(start, deleteCount);
+    push(this.array, array);
   }
 
-  findEquivalenceByType(type) {
-    const equivalence = this.array.find((equivalence) => {
-      const equivalenceMatchesType = equivalence.matchType(type);
+  someEquivalence(callback) { return this.array.some(callback); }
 
-      if (equivalenceMatchesType) {
-        return true;
-      }
-    }) || null;
+  everyEquivalence(callback) { return this.array.every(callback); }
 
-    return equivalence;
-  }
+  forEachEquivalence(callback) { this.array.forEach(callback); }
 
   findEquivalenceByTerm(term) {
     const equivalence = this.array.find((equivalence) => {
@@ -97,6 +65,45 @@ export default class Equivalences {
     return equivalence;
   }
 
+  mergedWith(equivalences) {
+    let  mergedEquivalences = this.clone(); ///
+
+    equivalences.forEachEquivalence((equivalence) => {
+      mergedEquivalences = mergedEquivalences.mergedWithEquivalence(equivalence);
+    });
+
+    return mergedEquivalences;
+  }
+
+  mergedWithEquivalence(equivalence) {
+    const equivalences = Equivalences.fromNothing();
+
+    let mergedEquivalence = equivalence; ///
+
+    this.forEachEquivalence((equivalence) => {
+      const mergedEquivalenceDisjointFromEquivalence = mergedEquivalence.isDisjointFrom(equivalence);
+
+      if (mergedEquivalenceDisjointFromEquivalence) {
+        equivalences.addEquivalence(equivalence);
+      } else {
+        mergedEquivalence = mergedEquivalence.mergedWith(equivalence);
+      }
+    });
+
+    equivalence = mergedEquivalence;  ///
+
+    equivalences.addEquivalence(equivalence);
+
+    return equivalences;
+  }
+
+  separateEquivalences(equivalencesA, equivalencesB, callback) {
+    const equivalencesAArray = equivalencesA.getArray(),
+          equivalencesBArray = equivalencesB.getArray();
+
+    separate(this.array, equivalencesAArray, equivalencesBArray, callback);
+  }
+
   separateInitiallyGroundedEquivalences(remainingEquivalences, initiallyGroundedEquivalences, context) {
     this.separateEquivalences(remainingEquivalences, initiallyGroundedEquivalences, (equivalence) => {
       const equivalenceInitiallyGrounded = equivalence.isInitiallyGrounded(context);
@@ -159,48 +166,18 @@ export default class Equivalences {
 
         equivalences.separateImplicitlyGroundedEquivalences(remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, context);
 
-        groundedEquivalences.pushEquivalences(implicitlyGroundedEquivalences);
+        groundedEquivalences.addEquivalences(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);
+  clone() {
+    const array = [
+            ...this.array
+          ],
+          equivalences = new Equivalences(array);
 
     return equivalences;
   }
@@ -213,45 +190,6 @@ export default class 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; ///

package/src/index.js

@@ -36,7 +36,6 @@ import Metavariable from "./dom/metavariable";
 import ProcedureCall from "./dom/procedureCall";
 import SubDerivation from "./dom/subDerivation";
 import TypeAssertion from "./dom/assertion/type";
-import TypeDeclaration from "./dom/declaration/type";
 import DefinedAssertion from "./dom/assertion/defined";
 import PropertyRelation from "./dom/propertyRelation";
 import TermSubstitution from "./dom/substitution/term";
@@ -48,6 +47,7 @@ import SatisfiesAssertion from "./dom/assertion/satisfies";
 import VariableDeclaration from "./dom/declaration/variable";
 import BracketedCombinator from "./dom/combinator/bracketed";
 import BracketedConstructor from "./dom/constructor/bracketed";
+import SimpleTypeDeclaration from "./dom/declaration/simpleType";
 import ReferenceSubstitution from "./dom/substitution/reference";
 import StatementSubstitution from "./dom/substitution/statement";
 import CombinatorDeclaration from "./dom/declaration/combinator";

package/src/mixins/statement/verify.js

@@ -19,9 +19,9 @@ function unifyWithBracketedCombinator(statement, assignments, stated, context) {
 
   const { BracketedCombinator } = dom,
         bracketedCombinator = BracketedCombinator.fromNothing(),
-        unifiedWithBracketedCombinator = bracketedCombinator.unifyStatement(statement, assignments, stated, context);
+        unifiesWithBracketedCombinator = bracketedCombinator.unifyStatement(statement, assignments, stated, context);
 
-  return unifiedWithBracketedCombinator;
+  return unifiesWithBracketedCombinator;
 }
 
 function unifyWithCombinators(statement, assignments, stated, context) {
@@ -30,19 +30,19 @@ function unifyWithCombinators(statement, assignments, stated, context) {
   assignments = null; ///
 
   const combinators = context.getCombinators(),
-        unifiedWithCombinators = combinators.some((combinator) => {
-          const unifiedWithCombinator = combinator.unifyStatement(statement, assignments, stated, context);
+        unifiesWithCombinators = combinators.some((combinator) => {
+          const unifiesWithCombinator = combinator.unifyStatement(statement, assignments, stated, context);
 
-          if (unifiedWithCombinator) {
+          if (unifiesWithCombinator) {
             return true;
           }
         });
 
-  return unifiedWithCombinators;
+  return unifiesWithCombinators;
 }
 
 function verifyAsMetavariable(statement, assignments, stated, context) {
-  let verifiedAsMetavariable = false;
+  let verifiesAsMetavariable = false;
 
   const metavariable = metavariableFromStatement(statement, context);
 
@@ -51,20 +51,20 @@ function verifyAsMetavariable(statement, assignments, stated, context) {
 
     context.trace(`Verifying the '${statementString}' statement as a metavariable...`);
 
-    const metavariableVerified = metavariable.verify(context);
+    const metavariableVerifies = metavariable.verify(context);
 
-    verifiedAsMetavariable = metavariableVerified; ///
+    verifiesAsMetavariable = metavariableVerifies; ///
 
-    if (verifiedAsMetavariable) {
+    if (verifiesAsMetavariable) {
       context.debug(`...verified the '${statementString}' statement as a metavariable.`);
     }
   }
 
-  return verifiedAsMetavariable;
+  return verifiesAsMetavariable;
 }
 
 function verifyAsEquality(statement, assignments, stated, context) {
-  let verifiedAsEquality = false;
+  let verifiesAsEquality = false;
 
   const equality = equalityFromStatement(statement, context);
 
@@ -73,20 +73,20 @@ function verifyAsEquality(statement, assignments, stated, context) {
 
     context.trace(`Verifying the '${statementString}' statement as an equality...`);
 
-    const equalityVerified = equality.verify(assignments, stated, context);
+    const equalityVerifies = equality.verify(assignments, stated, context);
 
-    verifiedAsEquality = equalityVerified; ///
+    verifiesAsEquality = equalityVerifies; ///
 
-    if (verifiedAsEquality) {
+    if (verifiesAsEquality) {
       context.debug(`...verified the '${statementString}' statement as an equality.`);
     }
   }
 
-  return verifiedAsEquality;
+  return verifiesAsEquality;
 }
 
 function verifyAsJudgement(statement, assignments, stated, context) {
-  let verifiedAsJudgement = false;
+  let verifiesAsJudgement = false;
 
   const judgement = judgementFromStatement(statement, context);
 
@@ -95,20 +95,20 @@ function verifyAsJudgement(statement, assignments, stated, context) {
 
     context.trace(`Verifying the '${statementString}' statement as a judgement...`);
 
-    const judgementVerified = judgement.verify(assignments, stated, context);
+    const judgementVerifies = judgement.verify(assignments, stated, context);
 
-    verifiedAsJudgement = judgementVerified;  ///
+    verifiesAsJudgement = judgementVerifies;  ///
 
-    if (verifiedAsJudgement) {
+    if (verifiesAsJudgement) {
       context.debug(`...verified the '${statementString}' statement as a judgement.`);
     }
   }
 
-  return verifiedAsJudgement;
+  return verifiesAsJudgement;
 }
 
 function verifyAsTypeAssertion(statement, assignments, stated, context) {
-  let verifiedAsTypeAssertion = false;
+  let verifiesAsTypeAssertion = false;
 
   const typeAssertion = typeAssertionFromStatement(statement, context);
 
@@ -117,20 +117,20 @@ function verifyAsTypeAssertion(statement, assignments, stated, context) {
 
     context.trace(`Verifying the '${statementString}' statement as a type assertion...`);
 
-    const typeAssertionVerified = typeAssertion.verify(assignments, stated, context);
+    const typeAssertionVerifies = typeAssertion.verify(assignments, stated, context);
 
-    verifiedAsTypeAssertion = typeAssertionVerified; ///
+    verifiesAsTypeAssertion = typeAssertionVerifies; ///
 
-    if (verifiedAsTypeAssertion) {
+    if (verifiesAsTypeAssertion) {
       context.debug(`...verified the '${statementString}' statement as a type assertion.`);
     }
   }
 
-  return verifiedAsTypeAssertion;
+  return verifiesAsTypeAssertion;
 }
 
 function verifyAsDefinedAssertion(statement, assignments, stated, context) {
-  let verifiedAsDefinedAssertion = false;
+  let verifiesAsDefinedAssertion = false;
 
   const definedAssertion = definedAssertionFromStatement(statement, context);
 
@@ -139,20 +139,20 @@ function verifyAsDefinedAssertion(statement, assignments, stated, context) {
 
     context.trace(`Verifying the '${statementString}' statement as a defined assertion...`);
 
-    const definedAssertionVerified = definedAssertion.verify(assignments, stated, context);
+    const definedAssertionVerifies = definedAssertion.verify(assignments, stated, context);
 
-    verifiedAsDefinedAssertion = definedAssertionVerified; ///
+    verifiesAsDefinedAssertion = definedAssertionVerifies; ///
 
-    if (verifiedAsDefinedAssertion) {
+    if (verifiesAsDefinedAssertion) {
       context.debug(`...verified the '${statementString}' statement as a defined assertion.`);
     }
   }
 
-  return verifiedAsDefinedAssertion;
+  return verifiesAsDefinedAssertion;
 }
 
 function verifyAsPropertyAssertion(statement, assignments, stated, context) {
-  let verifiedAsPropertyAssertion = false;
+  let verifiesAsPropertyAssertion = false;
 
   const propertyAssertion = propertyAssertionFromStatement(statement, context);
 
@@ -161,20 +161,20 @@ function verifyAsPropertyAssertion(statement, assignments, stated, context) {
 
     context.trace(`Verifying the '${statementString}' statement as a property assertion...`);
 
-    const propertyAssertionVerified = propertyAssertion.verify(assignments, stated, context);
+    const propertyAssertionVerifies = propertyAssertion.verify(assignments, stated, context);
 
-    verifiedAsPropertyAssertion = propertyAssertionVerified; ///
+    verifiesAsPropertyAssertion = propertyAssertionVerifies; ///
 
-    if (verifiedAsPropertyAssertion) {
+    if (verifiesAsPropertyAssertion) {
       context.debug(`...verified the '${statementString}' statement as a property assertion.`);
     }
   }
 
-  return verifiedAsPropertyAssertion;
+  return verifiesAsPropertyAssertion;
 }
 
 function verifyAsSubproofAssertion(statement, assignments, stated, context) {
-  let verifiedAsSubproofAssertion = false;
+  let verifiesAsSubproofAssertion = false;
 
   const subproofAssertion = subproofAssertionFromStatement(statement, context);
 
@@ -183,20 +183,20 @@ function verifyAsSubproofAssertion(statement, assignments, stated, context) {
 
     context.trace(`Verifying the '${statementString}' statement as a subproof assertion...`);
 
-    const subproofAssertionVerified = subproofAssertion.verify(assignments, stated, context);
+    const subproofAssertionVerifies = subproofAssertion.verify(assignments, stated, context);
 
-    verifiedAsSubproofAssertion = subproofAssertionVerified; ///
+    verifiesAsSubproofAssertion = subproofAssertionVerifies; ///
 
-    if (verifiedAsSubproofAssertion) {
+    if (verifiesAsSubproofAssertion) {
       context.debug(`...verified the '${statementString}' statement as a subproof assertion.`);
     }
   }
 
-  return verifiedAsSubproofAssertion;
+  return verifiesAsSubproofAssertion;
 }
 
 function verifyAsContainedAssertion(statement, assignments, stated, context) {
-  let verifiedAsContainedAssertion = false;
+  let verifiesAsContainedAssertion = false;
 
   const containedAssertion = containedAssertionFromStatement(statement, context);
 
@@ -205,20 +205,20 @@ function verifyAsContainedAssertion(statement, assignments, stated, context) {
 
     context.trace(`Verifying the '${statementString}' statement as a contained assertion...`);
 
-    const containedAssertionVerified = containedAssertion.verify(assignments, stated, context);
+    const containedAssertionVerifies = containedAssertion.verify(assignments, stated, context);
 
-    verifiedAsContainedAssertion = containedAssertionVerified; ///
+    verifiesAsContainedAssertion = containedAssertionVerifies; ///
 
-    if (verifiedAsContainedAssertion) {
+    if (verifiesAsContainedAssertion) {
       context.debug(`...verified the '${statementString}' statement as a contained assertion.`);
     }
   }
 
-  return verifiedAsContainedAssertion;
+  return verifiesAsContainedAssertion;
 }
 
 function verifyAsSatisfiesAssertion(statement, assignments, stated, context) {
-  let verifiedAsSatisfiesAssertion = false;
+  let verifiesAsSatisfiesAssertion = false;
 
   const satisfiesAssertion = satisfiesAssertionFromStatement(statement, context);
 
@@ -227,16 +227,16 @@ function verifyAsSatisfiesAssertion(statement, assignments, stated, context) {
 
     context.trace(`Verifying the '${statementString}' statement as a satisfies assertion...`);
 
-    const satisfiesAssertionVerified = satisfiesAssertion.verify(assignments, stated, context);
+    const satisfiesAssertionVerifies = satisfiesAssertion.verify(assignments, stated, context);
 
-    verifiedAsSatisfiesAssertion = satisfiesAssertionVerified; ///
+    verifiesAsSatisfiesAssertion = satisfiesAssertionVerifies; ///
 
-    if (verifiedAsSatisfiesAssertion) {
+    if (verifiesAsSatisfiesAssertion) {
       context.debug(`...verified the '${statementString}' statement as a satisfies assertion.`);
     }
   }
 
-  return verifiedAsSatisfiesAssertion;
+  return verifiesAsSatisfiesAssertion;
 }
 
 const verifyMixins = [