occam-verify-cli 1.0.220 → 1.0.224

package/src/dom/derivation.js

@@ -26,16 +26,16 @@ export default domAssigned(class Derivation {
   }
 
   verify(substitutions, context) {
-    let verified;
+    let verifies;
 
-    verified = this.stepsOrSubproofs.every((stepOrSubproof) => { ///
+    verifies = this.stepsOrSubproofs.every((stepOrSubproof) => { ///
       const assignments = [],
-            stepOrSubproofVerified = stepOrSubproof.verify(substitutions, assignments, context);
+            stepOrSubproofVerifies = stepOrSubproof.verify(substitutions, assignments, context);
 
-      if (stepOrSubproofVerified) {
-        const stepOrSubproofUnified = stepOrSubproof.unify(substitutions, context);
+      if (stepOrSubproofVerifies) {
+        const stepOrSubproofUnifies = stepOrSubproof.unify(substitutions, context);
 
-        if (stepOrSubproofUnified) {
+        if (stepOrSubproofUnifies) {
           const assignmentsAssigned = assignAssignments(assignments, context);
 
           if (assignmentsAssigned) {
@@ -47,7 +47,7 @@ export default domAssigned(class Derivation {
       }
     });
 
-    return verified;
+    return verifies;
   }
 
   static name = "Derivation";

package/src/dom/equality.js

@@ -1,11 +1,11 @@
 "use strict";
 
 import dom from "../dom";
+import equationalUnifier from "../unifier/equantional";
 import EqualityAssignment from "../assignment/equality";
 import VariableAssignment from "../assignment/variable";
 
 import { domAssigned } from "../dom";
-import { unifyEquality } from "../utilities/unification";
 
 export default domAssigned(class Equality {
   constructor(string, leftTerm, rightTerm) {
@@ -45,6 +45,15 @@ export default domAssigned(class Equality {
     return type;
   }
 
+  getTerms() {
+    const terms = [
+      this.leftTerm,
+      this.rightTerm
+    ];
+
+    return terms;
+  }
+
   isReflexive() {
     const leftTermString = this.leftTerm.getString(),
           rightTermString = this.rightTerm.getString(),
@@ -54,114 +63,122 @@ export default domAssigned(class Equality {
   }
 
   isEqual(context) {
-    const equality = this,  ///
-          equalityUnified = unifyEquality(equality, context),
-          equal = equalityUnified;  ///
+    let equal = false;
+
+    const leftTermNode = this.leftTerm.getNode(),
+          rightTermNode = this.rightTerm.getNode(),
+          termsEquates = equationalUnifier.equateTerms(leftTermNode, rightTermNode, context);
+
+    if (termsEquates) {
+      equal = true;
+    }
 
     return equal;
   }
 
   verify(assignments, stated, context) {
-    let verified = false;
+    let verifies = false;
 
     const equalityString = this.string; ///
 
     context.trace(`Verifying the '${equalityString}' equality...`);
 
-    const termsVerified = this.verifyTerms(context);
+    const termsVerify = this.verifyTerms(context);
 
-    if (termsVerified) {
-      let verifiedWhenStated = false,
-          verifiedWhenDerived = false;
+    if (termsVerify) {
+      let verifiesWhenStated = false,
+          verifiesWhenDerived = false;
 
       if (stated) {
-        verifiedWhenStated = this.verifyWhenStated(assignments, context);
+        verifiesWhenStated = this.verifyWhenStated(assignments, context);
       } else {
-        verifiedWhenDerived = this.verifyWhenDerived(context);
+        verifiesWhenDerived = this.verifyWhenDerived(context);
       }
 
-      verified = verifiedWhenStated || verifiedWhenDerived;
+      if (verifiesWhenStated || verifiesWhenDerived) {
+        verifies = true;
+      }
     }
 
-    if (verified) {
-      this.assign(assignments, context);
+    if (verifies) {
+
+        this.assign(assignments, context);
+
     }
 
-    if (verified) {
+    if (verifies) {
       context.debug(`...verified the '${equalityString}' equality.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   verifyTerms(context) {
-    let termsVerified;
+    let termsVerify;
 
     const equalityString = this.string; ///
 
     context.trace(`Verifying the '${equalityString}' equality's terms...`);
 
-    const leftTermVerified = this.leftTerm.verify(context, () => {
-      let verifiedAhead;
+    const leftTermVerifies = this.leftTerm.verify(context, () => {
+      let verifiesAhead;
 
-      const rightTermVerified = this.rightTerm.verify(context, () => {
-        let verifiedAhead;
+      const rightTermVerifies = this.rightTerm.verify(context, () => {
+        let verifiesAhead;
 
         const leftTermType = this.leftTerm.getType(),
               rightTermType = this.rightTerm.getType(),
               leftTermTypeComparableToRightTermType = leftTermType.isComparableTo(rightTermType);
 
-        verifiedAhead = leftTermTypeComparableToRightTermType;  ///
+        verifiesAhead = leftTermTypeComparableToRightTermType;  ///
 
-        return verifiedAhead;
+        return verifiesAhead;
       });
 
-      verifiedAhead = rightTermVerified; ///
+      verifiesAhead = rightTermVerifies; ///
 
-      return verifiedAhead;
+      return verifiesAhead;
     });
 
-    termsVerified = leftTermVerified; ///
+    termsVerify = leftTermVerifies; ///
 
-    if (termsVerified) {
+    if (termsVerify) {
       context.debug(`...verified the '${equalityString}' equality's terms.`);
     }
 
-    return termsVerified;
+    return termsVerify;
   }
 
   verifyWhenStated(assignments, context) {
-    let verifiedWhenStated;
+    let verifiesWhenStated;
 
     const equalityString = this.string; ///
 
     context.trace(`Verifying the '${equalityString}' stated equality...`);
 
-    verifiedWhenStated = true;
+    verifiesWhenStated = true;
 
-    if (verifiedWhenStated) {
+    if (verifiesWhenStated) {
       context.debug(`...verified the '${equalityString}' stated equality.`);
     }
 
-    return verifiedWhenStated;
+    return verifiesWhenStated;
   }
 
   verifyWhenDerived(context) {
-    let verifiedWhenDerived;
+    let verifiesWhenDerived;
 
     const equalityString = this.string; ///
 
     context.trace(`Verifying the '${equalityString}' derived equality...`);
 
-    const equal = this.isEqual(context);
-
-    verifiedWhenDerived = equal;  ///
+    verifiesWhenDerived = true;  ///
 
-    if (verifiedWhenDerived) {
+    if (verifiesWhenDerived) {
       context.debug(`...verified the '${equalityString}' derived equality.`);
     }
 
-    return verifiedWhenDerived;
+    return verifiesWhenDerived;
   }
 
   assign(assignments, context) {

package/src/dom/error.js

@@ -17,13 +17,13 @@ export default domAssigned(class Error {
   }
 
   verify() {
-    let verified = false;
+    let verifies = false;
 
     const errorString = this.string;  ///
 
     this.fileContext.warning(`The '${errorString}' error cannot be verified.`);
 
-    return verified;
+    return verifies;
   }
 
   static name = "Error";

package/src/dom/frame.js

@@ -127,42 +127,42 @@ export default domAssigned(class Frame {
   }
 
   verify(assignments, stated, context) {
-    let verified = false;
+    let verifies = false;
 
     const frameString = this.string;  ///
 
     context.trace(`Verifying the '${frameString}' frame...`);
 
-    const declarationsVerified = this.verifyDeclarations(assignments, stated, context);
+    const declarationsVerify = this.verifyDeclarations(assignments, stated, context);
 
-    if (declarationsVerified) {
-      const  metavariablesVerified = this.verifyMetavariables(assignments, stated, context);
+    if (declarationsVerify) {
+      const  metavariablesVerify = this.verifyMetavariables(assignments, stated, context);
 
-      if (metavariablesVerified) {
-        let verifiedWhenStated = false,
-            verifiedWhenDerived = false;
+      if (metavariablesVerify) {
+        let verifiesWhenStated = false,
+            verifiesWhenDerived = false;
 
         if (stated) {
-          verifiedWhenStated = this.verifyWhenStated(assignments, context);
+          verifiesWhenStated = this.verifyWhenStated(assignments, context);
         } else {
-          verifiedWhenDerived = this.verifyWhenDerived(context);
+          verifiesWhenDerived = this.verifyWhenDerived(context);
         }
 
-        if (verifiedWhenStated || verifiedWhenDerived) {
-          verified = true;
+        if (verifiesWhenStated || verifiesWhenDerived) {
+          verifies = true;
         }
       }
     }
 
-    if (verified) {
+    if (verifies) {
       context.debug(`...verified the '${frameString}' frame.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   verifyWhenStated(assignments, context) {
-    let verifiedWhenStated = false;
+    let verifiesWhenStated = false;
 
     const frameString = this.string;  ///
 
@@ -178,35 +178,35 @@ export default domAssigned(class Frame {
       if (metavariablesLength > 1) {
         context.trace(`The '${frameString}' stated frame cannot have more than one metavariable.`);
       } else {
-        verifiedWhenStated = true;
+        verifiesWhenStated = true;
       }
     }
 
-    if (verifiedWhenStated) {
+    if (verifiesWhenStated) {
       context.debug(`...verified the '${frameString}' stated frame.`);
     }
 
-    return verifiedWhenStated;
+    return verifiesWhenStated;
   }
 
   verifyWhenDerived(context) {
-    let verifiedWhenDerived;
+    let verifiesWhenDerived;
 
     const frameString = this.string;  ///
 
     context.trace(`Verifying the '${frameString}' derived frame...`);
 
-    verifiedWhenDerived = true;
+    verifiesWhenDerived = true;
 
-    if (verifiedWhenDerived) {
+    if (verifiesWhenDerived) {
       context.debug(`...verified the '${frameString}' derived frame.`);
     }
 
-    return verifiedWhenDerived;
+    return verifiesWhenDerived;
   }
 
   verifyDeclarations(assignments, stated, context) {
-    let declarationsVerified = true;  ///
+    let declarationsVerify = true;  ///
 
     const declarationsLength = this.declarations.length;
 
@@ -222,22 +222,22 @@ export default domAssigned(class Frame {
 
       assignments = null; ///
 
-      declarationsVerified = this.declarations.every((declaration) => {
-        const declarationVerified = declaration.verify(assignments, stated, context);
+      declarationsVerify = this.declarations.every((declaration) => {
+        const declarationVerifies = declaration.verify(assignments, stated, context);
 
-        return declarationVerified;
+        return declarationVerifies;
       });
 
-      if (declarationsVerified) {
+      if (declarationsVerify) {
         context.debug(`...verified the '${declarationsString}' declaration${sOrNothing}.`);
       }
     }
 
-    return declarationsVerified;
+    return declarationsVerify;
   }
 
   verifyMetavariables(assignments, stated, context) {
-    let metavariablesVerified = true;
+    let metavariablesVerify = true;
 
     const metavariablesLength = this.metavariables.length;
 
@@ -249,22 +249,22 @@ export default domAssigned(class Frame {
 
       context.trace(`Verifying the '${metavariablesString}' metavariable${sOrNothing}...`);
 
-      metavariablesVerified = this.metavariables.every((metavariable) => {
-        const metavariableVerified = metavariable.verify(context);
+      metavariablesVerify = this.metavariables.every((metavariable) => {
+        const metavariableVerifies = metavariable.verify(context);
 
-        return metavariableVerified;
+        return metavariableVerifies;
       });
 
-      if (metavariablesVerified) {
+      if (metavariablesVerify) {
         context.debug(`...verified the '${metavariablesString}' metavariable${sOrNothing}.`);
       }
     }
 
-    return metavariablesVerified;
+    return metavariablesVerify;
   }
 
   verifyGivenMetaType(metaType, assignments, stated, context) {
-    let verifiedGivenMetaType = false;
+    let verifiesGivenMetaType = false;
 
     const frameString = this.string,  ///
           metaTypeString = metaType.getString();
@@ -274,16 +274,16 @@ export default domAssigned(class Frame {
     const metaTypeName = metaType.getName();
 
     if (metaTypeName === FRAME_META_TYPE_NAME) {
-      const verified = this.verify(assignments, stated, context)
+      const verifies = this.verify(assignments, stated, context)
 
-      verifiedGivenMetaType = verified; ///
+      verifiesGivenMetaType = verifies; ///
     }
 
-    if (verifiedGivenMetaType) {
+    if (verifiesGivenMetaType) {
       context.debug(`...verified the '${frameString}' frame given the '${metaTypeString}' meta-type.`);
     }
 
-    return verifiedGivenMetaType;
+    return verifiesGivenMetaType;
   }
 
   static name = "Frame";

package/src/dom/judgement.js

@@ -29,94 +29,96 @@ export default domAssigned(class Judgement {
   getMetavariable() { return this.frame.getMetavariable(); }
 
   verify(assignments, stated, context) {
-    let verified = false;
+    let verifies = false;
 
     const judgementString = this.string;  ///
 
     context.trace(`Verifying the '${judgementString}' judgement...`);
 
-    const frameVerified = this.verifyFrame(assignments, stated, context);
+    const frameVerifies = this.verifyFrame(assignments, stated, context);
 
-    if (frameVerified) {
-      const declarationVerified = this.verifyDeclaration(assignments, stated, context);
+    if (frameVerifies) {
+      const declarationVerifies = this.verifyDeclaration(assignments, stated, context);
 
-      if (declarationVerified) {
-        let verifiedWhenStated = false,
-            verifiedWhenDerived = false;
+      if (declarationVerifies) {
+        let verifiesWhenStated = false,
+            verifiesWhenDerived = false;
 
         if (stated) {
-          verifiedWhenStated = this.verifyWhenStated(assignments, context);
+          verifiesWhenStated = this.verifyWhenStated(assignments, context);
         } else {
-          verifiedWhenDerived = this.verifyWhenDerived(context);
+          verifiesWhenDerived = this.verifyWhenDerived(context);
         }
 
-        verified = verifiedWhenStated || verifiedWhenDerived;
+        if (verifiesWhenStated || verifiesWhenDerived) {
+          verifies = true;
+        }
       }
     }
 
-    if (verified) {
+    if (verifies) {
       if (stated) {
         this.assign(assignments, context);
       }
     }
 
-    if (verified) {
+    if (verifies) {
       context.debug(`...verified the '${judgementString}' judgement.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   verifyFrame(assignments, stated, context) {
-    let frameVerified;
+    let frameVerifies;
 
     const frameString = this.frame.getString();
 
     context.trace(`Verifying the '${frameString}' frame...`);
 
-    frameVerified = this.frame.verify(assignments, stated, context);
+    frameVerifies = this.frame.verify(assignments, stated, context);
 
-    if (frameVerified) {
+    if (frameVerifies) {
       context.debug(`...verified the '${frameString}' frame.`);
     }
 
-    return frameVerified;
+    return frameVerifies;
   }
 
   verifyDeclaration(assignments, stated, context) {
-    let declarationVerified;
+    let declarationVerifies;
 
     const declarationString = this.declaration.getString();
 
     context.trace(`Verifying the '${declarationString}' declaration...`);
 
-    declarationVerified = this.declaration.verify(assignments, stated, context);
+    declarationVerifies = this.declaration.verify(assignments, stated, context);
 
-    if (declarationVerified) {
+    if (declarationVerifies) {
       context.debug(`...verified the '${declarationString}' declaration.`);
     }
 
-    return declarationVerified;
+    return declarationVerifies;
   }
 
   verifyWhenStated(assignments, context) {
-    let verifiedWhenStated;
+    let verifiesWhenStated;
 
     const judgementString = this.string;  ///
 
     context.trace(`Verifying the '${judgementString}' stated judgement...`);
 
-    verifiedWhenStated = true;
+    verifiesWhenStated = true;
 
-    if (verifiedWhenStated) {
+    if (verifiesWhenStated) {
       context.debug(`...verified the '${judgementString}' stated judgement.`);
     }
 
-    return verifiedWhenStated;
+    return verifiesWhenStated;
   }
 
   verifyWhenDerived(context) {
-    let verifiedWhenDerived;
+    let verifiesWhenDerived;
 
     const judgementString = this.string;  ///
 
@@ -127,13 +129,13 @@ export default domAssigned(class Judgement {
           substitutions = metaLemmaMetatheorem.getSubstitutions(),
           substitutionsMatch = this.frame.matchSubstitutions(substitutions, context);
 
-    verifiedWhenDerived = substitutionsMatch;
+    verifiesWhenDerived = substitutionsMatch;
 
-    if (verifiedWhenDerived) {
+    if (verifiesWhenDerived) {
       context.debug(`...verified the '${judgementString}' derived judgement.`);
     }
 
-    return verifiedWhenDerived;
+    return verifiesWhenDerived;
   }
 
   assign(assignments, context) {

package/src/dom/label.js

@@ -52,7 +52,7 @@ export default domAssigned(class Label {
   matchMetavariableName(metavariableName) { return this.metavariable.matchMetavariableName(metavariableName); }
 
   verify(nameOnly) {
-    let verified = false;
+    let verifies = false;
 
     const labelString = this.getString(); ///
 
@@ -73,14 +73,14 @@ export default domAssigned(class Label {
     if (labelPresent) {
       this.fileContext.debug(`The '${labelString}' label is already present.`);
     } else {
-      verified = true;
+      verifies = true;
     }
 
-    if (verified) {
+    if (verifies) {
       this.fileContext.debug(`...verified the '${labelString}' label.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   toJSON() {

package/src/dom/lemma.js

@@ -6,7 +6,7 @@ import { domAssigned } from "../dom";
 
 export default domAssigned(class Lemma extends TopLevelAssertion {
   verify() {
-    let verified;
+    let verifies;
 
     const lemma = this, ///
           fileContext = this.getFileContext(),
@@ -16,9 +16,9 @@ export default domAssigned(class Lemma extends TopLevelAssertion {
       fileContext.trace(`Verifying a lemma...`) :
         fileContext.trace(`Verifying the '${lemmaString}' lemma...`);
 
-    verified = super.verify();
+    verifies = super.verify();
 
-    if (verified) {
+    if (verifies) {
       const lemma = this; ///
 
       fileContext.addLemma(lemma);
@@ -28,7 +28,7 @@ export default domAssigned(class Lemma extends TopLevelAssertion {
           fileContext.debug(`...verified the '${lemmaString}' lemma.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   static name = "Lemma";

package/src/dom/metaLemma.js

@@ -6,7 +6,7 @@ import { domAssigned } from "../dom";
 
 export default domAssigned(class MetaLemma extends TopLevelMetaAssertion {
   verify() {
-    let verified;
+    let verifies;
 
     const metaLemma = this, ///
           fileContext = this.getFileContext(),
@@ -14,9 +14,9 @@ export default domAssigned(class MetaLemma extends TopLevelMetaAssertion {
 
     fileContext.trace(`Verifying the '${metaLemmaString}' meta-lemma...`);
 
-    verified = super.verify();
+    verifies = super.verify();
 
-    if (verified) {
+    if (verifies) {
       const metaTheorem = this; ///
 
       fileContext.addMetatheorem(metaTheorem);
@@ -24,7 +24,7 @@ export default domAssigned(class MetaLemma extends TopLevelMetaAssertion {
       fileContext.debug(`...verified the '${metaLemmaString}' meta-lemma.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   static name = "MetaLemma";

package/src/dom/metatheorem.js

@@ -6,7 +6,7 @@ import { domAssigned } from "../dom";
 
 export default domAssigned(class Metatheorem extends TopLevelMetaAssertion {
   verify() {
-    let verified;
+    let verifies;
 
     const metaLemma = this, ///
           fileContext = this.getFileContext(),
@@ -14,9 +14,9 @@ export default domAssigned(class Metatheorem extends TopLevelMetaAssertion {
 
     fileContext.trace(`Verifying the '${metaLemmaString}' metatheorem...`);
 
-    verified = super.verify();
+    verifies = super.verify();
 
-    if (verified) {
+    if (verifies) {
       const metaTheorem = this; ///
 
       fileContext.addMetatheorem(metaTheorem);
@@ -24,7 +24,7 @@ export default domAssigned(class Metatheorem extends TopLevelMetaAssertion {
       fileContext.debug(`...verified the '${metaLemmaString}' metatheorem.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   static name = "Metatheorem";