occam-verify-cli 1.0.635 → 1.0.638

package/src/element/assertion/type.js

@@ -28,28 +28,30 @@ export default define(class TypeAssertion extends Assertion {
     return typeAssertionNode;
   }
 
-  validate(assignments, stated, context) {
-    let validates = false;
+  validate(stated, context) {
+    let typeAssertion = null;
 
     const typeAssertionString = this.getString();  ///
 
     context.trace(`Validating the '${typeAssertionString}' type assertion...`);
 
-    const valid = this.isValid();
+    const validAssertion = this.findValidAssertion(context);
 
-    if (valid) {
-      validates = true;
+    if (validAssertion) {
+      typeAssertion = validAssertion; ///
 
       context.debug(`...the '${typeAssertionString}' type assertion is already valid.`);
     } else {
+      let validates = false;
+
       const typeValidates = this.validateType(context);
 
       if (typeValidates) {
         let validatesWhenStated = false,
-              validatesWhenDerived = false;
+            validatesWhenDerived = false;
 
         if (stated) {
-          validatesWhenStated = this.validateWhenStated(assignments, context);
+          validatesWhenStated = this.validateWhenStated(context);
         } else {
           validatesWhenDerived = this.validateWhenDerived(context);
         }
@@ -62,15 +64,17 @@ export default define(class TypeAssertion extends Assertion {
       if (validates) {
         const assertion = this; ///
 
-        context.addAssertion(assertion);
+        typeAssertion = assertion;  ///
 
-        this.assign(assignments, stated, context);
+        this.assign(stated, context);
+
+        context.addAssertion(assertion);
 
         context.debug(`...verified the '${typeAssertionString}' type assertion.`);
       }
     }
 
-    return validates;
+    return typeAssertion;
   }
 
   validateType(context) {
@@ -98,14 +102,14 @@ export default define(class TypeAssertion extends Assertion {
     return typeValidates;
   }
 
-  validateWhenStated(assignments, context) {
+  validateWhenStated(context) {
     let validatesWhenStated = false;
 
     const typeAssertionString = this.getString(); ///
 
     context.trace(`Validating the '${typeAssertionString}' stated type assertion...`);
 
-    const termValidates = this.term.validate(context, () => {
+    const term = this.term.validate(context, () => {
       let validatesForwards;
 
       const termType = this.term.getType(),
@@ -118,7 +122,9 @@ export default define(class TypeAssertion extends Assertion {
       return validatesForwards;
     });
 
-    if (termValidates) {
+    if (term !== null) {
+      this.term = term;
+
       validatesWhenStated = true;
     }
 
@@ -130,13 +136,13 @@ export default define(class TypeAssertion extends Assertion {
   }
 
   validateWhenDerived(context) {
-    let validatesWhenDerived;
+    let validatesWhenDerived = false;
 
     const typeAssertionString = this.getString(); ///
 
     context.trace(`Validating the '${typeAssertionString}' derived type assertion...`);
 
-    const termValidates = this.term.validate(context, () => {
+    const term = this.term.validate(context, () => {
       let validatesForwards = false;
 
       const termType = this.term.getType(),
@@ -153,7 +159,11 @@ export default define(class TypeAssertion extends Assertion {
       return validatesForwards;
     });
 
-    validatesWhenDerived = termValidates; ///
+    if (term !== null) {
+      this.term = term;
+
+      validatesWhenDerived = true;
+    }
 
     if (validatesWhenDerived) {
       context.debug(`...verified the '${typeAssertionString}' derived type assertion.`);
@@ -162,11 +172,7 @@ export default define(class TypeAssertion extends Assertion {
     return validatesWhenDerived;
   }
 
-  assign(assignments, stated, context) {
-    if (assignments === null) {
-      return;
-    }
-
+  assign(stated, context) {
     if (!stated) {
       return;
     }
@@ -175,7 +181,7 @@ export default define(class TypeAssertion extends Assertion {
           variableAssigment = variableAssignmentFromTypeAssertion(typeAssertion, context),
           assignment = variableAssigment;  ///
 
-    assignments.push(assignment);
+    context.addAassignment(assignment);
   }
 
   static name = "TypeAssertion";

package/src/element/assertion.js

@@ -22,12 +22,12 @@ export default class Assertion extends Element {
     return assertionNodeMatches;
   }
 
-  isValid(context) {
+  findValidAssertion(context) {
     const assertionNode = this.getAssertionNode(),
-          assertionPresent = context.isAssertionPresentByAssertionNode(assertionNode),
-          valid = assertionPresent;  ///
+          assertion = context.findAssertionByAssertionNode(assertionNode),
+          validAssertion = assertion;  ///
 
-    return valid;
+    return validAssertion;
   }
 
   isEqualTo(assertion) {

package/src/element/assumption.js

@@ -67,39 +67,41 @@ export default define(class Assumption extends Element {
     return comparesToSubstituion;
   }
 
-  isValid(context) {
+  findValidAssumption(context) {
     const assumptionNode = this.getAssumptionNode(),
-          assumptionPresent = context.isAssumptionPresentByAssumptionNode(assumptionNode),
-          valid = assumptionPresent;  ///
+          assumption = context.findAssumptionByAssumptionNode(assumptionNode),
+          validAssumption = assumption;  ///
 
-    return valid;
+    return validAssumption;
   }
 
-  validate(assignments, stated, context) {
-    let validates = false;
+  validate(stated, context) {
+    let assumption = null;
 
     const assumptionString = this.getString();  ///
 
     context.trace(`Validating the '${assumptionString}' assumption...`);
 
-    const valid = this.isValid(context);
+    const validAssumption = this.findValidAssumption(context);
 
-    if (valid) {
-      validates = true;
+    if (validAssumption) {
+      assumption = validAssumption; ///
 
       context.debug(`...the '${assumptionString}' assumption is already valid.`);
     } else {
-      const referenceValidates = this.validateReference(assignments, stated, context);
+      let validates = false;
+
+      const referenceValidates = this.validateReference(stated, context);
 
       if (referenceValidates) {
-        const statementValidates = this.validateStatement(assignments, stated, context);
+        const statementValidates = this.validateStatement(stated, context);
 
         if (statementValidates) {
           let validatesWhenStated = false,
               validatesWhenDerived = false;
 
           if (stated) {
-            validatesWhenStated = this.validateWhenStated(assignments, context);
+            validatesWhenStated = this.validateWhenStated(context);
           } else {
             validatesWhenDerived = this.validateWhenDerived(context);
           }
@@ -119,18 +121,22 @@ export default define(class Assumption extends Element {
       }
     }
 
-    return validates;
+    return assumption;
   }
 
-  validateReference(assignments, stated, context) {
-    let referenceValidates;
+  validateReference(stated, context) {
+    let referenceValidates = false;
 
     const assumptionString = this.getString(),  ///
           referenceString = this.reference.getString();
 
     context.trace(`Validating the '${assumptionString}' assumption's '${referenceString}' reference...`);
 
-    referenceValidates = this.reference.validate(context);
+    const reference = this.reference.validate(context);
+
+    if (reference !== null) {
+      referenceValidates = true;
+    }
 
     if (referenceValidates) {
       context.debug(`...validated the '${assumptionString}' assumption's '${referenceString}' statement.`);
@@ -139,19 +145,21 @@ export default define(class Assumption extends Element {
     return referenceValidates;
   }
 
-  validateStatement(assignments, stated, context) {
-    let statementValidates;
+  validateStatement(stated, context) {
+    let statementValidates = false;
 
     const assumptionString = this.getString(),  ///
-          statementString = this.statement.getString();
+      statementString = this.statement.getString();
 
     context.trace(`Validating the '${assumptionString}' assumption's '${statementString}' statement...`);
 
     stated = true;  ///
 
-    assignments = null; ///
+    const statement = this.statement.validate(stated, context);
 
-    statementValidates = this.statement.validate(assignments, stated, context);
+    if (statement !== null) {
+      statementValidates = true;
+    }
 
     if (statementValidates) {
       context.debug(`...validated the '${assumptionString}' assumption's '${statementString}' statement.`);
@@ -160,7 +168,7 @@ export default define(class Assumption extends Element {
     return statementValidates;
   }
 
-  validateReferenceAsMetavariable(assignments, stated, context) {
+  validateReferenceAsMetavariable(stated, context) {
     let referenceValidatesAsMetavariable;
 
     const referenceString = this.reference.getString(),
@@ -177,7 +185,7 @@ export default define(class Assumption extends Element {
     return referenceValidatesAsMetavariable;
   }
 
-  validateWhenStated(assignments, context) {
+  validateWhenStated(context) {
     let validatesWhenStated;
 
     const assumptionString = this.getString();  ///

package/src/element/combinator/bracketed.js

@@ -12,14 +12,14 @@ export default define(class BracketedCombinator extends Combinator {
     return bracketedCombinatorNode;
   }
 
-  unifyStatement(statement, assignments, stated, context) {
+  unifyStatement(statement, stated, context) {
     let statementUnifies;
 
     const statementString = statement.getString();
 
     context.trace(`Unifying the '${statementString}' statement with the bracketed combinator...`);
 
-    statementUnifies = super.unifyStatement(statement, assignments, stated, context);
+    statementUnifies = super.unifyStatement(statement, stated, context);
 
     if (statementUnifies) {
       context.debug(`...unified the '${statementString}' statement with the bracketed combinator.`);

package/src/element/combinator.js

@@ -47,7 +47,7 @@ export default define(class Combinator extends Element {
     return verifies;
   }
 
-  unifyStatement(statement, assignments, stated, context) {
+  unifyStatement(statement, stated, context) {
     let statementUnifies;
 
     const statementString = statement.getString(),
@@ -64,7 +64,7 @@ export default define(class Combinator extends Element {
     context = specifiContext; ///
 
     const combinator = this, ///
-          statementUnifiesWithCombinator = unifyStatementWithCombinator(statement, combinator, assignments, stated, generalContext, specifiContext);
+          statementUnifiesWithCombinator = unifyStatementWithCombinator(statement, combinator, stated, generalContext, specifiContext);
 
     statementUnifies = statementUnifiesWithCombinator; ///
 

package/src/element/conclusion.js

@@ -35,9 +35,14 @@ export  default define(class Conclusion extends Element {
 
     if (this.statement !== null) {
       attempt((context) => {
+        let statementValidates = false;
+
         const stated = true,
-              assignments = null,
-              statementValidates = this.statement.validate(assignments, stated, context);
+              statement = this.statement.validate(stated, context);
+
+        if (statement !== null) {
+          statementValidates = true;
+        }
 
         if (statementValidates) {
           this.setContext(context);

package/src/element/constructor/bracketed.js

@@ -32,7 +32,7 @@ export default define(class BracketedConstructor extends Constructor {
 
         term = termFromTermNode(termNode, context);
 
-        const termValidates = term.validate(context, () => {
+        term = term.validate(context, () => {
           let validatesForwards;
 
           const type = term.getType();
@@ -44,7 +44,9 @@ export default define(class BracketedConstructor extends Constructor {
           return validatesForwards;
         });
 
-        validatesForwards = termValidates;  ///
+        if (term !== null) {
+          validatesForwards = true;
+        }
       }
 
       return validatesForwards;

package/src/element/deduction.js

@@ -35,9 +35,14 @@ export default define(class Deduction extends Element {
 
     if (this.statement !== null) {
       attempt((context) => {
+        let statementValidates = false;
+
         const stated = true,
-              assignments = null,
-              statementValidates = this.statement.validate(assignments, stated, context);
+              statement = this.statement.validate(stated, context);
+
+        if (statement !== null) {
+          statementValidates = true;
+        }
 
         if (statementValidates) {
           this.setContext(context);

package/src/element/derivation.js

@@ -39,11 +39,10 @@ export default define(class Derivation extends Element {
     let verifies;
 
     verifies = await asyncEvery(this.subproofOrProofAssertions, async (subproofOrProofAssertion) => { ///
-      const assignments = [],
-            subproofOrProofAssertionVerifies = await subproofOrProofAssertion.verify(assignments, context);
+      const subproofOrProofAssertionVerifies = await subproofOrProofAssertion.verify(context);
 
       if (subproofOrProofAssertionVerifies) {
-        assignAssignments(assignments, context);
+        context.assignAssignments();
 
         context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 

package/src/element/equality.js

@@ -111,28 +111,30 @@ export default define(class Equality extends Element {
     return equal;
   }
 
-  isValid(context) {
+  findValidEquality(context) {
     const equalityNode = this.getEqualityNode(),
-          equalityPresent = context.isEqualityPresentByEqualityNode(equalityNode),
-          valid = equalityPresent;  ///
+          equality = context.findEqualityByEqualityNode(equalityNode),
+          validEquality = equality;  ///
 
-    return valid;
+    return validEquality;
   }
 
-  validate(assignments, stated, context) {
-    let validates = false;
+  validate(stated, context) {
+    let equality = false;
 
     const equalityString = this.getString(); ///
 
     context.trace(`Validating the '${equalityString}' equality...`);
 
-    const valid = this.isValid(context);
+    const validEquality = this.isValid(context);
 
-    if (valid) {
-      validates = true;
+    if (validEquality !== null) {
+      equality = validEquality; ///
 
       context.debug(`...the '${equalityString}' equality is already valid.`);
     } else {
+      let validates = false;
+
       const termsValidate = this.validateTerms(context);
 
       if (termsValidate) {
@@ -140,7 +142,7 @@ export default define(class Equality extends Element {
             validatesWhenDerived = false;
 
         if (stated) {
-          validatesWhenStated = this.validateWhenStated(assignments, context);
+          validatesWhenStated = this.validateWhenStated(context);
         } else {
           validatesWhenDerived = this.validateWhenDerived(context);
         }
@@ -153,45 +155,58 @@ export default define(class Equality extends Element {
       if (validates) {
         const equality = this;  ///
 
-        context.addEquality(equality);
+        this.assign(stated, context);
 
-        this.assign(assignments, stated, context);
+        context.addEquality(equality);
 
         context.debug(`...validated the '${equalityString}' equality.`);
       }
     }
 
-    return validates;
+    return equality;
   }
 
   validateTerms(context) {
-    let termsValidate;
+    let termsValidate = false;
 
     const equalityString = this.getString(); ///
 
     context.trace(`Validating the '${equalityString}' equality's terms...`);
 
-    const leftTermValidates = this.leftTerm.validate(context, () => {
-      let validatesForwards;
+    let leftTerm,
+        rightTerm = null;
 
-      const rightTermValidates = this.rightTerm.validate(context, () => {
+    leftTerm = this.leftTerm.validate(context, () => {
         let validatesForwards;
 
-        const leftTermType = this.leftTerm.getType(),
-              rightTermType = this.rightTerm.getType(),
-              leftTermTypeComparableToRightTermType = leftTermType.isComparableTo(rightTermType);
+        rightTerm = this.rightTerm.validate(context, () => {
+          let validatesForwards;
+
+          const leftTermType = this.leftTerm.getType(),
+                rightTermType = this.rightTerm.getType(),
+                leftTermTypeComparableToRightTermType = leftTermType.isComparableTo(rightTermType);
+
+          validatesForwards = leftTermTypeComparableToRightTermType;  ///
+
+          return validatesForwards;
+        });
 
-        validatesForwards = leftTermTypeComparableToRightTermType;  ///
+        const rightTermValidates = (rightTerm !== null);
+
+        validatesForwards = rightTermValidates; ///
 
         return validatesForwards;
       });
 
-      validatesForwards = rightTermValidates; ///
+    const leftTermValidates = (leftTerm !== null);
+
+    if (leftTermValidates) {
+      this.leftTerm = leftTerm;
 
-      return validatesForwards;
-    });
+      this.rightTerm = rightTerm;
 
-    termsValidate = leftTermValidates; ///
+      termsValidate = true;
+    }
 
     if (termsValidate) {
       context.debug(`...validated the '${equalityString}' equality's terms.`);
@@ -200,7 +215,7 @@ export default define(class Equality extends Element {
     return termsValidate;
   }
 
-  validateWhenStated(assignments, context) {
+  validateWhenStated(context) {
     let validatesWhenStated;
 
     const equalityString = this.getString(); ///
@@ -232,11 +247,7 @@ export default define(class Equality extends Element {
     return validatesWhenDerived;
   }
 
-  assign(assignments, stated, context) {
-    if (assignments === null) {
-      return;
-    }
-
+  assign(stated, context) {
     const equality = this,  ///
           equalityAssignment = equalityAssignmentFromEquality(equality, context),
           leftVariableAssignment = leftVariableAssignmentFromEquality(equality, context),
@@ -246,18 +257,18 @@ export default define(class Equality extends Element {
 
     assignment = equalityAssignment; ///
 
-    assignments.push(assignment);
+    context.addAssignment(assignment);
 
     if (leftVariableAssignment !== null) {
       assignment = leftVariableAssignment;  ///
 
-      assignments.push(assignment);
+      context.addAssignment(assignment);
     }
 
     if (rightVariableAssignment !== null) {
       assignment = rightVariableAssignment;  ///
 
-      assignments.push(assignment);
+      context.addAssignment(assignment);
     }
   }