occam-verify-cli 1.0.457 → 1.0.473

package/src/element/assertion/contained.js

@@ -6,7 +6,7 @@ import { define } from "../../elements";
 import { termFromTermAndSubstitutions, frameFromFrameAndSubstitutions, statementFromStatementAndSubstitutions } from "../../utilities/substitutions";
 
 export default define(class ContainedAssertion extends Assertion {
-  constructor(cpontext, string, node, term, frame, negated, statement) {
+  constructor(context, string, node, term, frame, negated, statement) {
     super(context, string, node);
 
     this.term = term;
@@ -31,46 +31,47 @@ export default define(class ContainedAssertion extends Assertion {
     return this.statement;
   }
 
-  verify(assignments, stated, context) {
-    let verifies = false;
+  validate(assignments, stated, context) {
+    let validates = false;
 
     const containedAssertionString = this.getString(); ///
 
-    context.trace(`Verifying the '${containedAssertionString}' contained assertion...`);
+    context.trace(`Validating the '${containedAssertionString}' contained assertion...`);
 
     const termValidates = this.validateTerm(assignments, stated, context),
-          frameVerifies = this.verifyFrame(assignments, stated, context),
+          frameVerifies = this.validateFrame(assignments, stated, context),
           statementValidates = this.validateStatement(assignments, stated, context)
 
     if (termValidates || frameVerifies || statementValidates) {
-      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) {
-      context.debug(`...verified the '${containedAssertionString}' contained assertion.`);
+    if (validates) {
+      context.debug(`...validated the '${containedAssertionString}' contained assertion.`);
     }
 
-    return verifies;
+    return validates;
   }
 
   validateTerm(assignments, stated, context) {
     let termValidates = false;
 
     if (this.term !== null) {
-      const termString = this.term.getString();
+      const termString = this.term.getString(),
+            containedAssertionString = this.getString(); ///
 
-      context.trace(`Validating the '${termString}' term...`);
+      context.trace(`Validating the '${containedAssertionString}' contained assertino's '${termString}' term...`);
 
       const termSingular = this.term.isSingular();
 
@@ -78,13 +79,13 @@ export default define(class ContainedAssertion extends Assertion {
         context.debug(`The '${termString}' term is not singular.`);
       } else {
         termValidates = this.term.validate(context, () => {
-          const verifiesAhead = true;
+          const validatesAhead = true;
 
-          return verifiesAhead;
+          return validatesAhead;
         });
 
         if (termValidates) {
-          context.debug(`...validated the '${termString}' term.`);
+          context.debug(`...validated the '${containedAssertionString}' contained assertino's '${termString}' term.`);
         }
       }
     }
@@ -92,13 +93,14 @@ export default define(class ContainedAssertion 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(),
+            containedAssertionString = this.getString(); ///
 
-      context.trace(`Verifying the '${frameString}' frame...`);
+      context.trace(`Validating the '${containedAssertionString}' contained assertino's '${frameString}' frame...`);
 
       const frameSingular = this.frame.isSingular();
 
@@ -109,10 +111,10 @@ export default define(class ContainedAssertion 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 '${containedAssertionString}' contained assertino's '${frameString}' frame.`);
         }
       }
     }
@@ -142,39 +144,39 @@ export default define(class ContainedAssertion extends Assertion {
     return statementValidates;
   }
 
-  verifyWhenStated(assignments, context) {
-    let verifiesWhenStated;
+  validateWhenStated(assignments, context) {
+    let validatesWhenStated;
 
     const containedAssertionString = this.getString(); ///
 
-    context.trace(`Verifying the '${containedAssertionString}' stated contained assertion...`);
+    context.trace(`Validating the '${containedAssertionString}' stated contained assertion...`);
 
-    verifiesWhenStated = true;
+    validatesWhenStated = true;
 
-    if (verifiesWhenStated) {
-      context.debug(`...verified the '${containedAssertionString}' stated contained assertion.`);
+    if (validatesWhenStated) {
+      context.debug(`...validated the '${containedAssertionString}' stated contained assertion.`);
     }
 
-    return verifiesWhenStated;
+    return validatesWhenStated;
   }
 
-  verifyWhenDerived(context) {
-    let verifiesWhenDerived;
+  validateWhenDerived(context) {
+    let validatesWhenDerived;
 
     const containedAssertionString = this.getString(); ///
 
-    context.trace(`Verifying the '${containedAssertionString}' derived contained assertion...`);
+    context.trace(`Validating the '${containedAssertionString}' derived contained assertion...`);
 
     const generalCotnext = null,
           specificContext = context; ///
 
-    verifiesWhenDerived = verifyWhenDerived(this.term, this.frame, this.statement, this.negated, generalCotnext, specificContext);
+    validatesWhenDerived = validateWhenDerived(this.term, this.frame, this.statement, this.negated, generalCotnext, specificContext);
 
-    if (verifiesWhenDerived) {
-      context.debug(`...verified the '${containedAssertionString}' derived contained assertion.`);
+    if (validatesWhenDerived) {
+      context.debug(`...validated the '${containedAssertionString}' derived contained assertion.`);
     }
 
-    return verifiesWhenDerived;
+    return validatesWhenDerived;
   }
 
   unifyIndependently(substitutions, generalContext, specificContext) {
@@ -188,9 +190,9 @@ export default define(class ContainedAssertion extends Assertion {
     const term = termFromTermAndSubstitutions(this.term, substitutions, generalContext, specificContext),
           frame = frameFromFrameAndSubstitutions(this.frame, substitutions, generalContext, specificContext),
           statement = statementFromStatementAndSubstitutions(this.statement, substitutions, generalContext, specificContext),
-          verifiesWhenDerived = verifyWhenDerived(term, frame, statement, this.negated, generalContext, specificContext);
+          validatesWhenDerived = validateWhenDerived(term, frame, statement, this.negated, generalContext, specificContext);
 
-    unifiesIndependently = verifiesWhenDerived; ///
+    unifiesIndependently = validatesWhenDerived; ///
 
     if (unifiesIndependently) {
       context.debug(`...unified the '${containedAssertionString}' contained assertion independently.`);
@@ -202,8 +204,8 @@ export default define(class ContainedAssertion extends Assertion {
   static name = "ContainedAssertion";
 });
 
-function verifyWhenDerived(term, frame, statement, negated, generalContext, specificContext) {
-  let verifiesWhenDerived = false;
+function validateWhenDerived(term, frame, statement, negated, generalContext, specificContext) {
+  let validatesWhenDerived = false;
 
   const context = specificContext;  ///
 
@@ -212,11 +214,11 @@ function verifyWhenDerived(term, frame, statement, negated, generalContext, spec
       const termContained = statement.isTermContained(term, context);
 
       if (!negated && termContained) {
-        verifiesWhenDerived = true;
+        validatesWhenDerived = true;
       }
 
       if (negated && !termContained) {
-        verifiesWhenDerived = true;
+        validatesWhenDerived = true;
       }
     }
 
@@ -224,14 +226,14 @@ function verifyWhenDerived(term, frame, statement, negated, generalContext, spec
       const frameContained = statement.isFrameContained(frame, context);
 
       if (!negated && frameContained) {
-        verifiesWhenDerived = true;
+        validatesWhenDerived = true;
       }
 
       if (negated && !frameContained) {
-        verifiesWhenDerived = true;
+        validatesWhenDerived = true;
       }
     }
   }
 
-  return verifiesWhenDerived;
+  return validatesWhenDerived;
 }

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);
 

package/src/element/assumption.js

@@ -140,20 +140,14 @@ export default define(class Assumption extends Element {
   }
 
   validateReferenceAsMetavariable(assignments, stated, context) {
-    let referenceValidatesAsMetavariable = false;
+    let referenceValidatesAsMetavariable;
 
     const referenceString = this.reference.getString(),
           assumptionString = this.getString(); ///
 
     context.trace(`Validating the '${assumptionString}' assumption's '${referenceString}' reference as s metavariable...`);
 
-    const metavariable = this.reference.getMetavariable(),
-          metavariableName = metavariable.getName(),
-          metavariablePresent = context.isMetavariablePresentByMetavariableName(metavariableName);
-
-    if (metavariablePresent) {
-      referenceValidatesAsMetavariable = true;
-    }
+    referenceValidatesAsMetavariable = this.reference.validateAsMetavariable(context);
 
     if (referenceValidatesAsMetavariable) {
       context.debug(`...validated the '${assumptionString}' assumption's '${referenceString}' reference as a metavariable.`);
@@ -273,13 +267,13 @@ export default define(class Assumption extends Element {
 
     const { Substitutions } = elements,
           specificContext = context,  ///
-          labelSubstitutions = Substitutions.fromNothing(),
+          labelSubstitutions = Substitutions.fromNothing(context),
           label = topLevelMetaAssertion.getLabel(),
           substitutions = labelSubstitutions, ///
           labelUnifies = this.unifyLabel(label, substitutions, generalContext, specificContext);
 
     if (labelUnifies) {
-      const statementSubstitutions = Substitutions.fromNothing(),
+      const statementSubstitutions = Substitutions.fromNothing(context),
             statement = topLevelMetaAssertion.getStatement(),
             substitutions = statementSubstitutions, ///
             statementUUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);