occam-verify-cli 1.0.617 → 1.0.632

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

package/src/element/equivalence.js

@@ -5,9 +5,9 @@ import { arrayUtilities } from "necessary";
 
 import { define } from "../elements";
 import { literally } from "../utilities/context";
-import { termsStringFromTerms } from "../utilities/string";
 import { instantiateEquivalence } from "../process/instantiate";
 import { stripBracketsFromTermNode } from "../utilities/brackets";
+import { equivalenceStringFromTerms } from "../utilities/string";
 import { equivalenceFromEquivalenceNode } from "../utilities/element";
 
 const { compress } = arrayUtilities;
@@ -57,7 +57,7 @@ export default define(class Equivalence extends Element {
       if (termGrounded) {
         const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
           const groundedTermNode = groundedTerm.getNode(),
-                groundedTermNodeMatches = term.matchNode(groundedTermNode);
+                groundedTermNodeMatches = term.matchTermNode(groundedTermNode);
 
           if (groundedTermNodeMatches) {
             return true;
@@ -151,7 +151,7 @@ export default define(class Equivalence extends Element {
     termNode = stripBracketsFromTermNode(termNode); ///
 
     const termNodeMatches = this.someTerm((term) => {
-      const termNodeMatches = term.matchNode(termNode);
+      const termNodeMatches = term.matchTermNode(termNode);
 
       if (termNodeMatches) {
         return true;
@@ -234,8 +234,8 @@ export default define(class Equivalence extends Element {
 
     return literally((context) => {
       const terms = combinedTerms,  ///
-            termsString = termsStringFromTerms(terms),
-            string = termsString,  ///
+            equivalenceString = equivalenceStringFromTerms(terms),
+            string = equivalenceString,  ///
             equivalenceNode = instantiateEquivalence(string, context),
             equivalence = equivalenceFromEquivalenceNode(equivalenceNode, context);
 
@@ -248,8 +248,8 @@ export default define(class Equivalence extends Element {
   static fromEquality(equality, context) {
     return literally((context) => {
       const terms = equality.getTerms(),
-            termsString = termsStringFromTerms(terms),
-            string = termsString,  ///
+            equivalenceString = equivalenceStringFromTerms(terms),
+            string = equivalenceString,  ///
             equivalenceNode = instantiateEquivalence(string, context),
             equivalence = equivalenceFromEquivalenceNode(equivalenceNode, context);
 

package/src/element/equivalences.js

@@ -80,7 +80,7 @@ export default define(class Equivalences extends Element {
   }
 
   mergedWith(equivalences, context) {
-    let  mergedEquivalences = this.clone(); ///
+    let  mergedEquivalences = this.clone(context); ///
 
     equivalences.forEachEquivalence((equivalence) => {
       mergedEquivalences = mergedEquivalences.mergedWithEquivalence(equivalence, context);
@@ -139,7 +139,7 @@ export default define(class Equivalences extends Element {
   }
 
   separateGroundedTermsAndDefinedVariables(groundedTerms, definedVariables, context) {
-    let equivalences = this,
+    let equivalences = this,  ///
         groundedEquivalences,
         remainingEquivalences,
         initiallyGroundedEquivalences,
@@ -187,11 +187,13 @@ export default define(class Equivalences extends Element {
     }
   }
 
-  clone() {
-    const array = [
+  clone(context) {
+    const string = EMPTY_STRING,
+          node = null,
+          array = [
             ...this.array
           ],
-          equivalences = new Equivalences(array);
+          equivalences = new Equivalences(context, string, node, array);
 
     return equivalences;
   }

package/src/element/frame.js

@@ -51,9 +51,9 @@ export default define(class Frame extends Element {
 
     const frameNodeB = frameNode, ///
           frameNodeAAMatchesFrameBNodeB = frameNodeA.match(frameNodeB),
-          equalTo = frameNodeAAMatchesFrameBNodeB; ///
+          frameNodeMatches = frameNodeAAMatchesFrameBNodeB; ///
 
-    return equalTo;
+    return frameNodeMatches;
   }
 
   isValid(context) {
@@ -79,24 +79,6 @@ export default define(class Frame extends Element {
     return singular;
   }
 
-  matchMetavariableName(metavariableName) {
-    let metavariableNameMatches = false;
-
-    const singular = this.isSingular();
-
-    if (singular) {
-      const metavariableNameA = metavariableName ///
-
-      metavariableName = this.getMetavariableName();
-
-      const metavariableNameB = metavariableName; ///
-
-      metavariableNameMatches = (metavariableNameA === metavariableNameB);
-    }
-
-    return metavariableNameMatches;
-  }
-
   compareParameter(parameter) {
     let comparesToParamter = false;
 
@@ -165,6 +147,24 @@ export default define(class Frame extends Element {
     return comparesToSubstitutions;
   }
 
+  compareMetavariableName(metavariableName) {
+    let comparesToMetavariableName = false;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      const metavariableNameA = metavariableName ///
+
+      metavariableName = this.getMetavariableName();
+
+      const metavariableNameB = metavariableName; ///
+
+      comparesToMetavariableName = (metavariableNameA === metavariableNameB);
+    }
+
+    return comparesToMetavariableName;
+  }
+
   validate(assignments, stated, context) {
     let validates = false;
 
@@ -184,7 +184,7 @@ export default define(class Frame extends Element {
 
       if (assumptionsValidate && metavariablevalidates) {
         let validatesWhenStated = false,
-              validatesWhenDerived = false;
+            validatesWhenDerived = false;
 
         if (stated) {
           validatesWhenStated = this.validateWhenStated(assignments, context);
@@ -289,12 +289,12 @@ export default define(class Frame extends Element {
 
       context.trace(`Validating the '${frameString}' frame's '${metavraibleString}' metavariable...`);
 
-      const metavariable = context.findMetavariable(this.metavariable);
+      const metavariablePresent = context.isMetavariablePresent(this.metavariable);
 
-      if (metavariable !== null) {
+      if (metavariablePresent) {
         const metaTypeName = FRAME_META_TYPE_NAME,
-              frameMetaType = findMetaTypeByMetaTypeName(metaTypeName),
-              metavariableValidateGivenMetaType = metavariable.validateGivenMetaType(frameMetaType, context);
+              frameMetaType = context.findMetaTypeByMetaTypeName(metaTypeName),
+              metavariableValidateGivenMetaType = this.metavariable.validateGivenMetaType(frameMetaType, context);
 
         if (metavariableValidateGivenMetaType) {
           metavariableValidates = true;

package/src/element/hypothesis.js

@@ -40,15 +40,13 @@ export default define(class Hypothesis extends Element {
             statementValidates = this.statement.validate(assignments, stated, context);
 
       if (statementValidates) {
-        const assignmentsAssigned = assignAssignments(assignments, context);
+        assignAssignments(assignments, context);
 
-        if (assignmentsAssigned) {
-          const subproofOrProofAssertion = this;  ///
+        const subproofOrProofAssertion = this;  ///
 
-          context.addSubproofOrProofAssertion(subproofOrProofAssertion);
+        context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
-          verifies = true;
-        }
+        verifies = true;
       }
     } else {
       context.debug(`Unable to verify the '${hypothesisString}' hypothesis because it is nonsense.`);

package/src/element/judgement.js

@@ -37,7 +37,27 @@ export default define(class Judgement extends Element {
 
   getMetavariable() { return this.frame.getMetavariable(); }
 
-  matchMetavariableName(metavariableName) { return this.frame.matchMetavariableName(metavariableName); }
+  compareMetavariableName(metavariableName) { return this.frame.compareMetavariableName(metavariableName); }
+
+  matchJudgementNode(judgementNode) {
+    const judgementNodeA = judgementNode; ///
+
+    judgementNode = this.getJudgementNode();
+
+    const judgementNodeB = judgementNode, ///
+          judgementNodeAAMatchesJudgementBNodeB = judgementNodeA.match(judgementNodeB),
+          judgementNodeMatches = judgementNodeAAMatchesJudgementBNodeB; ///
+
+    return judgementNodeMatches;
+  }
+
+  isValid(context) {
+    const judgementNode = this.getJudgementNode(),
+          judgementPresent = context.isJudgementPresentByJudgementNode(judgementNode),
+          valid = judgementPresent;  ///
+
+    return valid;
+  }
 
   validate(assignments, stated, context) {
     let validates = false;
@@ -46,35 +66,41 @@ export default define(class Judgement extends Element {
 
     context.trace(`Validating the '${judgementString}' judgement...`);
 
-    const frameValidates = this.frame.validate(assignments, stated, context);
+    const valid = this.isValid(context);
 
-    if (frameValidates) {
-      const assumptionValidates = this.assumption.validate(assignments, stated, context);
+    if (valid) {
+      validates = true;
 
-      if (assumptionValidates) {
-        let validatesWhenStated = false,
-            validatesWhenDerived = false;
+      context.debug(`...the '${judgementString}' judgement is already valid.`);
+    } else {
+      const frameValidates = this.frame.validate(assignments, stated, context);
 
-        if (stated) {
-          validatesWhenStated = this.validateWhenStated(assignments, context);
-        } else {
-          validatesWhenDerived = this.validateWhenDerived(context);
-        }
+      if (frameValidates) {
+        const assumptionValidates = this.assumption.validate(assignments, stated, context);
 
-        if (validatesWhenStated || validatesWhenDerived) {
-          validates = true;
+        if (assumptionValidates) {
+          let validatesWhenStated = false,
+              validatesWhenDerived = false;
+
+          if (stated) {
+            validatesWhenStated = this.validateWhenStated(assignments, context);
+          } else {
+            validatesWhenDerived = this.validateWhenDerived(context);
+          }
+
+          if (validatesWhenStated || validatesWhenDerived) {
+            validates = true;
+          }
         }
       }
-    }
 
-    if (validates) {
-      if (stated) {
-        this.assign(assignments, context);
-      }
-    }
+      if (validates) {
+        const judgement = this; ///
 
-    if (validates) {
-      context.debug(`...validated the '${judgementString}' judgement.`);
+        context.addJudgement(judgement)
+
+        context.debug(`...validated the '${judgementString}' judgement.`);
+      }
     }
 
     return validates;
@@ -120,13 +146,17 @@ export default define(class Judgement extends Element {
     return validatesWhenDerived;
   }
 
-  assign(assignments, context) {
+  assign(assignments, stated, context) {
     if (assignments === null) {
       return;
     }
 
+    if (!stated) {
+      return;
+    }
+
     const judgement = this, ///
-          judgementAssignment = judgementAssignmentFromJudgement(judgement),
+          judgementAssignment = judgementAssignmentFromJudgement(judgement, context),
           assignment = judgementAssignment; ///
 
     assignments.push(assignment);

package/src/element/metaType.js

@@ -48,7 +48,7 @@ export default define(class MetaType extends Element {
   static fromJSON(json, context) {
     const { name } = json,
           metaTypeName = name,  ///
-          metaType = findMetaTypeByMetaTypeName(metaTypeName);
+          metaType = context.findMetaTypeByMetaTypeName(metaTypeName);
 
     return metaType;
   }

package/src/element/metavariable.js

@@ -54,8 +54,9 @@ export default define(class Metavariable extends Element {
   }
 
   compare(metavariable) {
-    const name = metavariable.getName(),
-          comparesToMetavariable = (this.name === name);
+    const metavariableName = metavariable.getName(),
+          comparesToMetavariableName = this.compareMetavariableName(metavariableName),
+          comparesToMetavariable = comparesToMetavariableName;  ///
 
     return comparesToMetavariable;
   }
@@ -69,6 +70,18 @@ export default define(class Metavariable extends Element {
     return comparesToMetavariableName;
   }
 
+  matchMetavariableNode(metavariableNode) {
+    const metavariableNodeA = metavariableNode; ///
+
+    metavariableNode = this.getMetavariableNode();  ///
+
+    const metavariableNodeB = metavariableNode, ///
+          metavariableNodeAMatchesMetavariableNodeB = metavariableNodeA.match(metavariableNodeB),
+          metavariableNodeMatches = metavariableNodeAMatchesMetavariableNodeB;  ///
+
+    return metavariableNodeMatches;
+  }
+
   validate(context) {
     let validates = false;
 
@@ -306,7 +319,7 @@ export default define(class Metavariable extends Element {
 
     if (generalContextFilePath === specificContextFilePath) {
       const metavariableName = this.getMetavariableName(),  ///
-            frameMetavariableComparesToMetvariable = frame.matchMetavariableName(metavariableName);
+            frameMetavariableComparesToMetvariable = frame.compareMetavariableName(metavariableName);
 
       if (frameMetavariableComparesToMetvariable) {
         frameMetavariableUnifies = true;

package/src/element/propertyRelation.js

@@ -57,9 +57,9 @@ export default define(class PropertyRelation extends Element {
     context.trace(`Validating the '${termString}' term...`);
 
     termValidates = this.term.validate(context, () => {
-      const verifiesForwards = true;
+      const validatesForwards = true;
 
-      return verifiesForwards;
+      return validatesForwards;
     });
 
     if (termValidates) {