occam-verify-cli 1.0.437 → 1.0.444

package/src/element/premise.js

@@ -6,7 +6,6 @@ import TemporaryContext from "../context/temporary";
 import assignAssignments from "../process/assign";
 
 import { define } from "../elements";
-import { subproofAssertionFromStatement } from "../utilities/statement";
 import { termsFromJSON, framesFromJSON, statementFromJSON, procedureCallFromJSON, termsToTermsJSON, framesToFramesJSON, statementToStatementJSON, procedureCallToProcedureCallJSON } from "../utilities/json";
 
 export default define(class Premise extends Element {
@@ -32,46 +31,49 @@ export default define(class Premise extends Element {
 
     context = temporaryContext; ///
 
-    const premiseString = this.string; ///
+    const node = this.getNode(),
+          premiseString = this.getString(); ///
 
-    context.trace(`Verifying the '${premiseString}' premise...`, this.node);
+    context.trace(`Verifying the '${premiseString}' premise...`, node);
 
-    if (false) {
-      ///
-    } else if (this.statement !== null) {
-      const stated = true,
-            assignments = [],
-            statementVerifies = this.statement.verify(assignments, stated, context);
+    if ((this.statement === null) && (this.procedureCall === null)) {
+      context.debug(`Unable to verify the '${premiseString}' premise because it is nonsense.`, node);
+    } else {
+      if (this.statement !== null) {
+        const stated = true,
+              assignments = [],
+              statementValidates = this.statement.validate(assignments, stated, context);
 
-      if (statementVerifies) {
-        const assignmentsAssigned = assignAssignments(assignments, context);
+        if (statementValidates) {
+          const assignmentsAssigned = assignAssignments(assignments, context);
 
-        if (assignmentsAssigned) {
-          const { Step } = elements,
-                step = Step.fromStatement(this.statement, context),
-                stepOrSubproof = step;  ///
+          if (assignmentsAssigned) {
+            const { Step } = elements,
+                  step = Step.fromStatement(this.statement, context),
+                  stepOrSubproof = step;  ///
 
-          context.addStepOrSubproof(stepOrSubproof);
+            context.addStepOrSubproof(stepOrSubproof);
 
-          verifies = true;
+            verifies = true;
+          }
         }
       }
-    } else if (this.procedureCall !== null) {
-      const stated = true,
-            assignments = null,
-            procedureCallVerifies = this.procedureCall.verify(assignments, stated, context);
 
-      if (procedureCallVerifies) {
-        verifies = true;
+      if (this.procedureCall !== null) {
+        const stated = true,
+              assignments = null,
+              procedureCallVerifies = this.procedureCall.verify(assignments, stated, context);
+
+        if (procedureCallVerifies) {
+          verifies = true;
+        }
       }
-    } else {
-      context.debug(`Unable to verify the '${premiseString}' premise because it is nonsense.`, this.node);
     }
 
     if (verifies) {
-      this.context = context;
+      this.setContext(context);
 
-      context.debug(`...verified the '${premiseString}' premise.`, this.node);
+      context.debug(`...verified the '${premiseString}' premise.`, node);
     }
 
     return verifies;
@@ -80,11 +82,12 @@ export default define(class Premise extends Element {
   unifyIndependently(substitutions, context) {
     let unifiesIndependently = false;
 
-    const premiseString = this.string,  ///
+    const node = this.getNode(),
+          premiseString = this.getString(),  ///
           generalContext = this.context,  ///
           specificContext = context;  ///
 
-    context.trace(`Unifying the '${premiseString}' premise independently...`, this.node);
+    context.trace(`Unifying the '${premiseString}' premise independently...`, node);
 
     if (this.statement !== null) {
       const statementUnifiesIndependently = this.statement.unifyIndependently(substitutions, generalContext, specificContext);
@@ -103,7 +106,7 @@ export default define(class Premise extends Element {
     }
 
     if (unifiesIndependently) {
-      context.debug(`...unified the '${premiseString}' premise independenly.`, this.node);
+      context.debug(`...unified the '${premiseString}' premise independenly.`, node);
     }
 
     return unifiesIndependently;
@@ -145,22 +148,7 @@ export default define(class Premise extends Element {
     return stepOrSubproofUnifies;
   }
 
-  unifyStep(step, substitutions, context) {
-    let stepUnifies = false;
-
-    context = step.getContext();
-
-    const statement = step.getStatement(),
-          statementUnifies = this.unifyStatement(statement, substitutions, context);
-
-    if (statementUnifies) {
-      stepUnifies = true;
-    }
-
-    return stepUnifies;
-  }
-
-  unifySubproof(subproof, substitutions, generalContext, specificContext) {
+  unifySubproof(subproof, substitutions, context) {
     let subproofUnifies = false;
 
     const premise = this, ///
@@ -168,10 +156,18 @@ export default define(class Premise extends Element {
           premiseStatement = premise.getStatement(),
           premiseStatementString = premiseStatement.getString();
 
-    specificContext.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement...`);
+    context.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement...`);
+
+    const specificContext = context;  ///
+
+    context = this.getContext();
+
+    const generalContext = context; ///
+
+    context = specificContext;  ///
 
     if (this.statement !== null) {
-      const context = generalContext,
+      const context = generalContext, ///
             subproofAssertion = subproofAssertionFromStatement(this.statement, context);
 
       if (subproofAssertion !== null) {
@@ -180,33 +176,31 @@ export default define(class Premise extends Element {
     }
 
     if (subproofUnifies) {
-      specificContext.debug(`...unified the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement.`);
+      context.debug(`...unified the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement.`);
     }
 
     return subproofUnifies;
   }
 
-  unifyStatement(statement, substitutions, context) {
-    let statementUnifies;
+  unifyStep(step, substitutions, context) {
+    let stepUnifies = false;
+
+    const specificContext = context;  ///
 
-    const premise = this, ///
-          premiseString = premise.getString(),
-          statementString = statement.getString();
+    context = this.getContext();
 
-    context.trace(`Unifying the '${statementString}' statement with the '${premiseString}' premise...`);
+    const generalContext = context; ///
 
-    if (this.statement !== null) {
-      const generalContext = this.context,  ///
-            specificContext = context;  ///
+    context = specificContext;  ///
 
-      statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
-    }
+    const statement = step.getStatement(),
+          statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
 
     if (statementUnifies) {
-      context.debug(`...unified the '${statementString}' statement with the '${premiseString}' premise.`);
+      stepUnifies = true;
     }
 
-    return statementUnifies;
+    return stepUnifies;
   }
 
   toJSON() {

package/src/element/property.js

@@ -20,16 +20,16 @@ export default define(class Property extends Element {
     return this.nominalTypeName;
   }
 
-  matchPropertyName(propertyName) {
-    const propertyNameMatches = (this.name === propertyName);
+  comparePropertyName(propertyName) {
+    const comparesToPropertyName = (this.name === propertyName);
 
-    return propertyNameMatches;
+    return comparesToPropertyName;
   }
 
-  matchNominalTypeName(nominalTypeName) {
-    const nominalTypeNameMatches = (this.nominalTypeName === nominalTypeName);
+  compareNominalTypeName(nominalTypeName) {
+    const comparesToNominalTypeName = (this.nominalTypeName === nominalTypeName);
 
-    return nominalTypeNameMatches;
+    return comparesToNominalTypeName;
   }
 
   toJSON() {

package/src/element/propertyRelation.js

@@ -27,9 +27,9 @@ export default define(class PropertyRelation extends Element {
 
     context.trace(`Verifying the '${propertyRelationString}' property relation...`);
 
-    const termVerifies = this.verifyTerm(context);
+    const termValidates = this.validateTerm(context);
 
-    if (termVerifies) {
+    if (termValidates) {
       const propertyVerifies = this.verifyProperty(context);
 
       verifies = propertyVerifies;
@@ -42,24 +42,24 @@ export default define(class PropertyRelation extends Element {
     return verifies;
   }
 
-  verifyTerm(context) {
-    let termVerifies;
+  validateTerm(context) {
+    let termValidates;
 
     const termString = this.term.getString();
 
-    context.trace(`Verifying the '${termString}' term...`);
+    context.trace(`Validating the '${termString}' term...`);
 
-    termVerifies = this.term.verify(context, () => {
+    termValidates = this.term.validate(context, () => {
       const verifiesAhead = true;
 
       return verifiesAhead;
     });
 
-    if (termVerifies) {
-      context.debug(`...verified the '${termString}' term.`);
+    if (termValidates) {
+      context.debug(`...validated the '${termString}' term.`);
     }
 
-    return termVerifies;
+    return termValidates;
   }
 
   verifyProperty(context) {
@@ -73,9 +73,9 @@ export default define(class PropertyRelation extends Element {
           propertyName = this.property.getName(),
           termTypeProperties = termType.getProperties(),
           variableTypeProperty = termTypeProperties.find((termTypeProperty) => {
-            const propertyNameMatches = termTypeProperty.matchPropertyName(propertyName);
+            const termTypePropertyComparesToPropertyName = termTypeProperty.comparePropertyName(propertyName);
 
-            if (propertyNameMatches) {
+            if (termTypePropertyComparesToPropertyName) {
               return true;
             }
           }) || null;

package/src/element/reference.js

@@ -4,7 +4,7 @@ import Element from "../element";
 import elements from "../elements";
 
 import { define } from "../elements";
-import { referenceMetaType } from ".//metaType";
+import { referenceMetaTypeFromNothing } from "../metaTypes";
 import { unifyMetavariableIntrinsically } from "../process/unify";
 import { metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
 
@@ -35,19 +35,9 @@ export default define(class Reference extends Element {
 
   isMetavariableEqualToMetavariable(metavariable) { return this.metavariable.isEqualTo(metavariable); }
 
-  matchMetavariableName(metavariableName) { return this.metavariable.matchMetavariableName(metavariableName); }
+  compareMetavariableName(metavariableName) { return this.metavariable.compareMetavariableName(metavariableName); }
 
-  matchMetavariableNode(metavariableNode) {
-    const metavariableNodeA = metavariableNode; ///
-
-    metavariableNode = this.metavariable.getNode();
-
-    const metavariableNodeB = metavariableNode, ///
-          matches = metavariableNodeA.match(metavariableNodeB),
-          metavariableNodeMatches = matches;  ///
-
-    return metavariableNodeMatches; ///
-  }
+  matchMetavariableNode(metavariableNode) { return this.metavariable.matchNode(metavariableNode); }
 
   verify(context) {
     let verifies = false;
@@ -57,9 +47,9 @@ export default define(class Reference extends Element {
     context.trace(`Verifying the '${referenceString}' reference...`);
 
     if (!verifies) {
-      const metavariableVerifies = this.verifyMetavariable(context);
+      const metavariableValidates = this.validateMetavariable(context);
 
-      verifies = metavariableVerifies; ///
+      verifies = metavariableValidates; ///
     }
 
     if (!verifies) {
@@ -80,15 +70,16 @@ export default define(class Reference extends Element {
     return verifies;
   }
 
-  verifyMetavariable(context) {
-    let metavariableVerifies;
+  validateMetavariable(context) {
+    let metavariableValidates;
 
-    const metaType = referenceMetaType, ///
-          metavariableVerifiesGivenMetaType = this.metavariable.verifyGivenMetaType(metaType, context);
+    const referenceMetaType = referenceMetaTypeFromNothing(),
+          metaType = referenceMetaType, ///
+          metavariableValidatesGivenMetaType = this.metavariable.validateGivenMetaType(metaType, context);
 
-    metavariableVerifies = metavariableVerifiesGivenMetaType; ///
+    metavariableValidates = metavariableValidatesGivenMetaType; ///
 
-    return metavariableVerifies;
+    return metavariableValidates;
   }
 
   unifyLabel(label, substitutions, context) {

package/src/element/rule.js

@@ -17,13 +17,13 @@ import { labelsFromJSON,
 const { reverse, extract, backwardsEvery } = arrayUtilities;
 
 export default define(class Rule extends Element {
-  constructor(context, string, node, labels, premises, conclusion, proof) {
+  constructor(context, string, node, proof, labels, premises, conclusion) {
     super(context, string, node);
 
+    this.proof = proof;
     this.labels = labels;
     this.premises = premises;
     this.conclusion = conclusion;
-    this.proof = proof;
   }
 
   getLabels() {
@@ -34,39 +34,47 @@ export default define(class Rule extends Element {
     return this.premises;
   }
 
-  getConclusion() {
-    return this.conclusion;
-  }
-
   getProof() {
     return this.proof;
   }
 
-  matchMetavariableName(metavariableName) {
-    const metavariableNameMatches = this.labels.some((label) => {
-      const metavariableNameMatches = label.matchMetavariableName(metavariableName);
+  getConclusion() {
+    return this.conclusion;
+  }
+
+  compareMetavariableName(metavariableName) {
+    const comparesToMetavariableName = this.labels.some((label) => {
+      const labelComparesToMetavariableName = label.compareMetavariableName(metavariableName);
 
-      if (metavariableNameMatches) {
+      if (labelComparesToMetavariableName) {
         return true;
       }
     });
 
-    return metavariableNameMatches;
+    return comparesToMetavariableName;
   }
 
   verify() {
     let verifies = false;
 
-    const ruleString = this.string; ///
+    let context;
+
+    const node = this.getNode();
+
+    context = this.getContext();
 
-    this.context.trace(`Verifying the '${ruleString}' rule...`, this.node);
+    const ruleString = this.getString(); ///
+
+    context.trace(`Verifying the '${ruleString}' rule...`, node);
 
     const labelsVerify = this.verifyLabels();
 
     if (labelsVerify) {
-      const localContext = LocalContext.fromNothing(this.context),
-            context = localContext, ///
-            premisesVerify = this.verifyPremises(context);
+      const localContext = LocalContext.fromNothing(context);
+
+      context = localContext; ///
+
+      const premisesVerify = this.verifyPremises(context);
 
       if (premisesVerify) {
         const conclusionVerifies = this.verifyConclusion(context);
@@ -75,9 +83,10 @@ export default define(class Rule extends Element {
           const proofVerifies = this.verifyProof(context);
 
           if (proofVerifies) {
-            const rule = this;  ///
+            const rule = this,  ///
+                  context = this.getContext();
 
-            this.context.addRule(rule);
+            context.addRule(rule);
 
             verifies = true;
           }
@@ -86,7 +95,7 @@ export default define(class Rule extends Element {
     }
 
     if (verifies) {
-      this.context.debug(`...verified the '${ruleString}' rule.`, this.node);
+      context.debug(`...verified the '${ruleString}' rule.`, node);
     }
 
     return verifies;
@@ -252,57 +261,4 @@ export default define(class Rule extends Element {
 
     return rule;
   }
-
-  static fromRuleNode(ruleNode, context) {
-    const node = ruleNode,  ///
-          proof = proofFromRuleNode(ruleNode, context),
-          labels = labelsFromRuleNode(ruleNode, context),
-          premises = premisesFromRuleNode(ruleNode, context),
-          conclusion = conclusionFromRuleNode(ruleNode, context),
-          string = stringFromLabelsPremisesAndConclusion(labels, premises, conclusion),
-          rule = new Rule(context, string, node, labels, premises, conclusion, proof);
-
-    return rule;
-  }
 });
-
-function proofFromRuleNode(ruleNode, context) {
-  const { Proof } = elements,
-        proofNode = ruleNode.getProofNode(),
-        proof = Proof.fromProofNode(proofNode, context);
-
-  return proof;
-}
-
-function labelsFromRuleNode(ruleNode, context) {
-  const { Label } = elements,
-        labelNodes = ruleNode.getLabelNodes(),
-        labels = labelNodes.map((labelNode) => {
-          const label = Label.fromLabelNode(labelNode, context);
-
-          return label;
-        });
-
-  return labels;
-}
-
-function premisesFromRuleNode(ruleNode, context) {
-  const { Premise } = elements,
-        premiseNodes = ruleNode.getPremiseNodes(),
-        premises = premiseNodes.map((premiseNode) => {
-          const premise = Premise.fromPremiseNode(premiseNode, context);
-
-          return premise;
-        });
-
-  return premises;
-}
-
-function conclusionFromRuleNode(ruleNode, context) {
-  const { Conclusion } = elements,
-        conclusionNode = ruleNode.getConclusionNode(),
-        conclusion = Conclusion.fromConclusionNode(conclusionNode, context);
-
-  return conclusion;
-}
-

package/src/element/signature.js

@@ -27,7 +27,7 @@ export default define(class Signature extends Element {
 
     const signatureString = this.string;  ///
 
-    context.trace(`Verifying the ${signatureString} signature...`);
+    context.trace(`Verifying the '${signatureString}' signature...`);
 
     verifies = this.terms.every((term) => {
       const termVerifies = term.verify(context, () => {
@@ -42,13 +42,13 @@ export default define(class Signature extends Element {
     });
 
     if (verifies) {
-      context.debug(`...verified the ${signatureString} signature.`);
+      context.debug(`...verified the '${signatureString}' signature.`);
     }
 
     return verifies;
   }
 
-  match(signature, substitutions, generalContext, specificContext) {
+  compare(signature, substitutions, generalContext, specificContext) {
     const terms = signature.getTerms(),
           termsA = this.terms,  ///
           termsB = terms, ///
@@ -74,9 +74,10 @@ export default define(class Signature extends Element {
                 return true;
               }
             }
-          });
+          }),
+          compares = matches; ///
 
-    return matches;
+    return compares;
   }
 
   compareSubstitutions(substitutions, context) {
@@ -85,7 +86,7 @@ export default define(class Signature extends Element {
     const signatureString = this.string,  ///
           substitutionsString = substitutions.asString();
 
-    context.trace(`Comparing the '${substitutionsString}' substitutions against the ${signatureString} signature...`);
+    context.trace(`Comparing the '${substitutionsString}' substitutions against the '${signatureString}' signature...`);
 
     const array = substitutions.getArray(),
           compares = compare(this.terms, array, (term, substitution) => {
@@ -102,7 +103,7 @@ export default define(class Signature extends Element {
     }
 
     if (substitutionsCompares) {
-      context.debug(`...compared the '${substitutionsString}' substitutions against the ${signatureString} signature.`);
+      context.debug(`...compared the '${substitutionsString}' substitutions against the '${signatureString}' signature.`);
     }
 
     return substitutionsCompares;
@@ -114,7 +115,7 @@ export default define(class Signature extends Element {
     const signatureString = this.string,  ///
           substitutionsString = substitutions.asString();
 
-    context.trace(`Correlating the '${substitutionsString}' substitutions against the ${signatureString} signature...`);
+    context.trace(`Correlating the '${substitutionsString}' substitutions against the '${signatureString}' signature...`);
 
     const array = substitutions.getArray(),
           correlates = correlate(this.terms, array, (term, substitution) => {
@@ -131,7 +132,7 @@ export default define(class Signature extends Element {
     }
 
     if (substitutionsCorrelates) {
-      context.debug(`...correlated the '${substitutionsString}' substitutions against the ${signatureString} signature.`);
+      context.debug(`...correlated the '${substitutionsString}' substitutions against the '${signatureString}' signature.`);
     }
 
     return substitutionsCorrelates;