occam-verify-cli 1.0.617 → 1.0.632

package/src/element/assertion/type.js

@@ -1,10 +1,9 @@
 "use strict";
 
-import elements from "../../elements";
 import Assertion from "../assertion";
 
 import { define } from "../../elements";
-import { variableAssignmentFromVariable } from "../../process/assign";
+import { variableAssignmentFromTypeAssertion } from "../../process/assign";
 
 export default define(class TypeAssertion extends Assertion {
   constructor(context, string, node, term, type) {
@@ -29,49 +28,57 @@ export default define(class TypeAssertion extends Assertion {
     return typeAssertionNode;
   }
 
-  verify(assignments, stated, context) {
-    let verifies = false;
+  validate(assignments, stated, context) {
+    let validates = false;
 
-    let typeAssertionString = this.getString();  ///
+    const typeAssertionString = this.getString();  ///
 
-    context.trace(`Verifying the '${typeAssertionString}' type assertion...`);
+    context.trace(`Validating the '${typeAssertionString}' type assertion...`);
 
-    const typeVerifies = this.verifyType(context);
+    const valid = this.isValid();
 
-    if (typeVerifies) {
-      let verifiesWhenStated = false,
-          verifiesWhenDerived = false;
+    if (valid) {
+      validates = true;
 
-      if (stated) {
-        verifiesWhenStated = this.verifyWhenStated(assignments, context);
-      } else {
-        verifiesWhenDerived = this.verifyWhenDerived(context);
-      }
+      context.debug(`...the '${typeAssertionString}' type assertion is already valid.`);
+    } else {
+      const typeValidates = this.validateType(context);
 
-      if (verifiesWhenStated || verifiesWhenDerived) {
-        verifies = true;
-      }
-    }
+      if (typeValidates) {
+        let validatesWhenStated = false,
+              validatesWhenDerived = false;
+
+        if (stated) {
+          validatesWhenStated = this.validateWhenStated(assignments, context);
+        } else {
+          validatesWhenDerived = this.validateWhenDerived(context);
+        }
 
-    if (verifies) {
-      if (stated) {
-        this.assign(assignments, context);
+        if (validatesWhenStated || validatesWhenDerived) {
+          validates = true;
+        }
       }
-    }
 
-    if (verifies) {
-      context.debug(`...verified the '${typeAssertionString}' type assertion.`);
+      if (validates) {
+        const assertion = this; ///
+
+        context.addAssertion(assertion);
+
+        this.assign(assignments, stated, context);
+
+        context.debug(`...verified the '${typeAssertionString}' type assertion.`);
+      }
     }
 
-    return verifies;
+    return validates;
   }
 
-  verifyType(context) {
-    let typeVerifies;
+  validateType(context) {
+    let typeValidates;
 
     const typeString = this.type.getString();
 
-    context.trace(`Verifying the '${typeString}' type...`);
+    context.trace(`Validating the '${typeString}' type...`);
 
     const nominalTypeName = this.type.getNominalTypeName(),
           type = context.findTypeByNominalTypeName(nominalTypeName);
@@ -79,58 +86,58 @@ export default define(class TypeAssertion extends Assertion {
     if (type !== null) {
       this.type = type;
 
-      typeVerifies = true;
+      typeValidates = true;
     } else {
       context.debug(`The '${typeString}' type is not present.`);
     }
 
-    if (typeVerifies) {
+    if (typeValidates) {
       context.debug(`...verified the '${typeString}' type.`);
     }
 
-    return typeVerifies;
+    return typeValidates;
   }
 
-  verifyWhenStated(assignments, context) {
-    let verifiesWhenStated = false;
+  validateWhenStated(assignments, context) {
+    let validatesWhenStated = false;
 
     const typeAssertionString = this.getString(); ///
 
-    context.trace(`Verifying the '${typeAssertionString}' stated type assertion...`);
+    context.trace(`Validating the '${typeAssertionString}' stated type assertion...`);
 
-    const termVerifies = this.term.verify(context, () => {
-      let verifiesForwards;
+    const termValidates = this.term.validate(context, () => {
+      let validatesForwards;
 
       const termType = this.term.getType(),
             typeEqualToOrSubTypeOfTermType = this.type.isEqualToOrSubTypeOf(termType);
 
       if (typeEqualToOrSubTypeOfTermType) {
-        verifiesForwards = true;
+        validatesForwards = true;
       }
 
-      return verifiesForwards;
+      return validatesForwards;
     });
 
-    if (termVerifies) {
-      verifiesWhenStated = true;
+    if (termValidates) {
+      validatesWhenStated = true;
     }
 
-    if (verifiesWhenStated) {
+    if (validatesWhenStated) {
       context.debug(`...verified the '${typeAssertionString}' stated type assertion.`);
     }
 
-    return verifiesWhenStated;
+    return validatesWhenStated;
   }
 
-  verifyWhenDerived(context) {
-    let verifiesWhenDerived;
+  validateWhenDerived(context) {
+    let validatesWhenDerived;
 
     const typeAssertionString = this.getString(); ///
 
-    context.trace(`Verifying the '${typeAssertionString}' derived type assertion...`);
+    context.trace(`Validating the '${typeAssertionString}' derived type assertion...`);
 
-    const termVerifies = this.term.verify(context, () => {
-      let verifiesForwards = false;
+    const termValidates = this.term.validate(context, () => {
+      let validatesForwards = false;
 
       const termType = this.term.getType(),
             termTypeProvisional = termType.isProvisional();
@@ -138,52 +145,37 @@ export default define(class TypeAssertion extends Assertion {
       if (!termTypeProvisional) {
         const typeEqualToOrSuperTypeOfTermType = this.type.isEqualToOrSuperTypeOf(termType);
 
-        verifiesForwards = typeEqualToOrSuperTypeOfTermType; ///
+        if (typeEqualToOrSuperTypeOfTermType) {
+          validatesForwards = true;
+        }
       }
 
-      return verifiesForwards;
+      return validatesForwards;
     });
 
-    verifiesWhenDerived = termVerifies; ///
+    validatesWhenDerived = termValidates; ///
 
-    if (verifiesWhenDerived) {
+    if (validatesWhenDerived) {
       context.debug(`...verified the '${typeAssertionString}' derived type assertion.`);
     }
 
-    return verifiesWhenDerived;
+    return validatesWhenDerived;
   }
 
-  assign(assignments, context) {
+  assign(assignments, stated, context) {
     if (assignments === null) {
       return;
     }
 
-    const { Type, Variable } = elements,
-          termNode = this.term.getNode();
-
-    let type,
-        provisional;
-
-    provisional = this.type.isProvisional();
-
-    if (!provisional) {
-      type = this.type;
-    } else {
-      provisional = false;
-
-      type = Type.fromTypeAndProvisional(this.type, provisional);
+    if (!stated) {
+      return;
     }
 
-    const singularVariableNode = termNode.getSingularVariableNode();
+    const typeAssertion = this, ///
+          variableAssigment = variableAssignmentFromTypeAssertion(typeAssertion, context),
+          assignment = variableAssigment;  ///
 
-    if (singularVariableNode !== null) {
-      const variableNode = singularVariableNode,  ///
-            variable = Variable.fromVariableNodeAndType(variableNode, type, context),
-            variableAssignment = variableAssignmentFromVariable(variable),
-            assignment = variableAssignment;  ///
-
-      assignments.push(assignment);
-    }
+    assignments.push(assignment);
   }
 
   static name = "TypeAssertion";

package/src/element/assumption.js

@@ -31,6 +31,18 @@ export default define(class Assumption extends Element {
 
   getMetavariable() { return this.reference.getMetavariable(); }
 
+  matchAssumptionNode(assumptionode) {
+    const assumptionodeA = assumptionode; ///
+
+    assumptionode = this.getAssumptionNode();
+
+    const assumptionodeB = assumptionode, ///
+          assumptionodeAAMatchesAssumptionBNodeB = assumptionodeA.match(assumptionodeB),
+          assumptionodeMatches = assumptionodeAAMatchesAssumptionBNodeB; ///
+
+    return assumptionodeMatches;
+  }
+
   compareSubstitution(substitution, context) {
     let comparesToSubstituion = false;
 
@@ -55,6 +67,14 @@ export default define(class Assumption extends Element {
     return comparesToSubstituion;
   }
 
+  isValid(context) {
+    const assumptionNode = this.getAssumptionNode(),
+          assumptionPresent = context.isAssumptionPresentByAssumptionNode(assumptionNode),
+          valid = assumptionPresent;  ///
+
+    return valid;
+  }
+
   validate(assignments, stated, context) {
     let validates = false;
 
@@ -62,29 +82,41 @@ export default define(class Assumption extends Element {
 
     context.trace(`Validating the '${assumptionString}' assumption...`);
 
-    const referenceValidates = this.validateReference(assignments, stated, context);
+    const valid = this.isValid(context);
 
-    if (referenceValidates) {
-      const statementValidates = this.validateStatement(assignments, stated, context);
+    if (valid) {
+      validates = true;
 
-      if (statementValidates) {
-        let validatesWhenStated = false,
-            validatesWhenDerived = false;
+      context.debug(`...the '${assumptionString}' assumption is already valid.`);
+    } else {
+      const referenceValidates = this.validateReference(assignments, stated, context);
 
-        if (stated) {
-          validatesWhenStated = this.validateWhenStated(assignments, context);
-        } else {
-          validatesWhenDerived = this.validateWhenDerived(context);
-        }
+      if (referenceValidates) {
+        const statementValidates = this.validateStatement(assignments, stated, context);
+
+        if (statementValidates) {
+          let validatesWhenStated = false,
+              validatesWhenDerived = false;
+
+          if (stated) {
+            validatesWhenStated = this.validateWhenStated(assignments, context);
+          } else {
+            validatesWhenDerived = this.validateWhenDerived(context);
+          }
 
-        if (validatesWhenStated || validatesWhenDerived) {
-          validates = true;
+          if (validatesWhenStated || validatesWhenDerived) {
+            validates = true;
+          }
         }
       }
-    }
 
-    if (validates) {
-      context.debug(`...validated the '${assumptionString}' assumption.`);
+      if (validates) {
+        const assumption = this;  ///
+
+        context.addAssumption(assumption);
+
+        context.debug(`...validated the '${assumptionString}' assumption.`);
+      }
     }
 
     return validates;

package/src/element/constructor/bracketed.js

@@ -1,9 +1,9 @@
 "use strict";
 
-import elements from "../../elements";
 import Constructor from "../constructor";
 
 import { define } from "../../elements";
+import { termFromTermNode } from "../../utilities/element";
 
 export default define(class BracketedConstructor extends Constructor {
   getBracketedConstructorNode() {
@@ -13,7 +13,7 @@ export default define(class BracketedConstructor extends Constructor {
     return bracketedConstructorNode;
   }
 
-  unifyTerm(term, context, verifyForwards) {
+  unifyTerm(term, context, validateForwards) {
     let termUnifies;
 
     const termString = term.getString();
@@ -21,34 +21,33 @@ export default define(class BracketedConstructor extends Constructor {
     context.trace(`Unifying the '${termString}' term with the bracketed constructor...`);
 
     termUnifies = super.unifyTerm(term, context, () => {
-      let verifiesForwards = false;
+      let validatesForwards = false;
 
-      const { Term } = elements,
-            bracketedTerm = term, ///
+      const bracketedTerm = term, ///
             bracketedTermNode = bracketedTerm.getNode(),
             singularTermNode = bracketedTermNode.getSingularTermNode();
 
       if (singularTermNode !== null) {
         const termNode = singularTermNode;  ///
 
-        term = Term.fromTermNode(termNode, context);
+        term = termFromTermNode(termNode, context);
 
-        const termVVerifies = term.verify(context, () => {
-          let verifiesForwards;
+        const termValidates = term.validate(context, () => {
+          let validatesForwards;
 
           const type = term.getType();
 
           bracketedTerm.setType(type);
 
-          verifiesForwards = verifyForwards();
+          validatesForwards = validateForwards();
 
-          return verifiesForwards;
+          return validatesForwards;
         });
 
-        verifiesForwards = termVVerifies;  ///
+        validatesForwards = termValidates;  ///
       }
 
-      return verifiesForwards;
+      return validatesForwards;
     });
 
     if (termUnifies) {

package/src/element/constructor.js

@@ -30,7 +30,7 @@ export default define(class Constructor extends Element {
 
   setType(type) { this.term.setType(type); }
 
-  unifyTerm(term, context, verifyForwards) {
+  unifyTerm(term, context, validateForwards) {
     let termUnifies = false;
 
     const termString = term.getString(),
@@ -42,15 +42,15 @@ export default define(class Constructor extends Element {
           termUnifiesWithConstructor = unifyTermWithConstructor(term, constructor, context);
 
     if (termUnifiesWithConstructor) {
-      let verifiesForwards;
+      let validatesForwards;
 
       const type = this.getType();
 
       term.setType(type);
 
-      verifiesForwards = verifyForwards();
+      validatesForwards = validateForwards();
 
-      termUnifies = verifiesForwards;  ///
+      termUnifies = validatesForwards;  ///
     }
 
     if (termUnifies) {

package/src/element/declaration/constructor.js

@@ -33,7 +33,11 @@ export default define(class ConstructorDeclaration extends Declaration {
 
     const term = this.constructor.getTerm(),
           termNode = term.getNode(),
-          termValidates = validateTerm(termNode, context);
+          termValidates = validateTerm(termNode, context, () => {
+            const validatesFormards = true;
+
+            return validatesFormards;
+          });
 
     if (termValidates) {
       constructorValidates = true;

package/src/element/derivation.js

@@ -43,13 +43,11 @@ export default define(class Derivation extends Element {
             subproofOrProofAssertionVerifies = await subproofOrProofAssertion.verify(assignments, context);
 
       if (subproofOrProofAssertionVerifies) {
-        const assignmentsAssigned = assignAssignments(assignments, context);
+        assignAssignments(assignments, context);
 
-        if (assignmentsAssigned) {
-          context.addSubproofOrProofAssertion(subproofOrProofAssertion);
+        context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
-          return true;
-        }
+        return true;
       }
     });