occam-verify-cli 1.0.617 → 1.0.631

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,35 @@ export default define(class TypeAssertion extends Assertion {
       if (!termTypeProvisional) {
         const typeEqualToOrSuperTypeOfTermType = this.type.isEqualToOrSuperTypeOf(termType);
 
-        verifiesForwards = typeEqualToOrSuperTypeOfTermType; ///
+        validatesForwards = typeEqualToOrSuperTypeOfTermType; ///
       }
 
-      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/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;
       }
     });
 

package/src/element/equality.js

@@ -4,7 +4,7 @@ import { Element } from "occam-languages";
 
 import { define } from "../elements";
 import { equateTerms } from "../process/equate";
-import { equalityAssignmentFromEquality, variableAssignmentFromVariable } from "../process/assign";
+import { equalityAssignmentFromEquality, leftVariableAssignmentFromEquality, rightVariableAssignmentFromEquality } from "../process/assign";
 
 export default define(class Equality extends Element {
   constructor(context, string, node, leftTerm, rightTerm) {
@@ -29,6 +29,18 @@ export default define(class Equality extends Element {
     return equalityNde;
   }
 
+  getLeftTermNode() {
+    const leftTermNode = this.leftTerm.getNode();
+
+    return leftTermNode;
+  }
+
+  getRightTermNode() {
+    const rightTermNode = this.rightTerm.getNode();
+
+    return rightTermNode;
+  }
+
   getType() {
     let type;
 
@@ -57,6 +69,18 @@ export default define(class Equality extends Element {
     return terms;
   }
 
+  matchEqualityNode(equalityNode) {
+    const equalityNodeA = equalityNode; ///
+
+    equalityNode = this.getEqualityNode();
+
+    const equalityNodeB = equalityNode, ///
+          equalityNodeAAMatchesEqualityBNodeB = equalityNodeA.match(equalityNodeB),
+          equalityNodeMatches = equalityNodeAAMatchesEqualityBNodeB; ///
+
+    return equalityNodeMatches;
+  }
+
   isReflexive() {
     const leftTermString = this.leftTerm.getString(),
           rightTermString = this.rightTerm.getString(),
@@ -65,6 +89,14 @@ export default define(class Equality extends Element {
     return reflexive;
   }
 
+  isEqualTo(equality) {
+    const equalityNode = equality.getNode(),
+          equalityNodeMatches = this.matchEqualityNode(equalityNode),
+          equalTo = equalityNodeMatches;  ///
+
+    return equalTo;
+  }
+
   isEqual(context) {
     let equal = false;
 
@@ -79,151 +111,154 @@ export default define(class Equality extends Element {
     return equal;
   }
 
-  verify(assignments, stated, context) {
-    let verifies = false;
+  isValid(context) {
+    const equalityNode = this.getEqualityNode(),
+          equalityPresent = context.isEqualityPresentByEqualityNode(equalityNode),
+          valid = equalityPresent;  ///
+
+    return valid;
+  }
+
+  validate(assignments, stated, context) {
+    let validates = false;
 
     const equalityString = this.getString(); ///
 
-    context.trace(`Verifying the '${equalityString}' equality...`);
+    context.trace(`Validating the '${equalityString}' equality...`);
 
-    const termsVerify = this.verifyTerms(context);
+    const valid = this.isValid(context);
 
-    if (termsVerify) {
-      let verifiesWhenStated = false,
-          verifiesWhenDerived = false;
+    if (valid) {
+      validates = true;
 
-      if (stated) {
-        verifiesWhenStated = this.verifyWhenStated(assignments, context);
-      } else {
-        verifiesWhenDerived = this.verifyWhenDerived(context);
-      }
+      context.debug(`...the '${equalityString}' equality is already valid.`);
+    } else {
+      const termsValidate = this.validateTerms(context);
+
+      if (termsValidate) {
+        let validatesWhenStated = false,
+            validatesWhenDerived = false;
 
-      if (verifiesWhenStated || verifiesWhenDerived) {
-        verifies = true;
+        if (stated) {
+          validatesWhenStated = this.validateWhenStated(assignments, context);
+        } else {
+          validatesWhenDerived = this.validateWhenDerived(context);
+        }
+
+        if (validatesWhenStated || validatesWhenDerived) {
+          validates = true;
+        }
       }
-    }
 
-    if (verifies) {
+      if (validates) {
+        const equality = this;  ///
 
-        this.assign(assignments, context);
+        context.addEquality(equality);
 
-    }
+        this.assign(assignments, stated, context);
 
-    if (verifies) {
-      context.debug(`...verified the '${equalityString}' equality.`);
+        context.debug(`...validated the '${equalityString}' equality.`);
+      }
     }
 
-    return verifies;
+    return validates;
   }
 
-  verifyTerms(context) {
-    let termsVerify;
+  validateTerms(context) {
+    let termsValidate;
 
     const equalityString = this.getString(); ///
 
-    context.trace(`Verifying the '${equalityString}' equality's terms...`);
+    context.trace(`Validating the '${equalityString}' equality's terms...`);
 
-    const leftTermVerifies = this.leftTerm.verify(context, () => {
-      let verifiesForwards;
+    const leftTermValidates = this.leftTerm.validate(context, () => {
+      let validatesForwards;
 
-      const rightTermVerifies = this.rightTerm.verify(context, () => {
-        let verifiesForwards;
+      const rightTermValidates = this.rightTerm.validate(context, () => {
+        let validatesForwards;
 
         const leftTermType = this.leftTerm.getType(),
               rightTermType = this.rightTerm.getType(),
               leftTermTypeComparableToRightTermType = leftTermType.isComparableTo(rightTermType);
 
-        verifiesForwards = leftTermTypeComparableToRightTermType;  ///
+        validatesForwards = leftTermTypeComparableToRightTermType;  ///
 
-        return verifiesForwards;
+        return validatesForwards;
       });
 
-      verifiesForwards = rightTermVerifies; ///
+      validatesForwards = rightTermValidates; ///
 
-      return verifiesForwards;
+      return validatesForwards;
     });
 
-    termsVerify = leftTermVerifies; ///
+    termsValidate = leftTermValidates; ///
 
-    if (termsVerify) {
-      context.debug(`...verified the '${equalityString}' equality's terms.`);
+    if (termsValidate) {
+      context.debug(`...validated the '${equalityString}' equality's terms.`);
     }
 
-    return termsVerify;
+    return termsValidate;
   }
 
-  verifyWhenStated(assignments, context) {
-    let verifiesWhenStated;
+  validateWhenStated(assignments, context) {
+    let validatesWhenStated;
 
     const equalityString = this.getString(); ///
 
-    context.trace(`Verifying the '${equalityString}' stated equality...`);
+    context.trace(`Validating the '${equalityString}' stated equality...`);
 
-    verifiesWhenStated = true;
+    validatesWhenStated = true;
 
-    if (verifiesWhenStated) {
-      context.debug(`...verified the '${equalityString}' stated equality.`);
+    if (validatesWhenStated) {
+      context.debug(`...validated the '${equalityString}' stated equality.`);
     }
 
-    return verifiesWhenStated;
+    return validatesWhenStated;
   }
 
-  verifyWhenDerived(context) {
-    let verifiesWhenDerived;
+  validateWhenDerived(context) {
+    let validatesWhenDerived;
 
     const equalityString = this.getString(); ///
 
-    context.trace(`Verifying the '${equalityString}' derived equality...`);
+    context.trace(`Validating the '${equalityString}' derived equality...`);
 
-    verifiesWhenDerived = true;  ///
+    validatesWhenDerived = true;  ///
 
-    if (verifiesWhenDerived) {
-      context.debug(`...verified the '${equalityString}' derived equality.`);
+    if (validatesWhenDerived) {
+      context.debug(`...validated the '${equalityString}' derived equality.`);
     }
 
-    return verifiesWhenDerived;
+    return validatesWhenDerived;
   }
 
-  assign(assignments, context) {
+  assign(assignments, stated, context) {
     if (assignments === null) {
       return;
     }
 
-    const { Variable } = elements,
-          type = this.getType(),
-          leftTermNode = this.leftTerm.getNode(),
-          rightTermNode = this.rightTerm.getNode(),
-          leftTermNodeSingularVariableNode = leftTermNode.getSingularVariableNode(),
-          rightTermNodeSingularVariableNode = rightTermNode.getSingularVariableNode(),
-          leftVariableNode = leftTermNodeSingularVariableNode,  ///
-          rightVariableNode = rightTermNodeSingularVariableNode;  ///
+    const equality = this,  ///
+          equalityAssignment = equalityAssignmentFromEquality(equality, context),
+          leftVariableAssignment = leftVariableAssignmentFromEquality(equality, context),
+          rightVariableAssignment = rightVariableAssignmentFromEquality(equality, context);
 
     let assignment;
 
-    if (leftVariableNode !== null) {
-      const leftVariable = Variable.fromVariableNodeAndType(leftVariableNode, type, context),
-            leftVariableAssignment = variableAssignmentFromVariable(leftVariable);
+    assignment = equalityAssignment; ///
+
+    assignments.push(assignment);
 
+    if (leftVariableAssignment !== null) {
       assignment = leftVariableAssignment;  ///
 
       assignments.push(assignment);
     }
 
-    if (rightVariableNode !== null) {
-      const rightVariable = Variable.fromVariableNodeAndType(rightVariableNode, type, context),
-            rightVariableAssignment = variableAssignmentFromVariable(rightVariable);
-
+    if (rightVariableAssignment !== null) {
       assignment = rightVariableAssignment;  ///
 
       assignments.push(assignment);
     }
-
-    const equality = this,  //
-          equalityAssignment = equalityAssignmentFromEquality(equality);
-
-    assignment = equalityAssignment; ///
-
-    assignments.push(assignment);
   }
 
   static name = "Equality";