occam-verify-cli 1.0.437 → 1.0.444

package/src/element/equivalence.js

@@ -26,7 +26,7 @@ export default define(class Equivalence extends Element {
     const termString = term.getString(),
           equivalenceString = this.asString(); ///
 
-    context.trace(`Adding the '${termString}' term to the '${equivalenceString}' equivalence....`);
+    context.trace(`Adding the '${termString}' term to the '${equivalenceString}' equivalence...`);
 
     const termA = term, ///
           termPresent = this.someTerm((term) => {
@@ -76,9 +76,9 @@ export default define(class Equivalence extends Element {
     return type;
   }
 
-  equateTerm(term) {
+  compareTerm(term) {
     const termA = term, ///
-          termEquates = this.someTerm((term) => {
+          comparesToTerm = this.someTerm((term) => {
             const termB = term, ///
                   termAEqualToTermB = termA.isEqualTo(termB);
 
@@ -87,14 +87,14 @@ export default define(class Equivalence extends Element {
             }
           });
 
-    return termEquates;
+    return comparesToTerm;
   }
 
   matchTermNode(termNode) {
     termNode = stripBracketsFromTermNode(termNode); ///
 
     const termNodeMatches = this.someTerm((term) => {
-      const termNodeMatches = term.matchTermNode(termNode);
+      const termNodeMatches = term.matchNode(termNode);
 
       if (termNodeMatches) {
         return true;
@@ -137,9 +137,9 @@ export default define(class Equivalence extends Element {
 
   isDisjointFrom(equivalence) {
     const disjointFrom = equivalence.everyTerm((term) => {
-      const termEquates = this.equateTerm(term);
+      const comparesToTerm = this.compareTerm(term);
 
-      if (!termEquates) {
+      if (!comparesToTerm) {
         return true;
       }
     });
@@ -196,7 +196,7 @@ export default define(class Equivalence extends Element {
       if (termGrounded) {
         const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
           const groundedTermNode = groundedTerm.getNode(),
-                groundedTermNodeMatches = term.matchTermNode(groundedTermNode);
+                groundedTermNodeMatches = term.matchNode(groundedTermNode);
 
           if (groundedTermNodeMatches) {
             return true;

package/src/element/equivalences.js

@@ -51,9 +51,9 @@ export default define(class Equivalences extends Element {
 
   findEquivalenceByTerm(term) {
     const equivalence = this.array.find((equivalence) => {
-      const termEquates = equivalence.equateTerm(term);
+      const equivalenceComparesToTerm = equivalence.compareTerm(term);
 
-      if (termEquates) {
+      if (equivalenceComparesToTerm) {
         return true;
       }
     }) || null;
@@ -63,9 +63,9 @@ export default define(class Equivalences extends Element {
 
   findEquivalenceByTermNodes(termNodes) {
     const equivalence = this.array.find((equivalence) => {
-      const equivalenceMatchesTerms = equivalence.matchTermNodes(termNodes);
+      const termNodeMatches = equivalence.matchTermNodes(termNodes);
 
-      if (equivalenceMatchesTerms) {
+      if (termNodeMatches) {
         return true;
       }
     }) || null;

package/src/element/frame.js

@@ -87,54 +87,52 @@ export default define(class Frame extends Element {
     return metavariableEqualToMetavariable;
   }
 
-  matchFrameNode(frameNode) { return this.node.match(frameNode); }
+  compareSubstitution(substitution, context) {
+    let comparesToSubstitution = false;
 
-  matchSubstitution(substitution, context) {
-    let substitutionMatches = false;
-
-    const frameString = this.string,  ///
+    const frameString = this.getString(),  ///
           substitutionString = substitution.getString();
 
-    context.trace(`Matching the '${substitutionString}' substitution against the '${frameString}' frame...`);
+    context.trace(`Comparing the '${frameString}' frame to the '${substitutionString}' substitution...`);
 
-    if (!substitutionMatches) {
-      substitutionMatches = this.assumptions.some((assumption) => {
-        const substitutionMatchesAssumption = assumption.matchSubstitution(substitution, context);
+    if (!comparesToSubstitution) {
+      comparesToSubstitution = this.assumptions.some((assumption) => {
+        const assumptionComparesToSubstitution = assumption.compareSubstitution(substitution, context);
 
-        if (substitutionMatchesAssumption) {
+        if (assumptionComparesToSubstitution) {
           return true;
         }
       });
     }
 
-    if (substitutionMatches) {
-      context.debug(`...matched the '${substitutionString}' substitutions against the '${frameString}' frame.`);
+    if (comparesToSubstitution) {
+      context.debug(`...compared the the '${frameString}' frame to the '${substitutionString}' substitutions.`);
     }
 
-    return substitutionMatches;
+    return comparesToSubstitution;
   }
 
-  matchSubstitutions(substitutions, context) {
-    let substitutionsMatch;
+  compareSubstitutions(substitutions, context) {
+    let comparesToSubstitutions;
 
     const frameString = this.string,  ///
           substitutionsString = substitutions.asString();
 
-    context.trace(`Matching the '${substitutionsString}' substitutions against the '${frameString}' frame...`);
+    context.trace(`Comparing the '${frameString}' frame to the '${substitutionsString}' substitutions...`);
 
-    substitutionsMatch = substitutions.everySubstitution((substitution) => {
-      const substitutionMatches = this.matchSubstitution(substitution, context);
+    comparesToSubstitutions = substitutions.everySubstitution((substitution) => {
+      const compaaresToSubstitution = this.compareSubstitution(substitution, context);
 
-      if (substitutionMatches) {
+      if (compaaresToSubstitution) {
         return true;
       }
     });
 
-    if (substitutionsMatch) {
-      context.debug(`...matched the '${substitutionsString}' substitutions against the '${frameString}' frame.`);
+    if (comparesToSubstitutions) {
+      context.debug(`...compared the '${frameString}' frame to the '${substitutionsString}' substitutions.`);
     }
 
-    return substitutionsMatch;
+    return comparesToSubstitutions;
   }
 
   verify(assignments, stated, context) {
@@ -241,27 +239,27 @@ export default define(class Frame extends Element {
     return assumptionsVerify;
   }
 
-  verifyGivenMetaType(metaType, assignments, stated, context) {
-    let verifiesGivenMetaType = false;
+  validateGivenMetaType(metaType, assignments, stated, context) {
+    let validatesGivenMetaType = false;
 
     const frameString = this.string,  ///
           metaTypeString = metaType.getString();
 
-    context.trace(`Verifying the '${frameString}' frame given the '${metaTypeString}' meta-type...`);
+    context.trace(`Validatin the '${frameString}' frame given the '${metaTypeString}' meta-type...`);
 
     const metaTypeName = metaType.getName();
 
     if (metaTypeName === FRAME_META_TYPE_NAME) {
-      const verifies = this.verify(assignments, stated, context)
+      const validates = this.validate(assignments, stated, context)
 
-      verifiesGivenMetaType = verifies; ///
+      validatesGivenMetaType = validates; ///
     }
 
-    if (verifiesGivenMetaType) {
-      context.debug(`...verified the '${frameString}' frame given the '${metaTypeString}' meta-type.`);
+    if (validatesGivenMetaType) {
+      context.debug(`...validated the '${frameString}' frame given the '${metaTypeString}' meta-type.`);
     }
 
-    return verifiesGivenMetaType;
+    return validatesGivenMetaType;
   }
 
   toJSON() {

package/src/element/hypothesis.js

@@ -30,9 +30,9 @@ export default define(class Hypothesis extends Element {
     } else if (this.statement !== null) {
       const stated = true,
             assignments = [],
-            statementVerifies = this.statement.verify(assignments, stated, context);
+            statementValidates = this.statement.validate(assignments, stated, context);
 
-      if (statementVerifies) {
+      if (statementValidates) {
         const assignmentsAssigned = assignAssignments(assignments, context);
 
         if (assignmentsAssigned) {

package/src/element/judgement.js

@@ -108,7 +108,7 @@ export default define(class Judgement extends Element {
   }
 
   verifyWhenDerived(context) {
-    let verifiesWhenDerived;
+    let verifiesWhenDerived = false;
 
     const judgementString = this.string;  ///
 
@@ -118,9 +118,12 @@ export default define(class Judgement extends Element {
           reference = referenceFromMetavariable(metavariable, context),
           metaLemmaMetatheorem = context.findMetaLemmaMetatheoremByReference(reference),
           substitutions = metaLemmaMetatheorem.getSubstitutions(),
-          substitutionsMatch = this.frame.matchSubstitutions(substitutions, context);
+          frameComparesToSubstitutions = this.frame.compareSubstitutions(substitutions, context);
 
-    verifiesWhenDerived = substitutionsMatch;
+    if (frameComparesToSubstitutions) {
+      verifiesWhenDerived = true;
+
+    }
 
     if (verifiesWhenDerived) {
       context.debug(`...verified the '${judgementString}' derived judgement.`);

package/src/element/label.js

@@ -16,57 +16,50 @@ export default define(class Label extends Element {
     return this.metavariable;
   }
 
-  getMetavariableName() {
-    const metavariableName = this.metavariable.getName();
+  getMetavariableName() { return this.metavariable.getName(); }
 
-    return metavariableName;
-  }
+  getMetavariableNode() { return this.metavariable.getNode(); }
 
-  getMetavariableNode() {
-    const metavariableNode = this.metavariable.getNode();
+  compareMetavariableName(metavariableName) { return this.metavariable.compareMetavariableName(metavariableName); }
 
-    return metavariableNode;
-  }
+  isMetavariableEqualToMetavariable(metavariable) { return this.metavariable.isEqualTo(metavariable); }
 
-  matchReference(reference) {
+  compareReference(reference) {
     const metavariable = reference.getMetavariable(),
           metavariableEqualToMetavariable = this.isMetavariableEqualToMetavariable(metavariable),
-          referenceMatches = metavariableEqualToMetavariable; ///
+          comparesToReference = metavariableEqualToMetavariable; ///
 
-    return referenceMatches;
+    return comparesToReference;
   }
 
-  isMetavariableEqualToMetavariable(metavariable) { return this.metavariable.isEqualTo(metavariable); }
-
-  matchMetavariableName(metavariableName) { return this.metavariable.matchMetavariableName(metavariableName); }
-
   verify(nameOnly) {
     let verifies = false;
 
-    const labelString = this.getString(); ///
+    const context = this.getContext(),
+          labelString = this.getString(); ///
 
-    this.context.trace(`Verifying the '${labelString}' label...`);
+    context.trace(`Verifying the '${labelString}' label...`);
 
     let labelPresent;
 
     if (nameOnly) {
       const metavariableName = this.getMetavariableName();
 
-      labelPresent = this.context.isLabelPresentByMetavariableName(metavariableName);
+      labelPresent = context.isLabelPresentByMetavariableName(metavariableName);
     } else {
       const metavariable = this.getMetavariable();
 
-      labelPresent = this.context.isLabelPresentByMetavariable(metavariable);
+      labelPresent = context.isLabelPresentByMetavariable(metavariable);
     }
 
     if (labelPresent) {
-      this.context.debug(`The '${labelString}' label is already present.`);
+      context.debug(`The '${labelString}' label is already present.`);
     } else {
       verifies = true;
     }
 
     if (verifies) {
-      this.context.debug(`...verified the '${labelString}' label.`);
+      context.debug(`...verified the '${labelString}' label.`);
     }
 
     return verifies;

package/src/element/metaLemmaMetatheorem.js

@@ -47,11 +47,12 @@ export default class MetaLemmaMetatheorem extends Element {
 
   getStatement() { return this.deduction.getStatement(); }
 
-  matchReference(reference) {
+  compareReference(reference) {
     const label = this.getLabel(),
-          referenceMatches = label.matchReference(reference);
+          labelComparesToRefference = label.compareReference(reference),
+          comparesToReference = labelComparesToRefference;  ///
 
-    return referenceMatches;
+    return comparesToReference;
   }
 
   verify() {

package/src/element/metaType.js

@@ -3,9 +3,8 @@
 import Element from "../element";
 
 import { define } from "../elements";
-import { FRAME_META_TYPE_NAME, REFERENCE_META_TYPE_NAME, STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 
-class MetaType extends Element {
+export default define(class MetaType extends Element {
   constructor(context, string, node, name) {
     super(context, string, node);
 
@@ -22,10 +21,10 @@ class MetaType extends Element {
     return equalTo;
   }
 
-  matchMetaTypeName(metaTypeName) {
-    const metaTypeNameMatches = (metaTypeName === this.name);
+  compareMetaTypeName(metaTypeName) {
+    const comparesToMetaTypeName = (metaTypeName === this.name);
 
-    return metaTypeNameMatches;
+    return comparesToMetaTypeName;
   }
 
   toJSON() {
@@ -46,48 +45,13 @@ class MetaType extends Element {
 
     return metaType;
   }
-}
 
-export default define(MetaType);
-
-class FrameMetaType extends MetaType {
-  static fromNothing() {
-    const context = null,
-          string = null,
-          node = null,
-          name = FRAME_META_TYPE_NAME,
-          frameMetaType = new FrameMetaType(context, string, node, name);
-
-    return frameMetaType;
-  }
-}
-
-class ReferenceMetaType extends MetaType {
-  static fromNothing() {
+  static fromName(name) {
     const context = null,
-          string = null,
+          string = name,
           node = null,
-          name = REFERENCE_META_TYPE_NAME,
-          referenceMetaType = new ReferenceMetaType(context, string, node, name);
-
-    return referenceMetaType;
-  }
-}
+          metaType = new MetaType(context, string, node, name);
 
-class StatementMetaType extends MetaType {
-  static fromNothing() {
-    const context = null,
-          string = null,
-          node = null,
-          name = STATEMENT_META_TYPE_NAME,
-          statementMetaType = new StatementMetaType(context, string, node, name);
-
-    return statementMetaType;
+    return metaType;
   }
-}
-
-export const frameMetaType = FrameMetaType.fromNothing();
-
-export const referenceMetaType = ReferenceMetaType.fromNothing();
-
-export const statementMetaType = StatementMetaType.fromNothing();
+});

package/src/element/metavariable.js

@@ -39,48 +39,46 @@ export default define(class Metavariable extends Element {
     this.metaType = metaType;
   }
 
-  matchParameter(parameter) {
-    const name = parameter.getName(),
-          nameMatches = (name === this.name),
-          parameterMatches = nameMatches; ///
+  isNameEqualTo(name) {
+    const nameEqualTo = (name === this.name);
 
-    return parameterMatches;
+    return nameEqualTo;
   }
 
-  matchMetavariableName(metavariableName) {
-    const metavariableNameMatches = (metavariableName === this.name);
+  compareMetavariableName(metavariableName) {
+    const comparesToMetavariableName = (metavariableName === this.name);
 
-    return metavariableNameMatches;
+    return comparesToMetavariableName;
   }
 
   isMetaTypeEqualTo(metaType) { return this.metaType.isEqualTo(metaType); }
 
-  verify(context) {
-    let verifies;
+  validate(context) {
+    let validates;
 
-    const metavariableString = this.string; ///
+    const metavariableString = this.getString(); ///
 
-    context.trace(`Verifying the '${metavariableString}' metavariable...`);
+    context.trace(`Validating the '${metavariableString}' metavariable...`);
 
     const metavariable = this, ///
           metavariablePresent = context.isMetavariablePresent(metavariable);
 
-    verifies = metavariablePresent; ///
+    validates = metavariablePresent; ///
 
-    if (verifies) {
-      context.debug(`...verified the '${metavariableString}' metavariable.`);
+    if (validates) {
+      context.debug(`...va;idated the '${metavariableString}' metavariable.`);
     }
 
-    return verifies;
+    return validates;
   }
 
-  verifyGivenMetaType(metaType, context) {
-    let verifiesGivenMetaType = false;
+  validateGivenMetaType(metaType, context) {
+    let validatesGivenMetaType = false;
 
-    const metavariableString = this.string,  ///
+    const metavariableString = this.getString(),  ///
           metaTypeString = metaType.getString();
 
-    context.trace(`Verifying the '${metavariableString}' metavariable given the '${metaTypeString}' meta-type...`);
+    context.trace(`Validating the '${metavariableString}' metavariable given the '${metaTypeString}' meta-type...`);
 
     let metavariable = this;  ///
 
@@ -89,21 +87,21 @@ export default define(class Metavariable extends Element {
     if (metavariable !== null) {
       const metavariableMetaTypeEqualToMetaType = metavariable.isMetaTypeEqualTo(metaType);
 
-      verifiesGivenMetaType = metavariableMetaTypeEqualToMetaType;  ///
+      validatesGivenMetaType = metavariableMetaTypeEqualToMetaType;  ///
     }
 
-    if (verifiesGivenMetaType) {
-      context.debug(`...verified the '${metavariableString}' metavariable given the '${metaTypeString}' meta-type.`);
+    if (validatesGivenMetaType) {
+      context.debug(`...validated the '${metavariableString}' metavariable given the '${metaTypeString}' meta-type.`);
     }
 
-    return verifiesGivenMetaType;
+    return validatesGivenMetaType;
   }
 
   unifyFrame(frame, substitutions, generalContext, specificContext) {
     let frameUnifies = false;
 
     const frameString = frame.getString(),
-          metavariableString = this.string; ///
+          metavariableString = this.getString(); ///
 
     specificContext.trace(`Unifying the '${frameString}' frame with the '${metavariableString}' metavariable...`);
 
@@ -147,7 +145,7 @@ export default define(class Metavariable extends Element {
     let statementUnifies = false;
 
     const statementString = statement.getString(),
-          metavariableString = this.string, ///
+          metavariableString = this.getString(), ///
           substitutionString = (substitution !== null) ?
                                   substitution.getString() :
                                     EMPTY_STRING;
@@ -195,7 +193,7 @@ export default define(class Metavariable extends Element {
     let referenceUnifies = false;
 
     const referenceString = reference.getString(),
-          metavariableString = this.string; ///
+          metavariableString = this.getString(); ///
 
     specificContext.trace(`Unifying the '${referenceString}' reference with the '${metavariableString}' metavariable...`);
 
@@ -265,7 +263,7 @@ export default define(class Metavariable extends Element {
 
     if (generalContextFilePath === specificContextFilePath) {
       const metavariable = this,
-            metavariableString = this.string, ///
+            metavariableString = this.getString(), ///
             frameMetavariableEqualToMetvariable = frame.isMetavariableEqualToMetavariable(metavariable, context);
 
       if (frameMetavariableEqualToMetvariable) {
@@ -305,7 +303,7 @@ export default define(class Metavariable extends Element {
 
     if (generalContextFilePath === specificContextFilePath) {
       const metavariable = this,  ///
-            metavariableString = this.string, ///
+            metavariableString = this.getString(), ///
             statementMetavariableEqualToMetvariable = statement.isMetavariableEqualToMetavariable(metavariable, context);
 
       if (statementMetavariableEqualToMetvariable) {
@@ -345,7 +343,7 @@ export default define(class Metavariable extends Element {
 
     if (generalContextFilePath === specificContextFilePath) {
       const metavariable = this,  ///
-            metavariableString = this.string, ///
+            metavariableString = this.getString(), ///
             referenceMetavariableEqualToMetvariable = reference.isMetavariableEqualToMetavariable(metavariable);
 
       if (referenceMetavariableEqualToMetvariable) {
@@ -376,7 +374,7 @@ export default define(class Metavariable extends Element {
           typeJSON = typeToTypeJSON(this.type),
           type = typeJSON,  ///
           metaType = metaTypeJSON,  ///
-          string = this.string, ///
+          string = this.getString(), ///
           json = {
             string,
             type,

package/src/element/parameter.js

@@ -20,9 +20,9 @@ export default define(class Parameter extends Element {
 
     const parameter = this, ///
           substitution = substitutions.findSubstitution((substitution) => {
-            const nameMatches = substitution.matchParameter(parameter);
+            const substitutionComparesToParamter = substitution.compareParameter(parameter);
 
-            if (nameMatches) {
+            if (substitutionComparesToParamter) {
               return true;
             }
           });