occam-verify-cli 1.0.448 → 1.0.472

package/src/element/assertion/defined.js

@@ -27,45 +27,46 @@ export default define(class DefinedAssertion extends Assertion {
     return this.negated;
   }
 
-  verify(assignments, stated, context) {
-    let verifies = false;
+  validate(assignments, stated, context) {
+    let validated = false;
 
     const definedAssertionString = this.getString(); ///
 
-    context.trace(`Verifying the '${definedAssertionString}' defined assertion...`);
+    context.trace(`Validating the '${definedAssertionString}' defined assertion...`);
 
     const termValidates = this.validateTerm(assignments, stated, context),
-          frameVerifies = this.verifyFrame(assignments, stated, context);
+          frameVerifies = this.validateFrame(assignments, stated, context);
 
     if (termValidates || frameVerifies) {
       let verifiesWhenStated = false,
           verifiesWhenDerived = false;
 
       if (stated) {
-        verifiesWhenStated = this.verifyWhenStated(assignments, context);
+        verifiesWhenStated = this.validateWhenStated(assignments, context);
       } else {
-        verifiesWhenDerived = this.verifyWhenDerived(context);
+        verifiesWhenDerived = this.validateWhenDerived(context);
       }
 
       if (verifiesWhenStated || verifiesWhenDerived) {
-        verifies = true;
+        validated = true;
       }
     }
 
-    if (verifies) {
-      context.debug(`...verified the '${definedAssertionString}' defined assertion.`);
+    if (validated) {
+      context.debug(`...validated the '${definedAssertionString}' defined assertion.`);
     }
 
-    return verifies;
+    return validated;
   }
 
   validateTerm(assignments, stated, context) {
     let termValidates = false;
 
     if (this.term !== null) {
-      const termString = this.term.getString(); ///
+      const termString = this.term.getString(), ///
+            definedAssertionString = this.getString();  ///
 
-      context.trace(`Validating the '${termString}' term...`);
+      context.trace(`Validating the '${definedAssertionString}' defined assertino's '${termString}' term...`);
 
       const termSingular = this.term.isSingular();
 
@@ -79,7 +80,7 @@ export default define(class DefinedAssertion extends Assertion {
         });
 
         if (termValidates) {
-          context.debug(`...validated the '${termString}' term.`);
+          context.debug(`...validated the'${definedAssertionString}' defined assertino's '${termString}' term.`);
         }
       }
     }
@@ -87,13 +88,14 @@ export default define(class DefinedAssertion extends Assertion {
     return termValidates;
   }
 
-  verifyFrame(assignments, stated, context) {
+  validateFrame(assignments, stated, context) {
     let frameVerifies = false;
 
     if (this.frame !== null) {
-      const frameString = this.frame.getString(); ///
+      const frameString = this.frame.getString(), ///
+            definedAssertionString = this.getString();  ///
 
-      context.trace(`Verifying the '${frameString}' frame...`);
+      context.trace(`Validating the'${definedAssertionString}' defined assertino's '${frameString}' frame...`);
 
       const frameSingular = this.frame.isSingular();
 
@@ -104,10 +106,10 @@ export default define(class DefinedAssertion extends Assertion {
 
         assignments = null; ///
 
-        frameVerifies = this.frame.verify(assignments, stated, context);
+        frameVerifies = this.frame.validate(assignments, stated, context);
 
         if (frameVerifies) {
-          context.debug(`...verified the '${frameString}' frame.`);
+          context.debug(`...validated the'${definedAssertionString}' defined assertino's '${frameString}' frame.`);
         }
       }
     }
@@ -115,36 +117,36 @@ export default define(class DefinedAssertion extends Assertion {
     return frameVerifies;
   }
 
-  verifyWhenStated(assignments, context) {
+  validateWhenStated(assignments, context) {
     let verifiesWhenStated;
 
     const definedAssertionString = this.getString(); ///
 
-    context.trace(`Verifying the '${definedAssertionString}' stated defined assertion...`);
+    context.trace(`Validating the '${definedAssertionString}' stated defined assertion...`);
 
     verifiesWhenStated = true;
 
     if (verifiesWhenStated) {
-      context.debug(`...verified the '${definedAssertionString}' stated defined assertion.`);
+      context.debug(`...validated the '${definedAssertionString}' stated defined assertion.`);
     }
 
     return verifiesWhenStated;
   }
 
-  verifyWhenDerived(context) {
+  validateWhenDerived(context) {
     let verifiesWhenDerived;
 
     const definedAssertionString = this.getString(); ///
 
-    context.trace(`Verifying the '${definedAssertionString}' derived defined assertion...`);
+    context.trace(`Validating the '${definedAssertionString}' derived defined assertion...`);
 
     const generalContext = null,
           specificContext = context;  ///
 
-    verifiesWhenDerived = verifyWhenDerived(this.term, this.frame, this.negated, generalContext, specificContext);
+    verifiesWhenDerived = validateWhenDerived(this.term, this.frame, this.negated, generalContext, specificContext);
 
     if (verifiesWhenDerived) {
-      context.debug(`...verified the '${definedAssertionString}' derived defined assertion.`);
+      context.debug(`...validated the '${definedAssertionString}' derived defined assertion.`);
     }
 
     return verifiesWhenDerived;
@@ -160,7 +162,7 @@ export default define(class DefinedAssertion extends Assertion {
 
     const term = termFromTermAndSubstitutions(this.term, substitutions, generalContext, specificContext),
           frame = frameFromFrameAndSubstitutions(this.frame, substitutions, generalContext, specificContext),
-          verifiesWhenDerived = verifyWhenDerived(term, frame, this.negated, generalContext, specificContext);
+          verifiesWhenDerived = validateWhenDerived(term, frame, this.negated, generalContext, specificContext);
 
     unifiesIndependently = verifiesWhenDerived; ///
 
@@ -174,7 +176,7 @@ export default define(class DefinedAssertion extends Assertion {
   static name = "DefinedAssertion";
 });
 
-function verifyWhenDerived(term, frame, negated, generalContext, specificContext) {
+function validateWhenDerived(term, frame, negated, generalContext, specificContext) {
   let verifiesWhenDerived = false;
 
   const context = specificContext;  ///

package/src/element/assertion/property.js

@@ -48,45 +48,45 @@ export default define(class PropertyAssertion extends Assertion {
     return comparesToTermAndPropertyRelation;
   }
 
-  verify(assignments, stated, context) {
-    let verifies = false;
+  validate(assignments, stated, context) {
+    let validates = false;
 
     const propertyAssertionString = this.getString(); ///
 
-    context.trace(`Verifying the '${propertyAssertionString}' property assertion...`);
+    context.trace(`Validating the '${propertyAssertionString}' property assertion...`);
 
     const termValidates = this.validateTerm(assignments, stated, context);
 
     if (termValidates) {
-      const propertyRelationVerifies = this.verifyPropertyRelation(assignments, stated, context);
+      const propertyRelationVerifies = this.validatePropertyRelation(assignments, stated, context);
 
       if (propertyRelationVerifies) {
-        let verifiesWhenStated = false,
-            verifiesWhenDerived = false;
+        let validatesWhenStated = false,
+            validatesWhenDerived = false;
 
         if (stated) {
-          verifiesWhenStated = this.verifyWhenStated(assignments, context);
+          validatesWhenStated = this.validateWhenStated(assignments, context);
         } else {
-          verifiesWhenDerived = this.verifyWhenDerived(context);
+          validatesWhenDerived = this.validateWhenDerived(context);
         }
 
-        if (verifiesWhenStated || verifiesWhenDerived) {
-          verifies = true;
+        if (validatesWhenStated || validatesWhenDerived) {
+          validates = true;
         }
       }
     }
 
-    if (verifies) {
+    if (validates) {
       if (stated) {
         this.assign(assignments, context);
       }
     }
 
-    if (verifies) {
-      context.debug(`...verified the '${propertyAssertionString}' property assertion.`);
+    if (validates) {
+      context.debug(`...validated the '${propertyAssertionString}' property assertion.`);
     }
 
-    return verifies;
+    return validates;
   }
 
   validateTerm(assignments, stated, context) {
@@ -96,10 +96,10 @@ export default define(class PropertyAssertion extends Assertion {
 
     context.trace(`Validating the '${termString}' term...`);
 
-    termValidates = this.term.verify(context, () => {
-      const verifiesAhead = true;
+    termValidates = this.term.validate(context, () => {
+      const validatesAhead = true;
 
-      return verifiesAhead;
+      return validatesAhead;
     });
 
     if (termValidates) {
@@ -109,52 +109,52 @@ export default define(class PropertyAssertion extends Assertion {
     return termValidates;
   }
 
-  verifyPropertyRelation(assignments, stated, context) {
+  validatePropertyRelation(assignments, stated, context) {
     let propertyRelationVerifies;
 
     const propertyRelationString = this.propertyRelation.getString();
 
-    context.trace(`Verifying the '${propertyRelationString}' property relation...`);
+    context.trace(`Validating the '${propertyRelationString}' property relation...`);
 
-    propertyRelationVerifies = this.propertyRelation.verify(context);
+    propertyRelationVerifies = this.propertyRelation.validate(context);
 
     if (propertyRelationVerifies) {
-      context.debug(`...verified the '${propertyRelationString}' property relation.`);
+      context.debug(`...validated the '${propertyRelationString}' property relation.`);
     }
 
     return propertyRelationVerifies;
   }
 
-  verifyWhenStated(assignments, context) {
-    let verifiesWhenStated;
+  validateWhenStated(assignments, context) {
+    let validatesWhenStated;
 
     const propertyAssertionString = this.getString(); ///
 
-    context.trace(`Verifying the '${propertyAssertionString}' stated property assertion...`);
+    context.trace(`Validating the '${propertyAssertionString}' stated property assertion...`);
 
-    verifiesWhenStated = true;
+    validatesWhenStated = true;
 
-    if (verifiesWhenStated) {
-      context.debug(`...verified the '${propertyAssertionString}' stated property assertion.`);
+    if (validatesWhenStated) {
+      context.debug(`...validated the '${propertyAssertionString}' stated property assertion.`);
     }
 
-    return verifiesWhenStated;
+    return validatesWhenStated;
   }
 
-  verifyWhenDerived(context) {
-    let verifiesWhenDerived;
+  validateWhenDerived(context) {
+    let validatesWhenDerived;
 
     const propertyAssertionString = this.getString(); ///
 
-    context.trace(`Verifying the '${propertyAssertionString}' derived property assertion...`);
+    context.trace(`Validating the '${propertyAssertionString}' derived property assertion...`);
 
-    verifiesWhenDerived = true;
+    validatesWhenDerived = true;
 
-    if (verifiesWhenDerived) {
-      context.debug(`...verified the '${propertyAssertionString}' derived property assertion.`);
+    if (validatesWhenDerived) {
+      context.debug(`...validated the '${propertyAssertionString}' derived property assertion.`);
     }
 
-    return verifiesWhenDerived;
+    return validatesWhenDerived;
   }
 
   assign(assignments, context) {

package/src/element/assertion/satisfies.js

@@ -25,40 +25,41 @@ export default define(class SatisfiesAssertion extends Assertion {
 
   correlateSubstitutions(substitutions, context) { return this.signature.correlateSubstitutions(substitutions, context); }
 
-  verify(assignments, stated, context) {
-    let verifies = false;
+  validate(assignments, stated, context) {
+    let validates = false;
 
     const satisfiesAssertionString = this.getString(); ///
 
-    context.trace(`Verifying the '${satisfiesAssertionString}' satisfies assertion...`);
+    context.trace(`Validating the '${satisfiesAssertionString}' satisfies assertion...`);
 
-    const signatureVerifies = this.verifySignature(assignments, stated, context);
+    const signatureVerifies = this.validateSignature(assignments, stated, context);
 
     if (signatureVerifies) {
-      const referenceVerifies = this.verifyReference(assignments, stated, context);
+      const referenceVerifies = this.validateReference(assignments, stated, context);
 
-      verifies = referenceVerifies; ///
+      validates = referenceVerifies; ///
     }
 
-    if (verifies) {
-      context.debug(`...verified the '${satisfiesAssertionString}' satisfies assertion.`);
+    if (validates) {
+      context.debug(`...validated the '${satisfiesAssertionString}' satisfies assertion.`);
     }
 
-    return verifies;
+    return validates;
   }
 
-  verifySignature(assignments, stated, context) {
-    const signatureVerifies = this.signature.verify(context);
+  validateSignature(assignments, stated, context) {
+    const signatureVerifies = this.signature.validate(context);
 
     return signatureVerifies;
   }
 
-  verifyReference(assignments, stated, context) {
+  validateReference(assignments, stated, context) {
     let referenceVerifies = false;
 
-    const referenceString = this.reference.getString();
+    const referenceString = this.reference.getString(),
+          satisfiesAssertionString = this.getString();  ///
 
-    context.trace(`Verifying the '${referenceString}' reference...`);
+    context.trace(`Validating the '${satisfiesAssertionString}' satisfies assertino's '${referenceString}' reference...`);
 
     const axiom = context.findAxiomByReference(this.reference, context);
 
@@ -71,7 +72,7 @@ export default define(class SatisfiesAssertion extends Assertion {
     }
 
     if (referenceVerifies) {
-      context.debug(`...verified the '${referenceString}' reference.`);
+      context.debug(`...validated the '${satisfiesAssertionString}' satisfies assertino's '${referenceString}' reference.`);
     }
 
     return referenceVerifies;
@@ -85,7 +86,7 @@ export default define(class SatisfiesAssertion extends Assertion {
 
     context.trace(`Unifying the '${statementString}' statement with the '${satisfiesAssertionString}' satisfies assertion...`);
 
-    this.signature.verify(context);
+    this.signature.validate(context);
 
     const axiom = context.findAxiomByReference(this.reference),
           satisfiable = axiom.isSatisfiable();
@@ -95,14 +96,14 @@ export default define(class SatisfiesAssertion extends Assertion {
 
       const { Substitutions } = elements;
 
-      substitutions = Substitutions.fromNothing();
+      substitutions = Substitutions.fromNothing(context);
 
       const axiomComparesToSignature = axiom.compareSignature(this.signature, substitutions, context);
 
       if (axiomComparesToSignature) {
         const substitutionsB = substitutions; ///
 
-        substitutions = Substitutions.fromNothing();
+        substitutions = Substitutions.fromNothing(context);
 
         statementUnifies = axiom.unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, substitutions, context);