occam-verify-cli 1.0.448 → 1.0.472

package/src/element/equality.js

@@ -76,7 +76,7 @@ export default define(class Equality extends Element {
   verify(assignments, stated, context) {
     let verifies = false;
 
-    const equalityString = this.string; ///
+    const equalityString = this.getString(); ///
 
     context.trace(`Verifying the '${equalityString}' equality...`);
 
@@ -113,7 +113,7 @@ export default define(class Equality extends Element {
   verifyTerms(context) {
     let termsVerify;
 
-    const equalityString = this.string; ///
+    const equalityString = this.getString(); ///
 
     context.trace(`Verifying the '${equalityString}' equality's terms...`);
 
@@ -149,7 +149,7 @@ export default define(class Equality extends Element {
   verifyWhenStated(assignments, context) {
     let verifiesWhenStated;
 
-    const equalityString = this.string; ///
+    const equalityString = this.getString(); ///
 
     context.trace(`Verifying the '${equalityString}' stated equality...`);
 
@@ -165,7 +165,7 @@ export default define(class Equality extends Element {
   verifyWhenDerived(context) {
     let verifiesWhenDerived;
 
-    const equalityString = this.string; ///
+    const equalityString = this.getString(); ///
 
     context.trace(`Verifying the '${equalityString}' derived equality...`);
 

package/src/element/equivalence.js

@@ -5,10 +5,11 @@ import { arrayUtilities } from "necessary";
 import Element from "../element";
 
 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 { equalivanceFromEquivalenceNode } from "../utilities/element";
+import { equivalenceFromEquivalenceNode } from "../utilities/element";
 
 const { compress } = arrayUtilities;
 
@@ -22,40 +23,6 @@ export default define(class Equivalence extends Element {
     return this.terms;
   }
 
-  addTerm(term, context) {
-    const termString = term.getString(),
-          equivalenceString = this.asString(); ///
-
-    context.trace(`Adding the '${termString}' term to the '${equivalenceString}' equivalence...`);
-
-    const termA = term, ///
-          termPresent = this.someTerm((term) => {
-            const termB = term, ///
-                  termAEqualToTermB = termA.isEqualTo(termB);
-
-            if (termAEqualToTermB) {
-              return true;
-            }
-          });
-
-    if (!termPresent) {
-      this.terms.push(term);
-
-      const termsString = termsStringFromTerms(this.terms),
-            string = termsString,  ///
-            equalivanceNode = instantiateEquivalence(string, context),
-            equalivance = equalivanceFromEquivalenceNode(equalivanceNode, context);
-
-      this.node = equalivance.getNode();
-
-      this.string = equalivance.getString();
-
-      const equivalenceString = this.string; ///
-
-      context.debug(`...added the '${termString}' term to the '${equivalenceString}' equivalence.`);
-    }
-  }
-
   getType() {
     const type = this.terms.reduce((type, term) => {
       const termType = term.getType();
@@ -76,6 +43,89 @@ export default define(class Equivalence extends Element {
     return type;
   }
 
+  getGroundedTerms(definedVariables, groundedTerms, context) {
+    this.terms.forEach((term) => {
+      const termGrounded = term.isGrounded(definedVariables, context);
+
+      if (termGrounded) {
+        const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
+          const groundedTermNode = groundedTerm.getNode(),
+                groundedTermNodeMatches = term.matchNode(groundedTermNode);
+
+          if (groundedTermNodeMatches) {
+            return true;
+          }
+        })
+
+        if (!termMatchesGroundedTerm) {
+          const groundedTerm = term;
+
+          groundedTerms.push(groundedTerm);
+        }
+      }
+    });
+  }
+
+  getInitiallyGroundedTerms(context) {
+    const initiallyGroundedTerms = this.terms.reduce((initiallyGroundedTerms, term) => {
+      const termInitiallyGrounded = term.isInitiallyGrounded(context);
+
+      if (termInitiallyGrounded) {
+        const initiallyGroundedTerm = term; ///
+
+        initiallyGroundedTerms.push(initiallyGroundedTerm);
+      }
+
+      return initiallyGroundedTerms;
+    }, []);
+
+    return initiallyGroundedTerms;
+  }
+
+  getImplicitlyGroundedTerms(definedVariables, context) {
+    const implicitlyGroundedTerms = this.terms.reduce((implicitlyGroundedTerms, term) => {
+      const termImplicitlyGrounded = term.isImplicitlyGrounded(definedVariables, context);
+
+      if (termImplicitlyGrounded) {
+        const implicitlyGroundedTerm = term; ///
+
+        implicitlyGroundedTerms.push(implicitlyGroundedTerm);
+      }
+
+      return implicitlyGroundedTerms;
+    }, []);
+
+    return implicitlyGroundedTerms;
+  }
+
+  isDisjointFrom(equivalence) {
+    const disjointFrom = equivalence.everyTerm((term) => {
+      const comparesToTerm = this.compareTerm(term);
+
+      if (!comparesToTerm) {
+        return true;
+      }
+    });
+
+    return disjointFrom;
+  }
+
+  isInitiallyGrounded(context) {
+    const initiallyGroundedTerms = this.getInitiallyGroundedTerms(context),
+          initiallyGroundedTermsLength = initiallyGroundedTerms.length,
+          initiallyGrounded = (initiallyGroundedTermsLength > 0);
+
+    return initiallyGrounded;
+  }
+
+  isImplicitlyGrounded(definedVariables, context) {
+    const implicitlyGroundedTerms = this.getImplicitlyGroundedTerms(definedVariables, context),
+          implicitlyGroundedTermsLength = implicitlyGroundedTerms.length,
+          implicitlyGrounded = (implicitlyGroundedTermsLength > 0);
+
+    return implicitlyGrounded;
+  }
+
   compareTerm(term) {
     const termA = term, ///
           comparesToTerm = this.someTerm((term) => {
@@ -135,41 +185,6 @@ export default define(class Equivalence extends Element {
     return variableNodeMatches;
   }
 
-  isDisjointFrom(equivalence) {
-    const disjointFrom = equivalence.everyTerm((term) => {
-      const comparesToTerm = this.compareTerm(term);
-
-      if (!comparesToTerm) {
-        return true;
-      }
-    });
-
-    return disjointFrom;
-  }
-
-  mergedWith(equivalence) {
-    const equivalenceA = this,
-          equivalenceB = equivalence, ///
-          equivalenceATerms = equivalenceA.getTerms(),
-          equivalenceTermsB = equivalenceB.getTerms(),
-          terms = [
-            ...equivalenceATerms,
-            ...equivalenceTermsB
-          ];
-
-    compress(terms, (termA, termB) => {
-      const termAEqualToTermB = termA.isEqualTo(termB);
-
-      if (!termAEqualToTermB) {
-        return true;
-      }
-    });
-
-    equivalence = new Equivalence(terms);
-
-    return equivalence;
-  }
-
   someTerm(callback) { return this.terms.some(callback); }
 
   everyTerm(callback) { return this.terms.every(callback); }
@@ -189,84 +204,49 @@ export default define(class Equivalence extends Element {
     return result;
   }
 
-  getGroundedTerms(definedVariables, groundedTerms, context) {
-    this.terms.forEach((term) => {
-      const termGrounded = term.isGrounded(definedVariables, context);
+  combineTerms(terms) {
+    const combinedTerms = [
+      ...this.terms,
+      ...terms
+    ];
 
-      if (termGrounded) {
-        const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
-          const groundedTermNode = groundedTerm.getNode(),
-                groundedTermNodeMatches = term.matchNode(groundedTermNode);
+    compress(combinedTerms, (combinedTermA, combinedTermB) => {
+      const combinedTermAEqualToCombinedTermB = combinedTermA.isEqualTo(combinedTermB);
 
-          if (groundedTermNodeMatches) {
-            return true;
-          }
-        })
-
-        if (!termMatchesGroundedTerm) {
-          const groundedTerm = term;
-
-          groundedTerms.push(groundedTerm);
-        }
+      if (!combinedTermAEqualToCombinedTermB) {
+        return true;
       }
     });
-  }
-
-  isInitiallyGrounded(context) {
-    const initiallyGroundedTerms = this.getInitiallyGroundedTerms(context),
-          initiallyGroundedTermsLength = initiallyGroundedTerms.length,
-          initiallyGrounded = (initiallyGroundedTermsLength > 0);
 
-    return initiallyGrounded;
+    return combinedTerms;
   }
 
-  isImplicitlyGrounded(definedVariables, context) {
-    const implicitlyGroundedTerms = this.getImplicitlyGroundedTerms(definedVariables, context),
-          implicitlyGroundedTermsLength = implicitlyGroundedTerms.length,
-          implicitlyGrounded = (implicitlyGroundedTermsLength > 0);
-
-    return implicitlyGrounded;
-  }
-
-  getInitiallyGroundedTerms(context) {
-    const initiallyGroundedTerms = this.terms.reduce((initiallyGroundedTerms, term) => {
-      const termInitiallyGrounded = term.isInitiallyGrounded(context);
-
-      if (termInitiallyGrounded) {
-        const initiallyGroundedTerm = term; ///
-
-        initiallyGroundedTerms.push(initiallyGroundedTerm);
-      }
+  mergedWith(equivalence, context) {
+    const terms = equivalence.getTerms(),
+          combinedTerms = this.combineTerms(terms);
 
-      return initiallyGroundedTerms;
-    }, []);
+    return literally((context) => {
+      const terms = combinedTerms,  ///
+            termsString = termsStringFromTerms(terms),
+            string = termsString,  ///
+            equivalenceNode = instantiateEquivalence(string, context),
+            equivalence = equivalenceFromEquivalenceNode(equivalenceNode, context);
 
-    return initiallyGroundedTerms;
+      return equivalence;
+    }, context);
   }
 
-  getImplicitlyGroundedTerms(definedVariables, context) {
-    const implicitlyGroundedTerms = this.terms.reduce((implicitlyGroundedTerms, term) => {
-      const termImplicitlyGrounded = term.isImplicitlyGrounded(definedVariables, context);
-
-      if (termImplicitlyGrounded) {
-        const implicitlyGroundedTerm = term; ///
-
-        implicitlyGroundedTerms.push(implicitlyGroundedTerm);
-      }
-
-      return implicitlyGroundedTerms;
-    }, []);
-
-    return implicitlyGroundedTerms;
-  }
+  static name = "Equivalence";
 
   static fromEquality(equality, context) {
-    const terms = equality.getTerms(),
-          termsString = termsStringFromTerms(terms),
-          string = termsString,  ///
-          equalivanceNode = instantiateEquivalence(string, context),
-          equalivance = equalivanceFromEquivalenceNode(equalivanceNode, context);
+    return literally((context) => {
+      const terms = equality.getTerms(),
+            termsString = termsStringFromTerms(terms),
+            string = termsString,  ///
+            equivalenceNode = instantiateEquivalence(string, context),
+            equivalence = equivalenceFromEquivalenceNode(equivalenceNode, context);
 
-    return equalivance;
+      return equivalence;
+    }, context);
   }
 });

package/src/element/equivalences.js

@@ -73,18 +73,18 @@ export default define(class Equivalences extends Element {
     return equivalence;
   }
 
-  mergedWith(equivalences) {
+  mergedWith(equivalences, context) {
     let  mergedEquivalences = this.clone(); ///
 
     equivalences.forEachEquivalence((equivalence) => {
-      mergedEquivalences = mergedEquivalences.mergedWithEquivalence(equivalence);
+      mergedEquivalences = mergedEquivalences.mergedWithEquivalence(equivalence, context);
     });
 
     return mergedEquivalences;
   }
 
-  mergedWithEquivalence(equivalence) {
-    const equivalences = Equivalences.fromNothing();
+  mergedWithEquivalence(equivalence, context) {
+    const equivalences = Equivalences.fromNothing(context);
 
     let mergedEquivalence = equivalence; ///
 
@@ -94,7 +94,7 @@ export default define(class Equivalences extends Element {
       if (mergedEquivalenceDisjointFromEquivalence) {
         equivalences.addEquivalence(equivalence);
       } else {
-        mergedEquivalence = mergedEquivalence.mergedWith(equivalence);
+        mergedEquivalence = mergedEquivalence.mergedWith(equivalence, context);
       }
     });
 
@@ -139,9 +139,9 @@ export default define(class Equivalences extends Element {
         initiallyGroundedEquivalences,
         implicitlyGroundedEquivalences;
 
-    remainingEquivalences =Equivalences.fromNothing();
+    remainingEquivalences =Equivalences.fromNothing(context);
 
-    initiallyGroundedEquivalences = Equivalences.fromNothing();
+    initiallyGroundedEquivalences = Equivalences.fromNothing(context);
 
     equivalences.separateInitiallyGroundedEquivalences(remainingEquivalences, initiallyGroundedEquivalences, context);
 
@@ -190,6 +190,8 @@ export default define(class Equivalences extends Element {
     return equivalences;
   }
 
+  static name = "Equivalences";
+
   static fromNothing(context) {
     const string = EMPTY_STRING,
           node = null,

package/src/element/error.js

@@ -12,9 +12,11 @@ export default define(class Error extends Element {
   verify() {
     let verifies = false;
 
-    const errorString = this.string;  ///
+    const node = this.getNode(),
+          context = this.getContext(),
+          errorString = this.getString();  ///
 
-    this.context.warning(`The '${errorString}' error cannot be verified.`, this.node);
+    context.warning(`The '${errorString}' error cannot be verified.`, node);
 
     return verifies;
   }

package/src/element/frame.js

@@ -6,8 +6,8 @@ import Element from "../element";
 import elements from "../elements";
 
 import { define } from "../elements";
-import { S, NOTHING } from "../constants";
 import { FRAME_META_TYPE_NAME } from "../metaTypeNames";
+import { assumptionsStringFromAssumptions } from "../utilities/string";
 
 const { first } = arrayUtilities;
 
@@ -53,18 +53,18 @@ export default define(class Frame extends Element {
   }
 
   getMetavariableName() {
-    let metavariableName = null;
-
-    const singular = this.isSingular();
-
-    if (singular) {
-      metavariableName = this.node.getMetavariableName();
-    }
+    const node = this.getNode(),
+          metavariableName = node.getMetavariableName();
 
     return metavariableName;
   }
 
-  isSingular() { return this.node.isSingular(); }
+  isSingular() {
+    const node = this.getNode(),
+          singular = node.isSingular();
+
+    return singular;
+  }
 
   isMetavariableEqualToMetavariable(metavariable, context) {
     let metavariableEqualToMetavariable;
@@ -72,8 +72,9 @@ export default define(class Frame extends Element {
     const singular = this.isSingular();
 
     if (singular) {
-      const metavariableA = metavariable, ///
-            singularMetavariableNode = this.node.getSingularMetavariableNode(),
+      const node = this.getNode(),
+            metavariableA = metavariable, ///
+            singularMetavariableNode = node.getSingularMetavariableNode(),
             metavariableName = singularMetavariableNode.getMetavariableName();
 
       metavariable = context.findMetavariableByMetavariableName(metavariableName)
@@ -87,6 +88,26 @@ export default define(class Frame extends Element {
     return metavariableEqualToMetavariable;
   }
 
+  compareParameter(parameter) {
+    let comparesToParamter = false;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      const parameterName = parameter.getName();
+
+      if (parameterName !== null) {
+        const metavariableName = this.getMetavariableName();
+
+        if (parameterName === metavariableName) {
+          comparesToParamter = true;
+        }
+      }
+    }
+
+    return comparesToParamter;
+  }
+
   compareSubstitution(substitution, context) {
     let comparesToSubstitution = false;
 
@@ -115,7 +136,7 @@ export default define(class Frame extends Element {
   compareSubstitutions(substitutions, context) {
     let comparesToSubstitutions;
 
-    const frameString = this.string,  ///
+    const frameString = this.getString(),  ///
           substitutionsString = substitutions.asString();
 
     context.trace(`Comparing the '${frameString}' frame to the '${substitutionsString}' substitutions...`);
@@ -135,117 +156,111 @@ export default define(class Frame extends Element {
     return comparesToSubstitutions;
   }
 
-  verify(assignments, stated, context) {
-    let verifies = false;
+  validate(assignments, stated, context) {
+    let validates = false;
 
-    const frameString = this.string;  ///
+    const frameString = this.getString();  ///
 
-    context.trace(`Verifying the '${frameString}' frame...`);
+    context.trace(`Validating the '${frameString}' frame...`);
 
-    const assumptionsVerify = this.verifyAssumptions(assignments, stated, context);
+    const assumptionsValidate = this.validateAssumptions(assignments, stated, context);
 
-    if (assumptionsVerify) {
-      let verifiesWhenStated = false,
-          verifiesWhenDerived = false;
+    if (assumptionsValidate) {
+      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) {
       const frame = this; ///
 
       context.addFrame(frame);
 
-      context.debug(`...verified the '${frameString}' frame.`);
+      context.debug(`...validated the '${frameString}' frame.`);
     }
 
-    return verifies;
+    return validates;
   }
 
-  verifyWhenStated(assignments, context) {
-    let verifiesWhenStated = false;
+  validateWhenStated(assignments, context) {
+    let validatesWhenStated = false;
 
-    const frameString = this.string;  ///
+    const frameString = this.getString();  ///
 
-    context.trace(`Verifying the '${frameString}' stated frame...`);
+    context.trace(`Validating the '${frameString}' stated frame...`);
 
     const singular = this.isSingular();
 
-    if (!singular) {
-      context.trace(`The '${frameString}' stated frame must be singular.`);
+    if (singular) {
+      validatesWhenStated = true;
     } else {
-      verifiesWhenStated = true;
+      context.trace(`The '${frameString}' stated frame must be singular.`);
     }
 
-    if (verifiesWhenStated) {
-      context.debug(`...verified the '${frameString}' stated frame.`);
+    if (validatesWhenStated) {
+      context.debug(`...validated the '${frameString}' stated frame.`);
     }
 
-    return verifiesWhenStated;
+    return validatesWhenStated;
   }
 
-  verifyWhenDerived(context) {
-    let verifiesWhenDerived;
+  validateWhenDerived(context) {
+    let validatesWhenDerived;
 
-    const frameString = this.string;  ///
+    const frameString = this.getString();  ///
 
     context.trace(`Verifying the '${frameString}' derived frame...`);
 
-    verifiesWhenDerived = true;
+    validatesWhenDerived = true;
 
-    if (verifiesWhenDerived) {
+    if (validatesWhenDerived) {
       context.debug(`...verified the '${frameString}' derived frame.`);
     }
 
-    return verifiesWhenDerived;
+    return validatesWhenDerived;
   }
 
-  verifyAssumptions(assignments, stated, context) {
-    let assumptionsVerify = true;  ///
-
-    const length = this.getLength();
+  validateAssumptions(assignments, stated, context) {
+    let assumptionsValidate;
 
-    if (length > 0) {
-      const sOrNothing = (length > 1) ?
-                           S :
-                             NOTHING,
-            assumptionsString = assumptionsStringFromAssumptions(this.assumptions);
+    const frameString = this.getString(), ///
+          assumptionsString = assumptionsStringFromAssumptions(this.assumptions);
 
-      context.trace(`Verifying the '${assumptionsString}' assumption${sOrNothing}...`);
+    context.trace(`Validating the '${assumptionsString}' assumptions of the '${frameString}' frame...`);
 
-      stated = true;  ///
+    stated = true;  ///
 
-      assignments = null; ///
+    assignments = null; ///
 
-      assumptionsVerify = this.assumptions.every((assumption) => {
-        const assumptionVerifies = assumption.verify(assignments, stated, context);
+    assumptionsValidate = this.assumptions.every((assumption) => {
+      const assumptionVerifies = assumption.validate(assignments, stated, context);
 
-        return assumptionVerifies;
-      });
+      return assumptionVerifies;
+    });
 
-      if (assumptionsVerify) {
-        context.debug(`...verified the '${assumptionsString}' assumption${sOrNothing}.`);
-      }
+    if (assumptionsValidate) {
+      context.debug(`...validated the '${assumptionsString}' assumptions of the '${frameString}' frame.`);
     }
 
-    return assumptionsVerify;
+    return assumptionsValidate;
   }
 
   validateGivenMetaType(metaType, assignments, stated, context) {
     let validatesGivenMetaType = false;
 
-    const frameString = this.string,  ///
+    const frameString = this.getString(),  ///
           metaTypeString = metaType.getString();
 
-    context.trace(`Validatin the '${frameString}' frame given the '${metaTypeString}' meta-type...`);
+    context.trace(`Validating the '${frameString}' frame given the '${metaTypeString}' meta-type...`);
 
     const metaTypeName = metaType.getName();
 

package/src/element/hypothesis.js

@@ -20,7 +20,7 @@ export default define(class Hypothesis extends Element {
   verify(context) {
     let verifies = false;
 
-    const hypothesisString = this.string; ///
+    const hypothesisString = this.getString(); ///
 
     context.trace(`Verifying the '${hypothesisString}' hypothesis...`, this.node);