occam-verify-cli 1.0.438 → 1.0.448

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

@@ -1,7 +1,6 @@
 "use strict";
 
 import Element from "../element";
-import elements from "../elements";
 import assignAssignments from "../process/assign";
 
 import { define } from "../elements";
@@ -30,17 +29,15 @@ 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) {
-          const { Step } = elements,
-                step = Step.fromStatement(this.statement, context),
-                stepOrSubproof = step;  ///
+          const subproofOrProofAssertion = this;  ///
 
-          context.addStepOrSubproof(stepOrSubproof);
+          context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
           verifies = true;
         }
@@ -56,26 +53,27 @@ export default define(class Hypothesis extends Element {
     return verifies;
   }
 
-  isEqualToStep(step, context) {
-    let equalToStep = false;
+  compareProofAssertion(proofAssertion, context) {
+    let comparesToProofAssertion = false;
 
-    const stepString = step.getString(),
-          hypothesisString = this.string; ///
+    const node = this.getNode(),
+          hypothesisString = this.getString(), ///
+          proofAssertionString = proofAssertion.getString();
 
-    context.trace(`Is the '${hypothesisString}' hypothesis equal to the '${stepString}' step...`, this.node);
+    context.trace(`Is the '${hypothesisString}' hypothesis equal to the '${proofAssertionString}' proof assertion...`, node);
 
-    const stepStatement = step.getStatement(),
-          statementEqualToStepStatement = this.statement.isEqualTo(stepStatement);
+    const proofAssertionStatement = proofAssertion.getStatement(),
+          statementEqualToStepStatement = this.statement.isEqualTo(proofAssertionStatement);
 
     if (statementEqualToStepStatement) {
-      equalToStep = true;
+      comparesToProofAssertion = true;
     }
 
-    if (equalToStep) {
-      context.trace(`...the '${hypothesisString}' hypothesis is equal to the '${stepString}' step.`, this.node);
+    if (comparesToProofAssertion) {
+      context.trace(`...the '${hypothesisString}' hypothesis is equal to the '${proofAssertionString}' proof assertion.`, node);
     }
 
-    return equalToStep;
+    return comparesToProofAssertion;
   }
 
   toJSON() {

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

@@ -20,16 +20,16 @@ export default define(class Label extends Element {
 
   getMetavariableNode() { return this.metavariable.getNode(); }
 
-  matchMetavariableName(metavariableName) { return this.metavariable.matchMetavariableName(metavariableName); }
+  compareMetavariableName(metavariableName) { return this.metavariable.compareMetavariableName(metavariableName); }
 
   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;
   }
 
   verify(nameOnly) {

package/src/element/metaLemmaMetatheorem.js

@@ -1,10 +1,8 @@
 "use strict";
 
 import Element from "../element";
-import elements from "../elements";
 import LocalContext from "../context/local";
 
-import { proofFromProofNode, deductionFromDeductionNode, suppositionsFromSuppositionNodes } from "./axiomLemmaTheoremConjecture";
 import { labelFromJSON,
          labelToLabelJSON,
          deductionFromJSON,
@@ -47,11 +45,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() {
@@ -149,72 +148,9 @@ export default class MetaLemmaMetatheorem extends Element {
           substitutions = substitutionsFromJSON(json, context),
           node = null,
           proof = null,
-          string = stringFromLabelASuppositionsAndDeduction(label, suppositions, deduction),
+          string = metaLemmaMetatheoremStringFromLabelASuppositionsAndDeduction(label, suppositions, deduction),
           metaLemmaMetatheorem = new Class(context, string, node, label, suppositions, deduction, proof, substitutions);
 
     return metaLemmaMetatheorem;
   }
-
-  static fromNode(Class, node, context) {
-    const { Substitutions } = elements,
-          topLevelAssertionNode = node, ///
-          proofNode = topLevelAssertionNode.getProofNode(),
-          labelNode = topLevelAssertionNode.getLabelNode(),
-          deductionNode = topLevelAssertionNode.getDeductionNode(),
-          suppositionNodes = topLevelAssertionNode.getSuppositionNodes(),
-          proof = proofFromProofNode(proofNode, context),
-          label = labelFromLabelNode(labelNode, context),
-          deduction = deductionFromDeductionNode(deductionNode, context),
-          suppositions = suppositionsFromSuppositionNodes(suppositionNodes, context),
-          substitutions = Substitutions.fromNothing(),
-          string = stringFromLabelASuppositionsAndDeduction(label, suppositions, deduction),
-          metaLemmaMetatheorem = new Class(context, string, node, label, suppositions, deduction, proof, substitutions);
-
-    return metaLemmaMetatheorem;
-  }
-}
-
-function labelFromLabelNode(labelNode, context) {
-  let label = null;
-
-  const { Label } = elements;
-
-  if (labelNode !== null) {
-    label = Label.fromLabelNode(labelNode, context);
-  }
-
-  return label;
-}
-
-function labelStringFromLabel(label) {
-  const labelsString = (label !== null) ?
-                          label.getString() :
-                            null;
-
-  return labelsString;
-}
-
-function suppositionsStringFromSuppositions(suppositions) {
-  const suppositionsString = suppositions.reduce((suppositionsString, supposition) => {
-    const suppositionString = supposition.getString();
-
-    suppositionsString = (suppositionsString !== null) ?
-                          `${suppositionsString}, ${suppositionString}` :
-                            suppositionString;  ///
-
-    return suppositionsString;
-  }, null);
-
-  return suppositionsString;
-}
-
-function stringFromLabelASuppositionsAndDeduction(label, suppositions, deduction) {
-  const suppositionsString = suppositionsStringFromSuppositions(suppositions),
-        deductionString = deduction.getString(),
-        labelString = labelStringFromLabel(label),
-        string = (labelString === null) ?
-                    deductionString : ///
-                     `${labelString} :: [${suppositionsString}] ... ${deductionString}`;
-
-  return string;
 }

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,49 @@ 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 nameMetavariableName = (this.name === metavariableName),
+          comparesToMetavariableName = nameMetavariableName;  ///
 
-    return metavariableNameMatches;
+    return comparesToMetavariableName;
   }
 
   isMetaTypeEqualTo(metaType) { return this.metaType.isEqualTo(metaType); }
 
-  verify(context) {
-    let verifies;
+  validate(context) {
+    let validates = false;
 
-    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; ///
+    if (metavariablePresent) {
+      validates = true;
+    }
 
-    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 +90,23 @@ export default define(class Metavariable extends Element {
     if (metavariable !== null) {
       const metavariableMetaTypeEqualToMetaType = metavariable.isMetaTypeEqualTo(metaType);
 
-      verifiesGivenMetaType = metavariableMetaTypeEqualToMetaType;  ///
+      if (metavariableMetaTypeEqualToMetaType) {
+        validatesGivenMetaType = true;
+      }
     }
 
-    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 +150,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 +198,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 +268,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 +308,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 +348,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 +379,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;
             }
           });