occam-verify-cli 1.0.437 → 1.0.444

package/src/element/substitution/term.js

@@ -1,6 +1,5 @@
 "use strict";
 
-import elements from "../../elements";
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
@@ -31,28 +30,26 @@ export default define(class TermSubstitution extends Substitution {
     return replacementNode;
   }
 
+  isTermEqualToTerm(term, context) {
+    term = stripBracketsFromTerm(term, context); ///
+
+    const termEqualToTerm = this.term.isEqualTo(term);
+
+    return termEqualToTerm;
+  }
+
   isTrivial() {
     let trivial = false;
 
-    const termEqualToVariable = this.term.isEqualToVariable(this.variable);
+    const termComparesToVaraible = this.term.compareVariable(this.variable);
 
-    if (termEqualToVariable) {
+    if (termComparesToVaraible) {
       trivial = true;
     }
 
     return trivial;
   }
 
-  isTermEqualToTerm(term, context) {
-    term = stripBracketsFromTerm(term, context); ///
-
-    const termEqualToTerm = this.term.isEqualTo(term);
-
-    return termEqualToTerm;
-  }
-
-  matchParameter(parameter) { return this.variable.matchParameter(parameter); }
-
   verify(context) {
     let verifies = false;
 

package/src/element/substitution.js

@@ -110,14 +110,12 @@ export default class Substitution extends Element {
     return substitutionEqualToSubstitution;
   }
 
-  matchParameter(parameter) {
-    const parameterMatches = false;
+  compareParameter(parameter) {
+    const comparesToParameter = false;
 
-    return parameterMatches;
+    return comparesToParameter;
   }
 
-  matchSubstitutionNode(substitutionNode) { return this.node.match(substitutionNode); }
-
   resolve(substitutions, context) {
     const resolved = true;
 

package/src/element/substitutions.js

@@ -6,6 +6,7 @@ import Element from "../element";
 
 import { define } from "../elements";
 import { EMPTY_STRING } from "../constants";
+import { substitutionsStringFromSubstitutions } from "../utilities/string";
 
 const { find, first, clear, prune, filter, compress, correlate } = arrayUtilities;
 
@@ -25,8 +26,6 @@ export default define(class Substitutions extends Element {
     return this.savedArray;
   }
 
-  getLength() { return this.array.length; }
-
   getMetavariables() {
     const metavariables = [];
 
@@ -75,6 +74,8 @@ export default define(class Substitutions extends Element {
     return firstSubstitution;
   }
 
+  getLength() { return this.array.length; }
+
   mapSubstitution(callback) { return this.array.map(callback); }
 
   findSubstitution(callback) { return this.array.find(callback) || null; }  ///
@@ -200,9 +201,13 @@ export default define(class Substitutions extends Element {
   addSubstitution(substitution, context) {
     this.array.push(substitution);
 
-    const substitutionString = substitution.getString();
+    const string = this.asString(),
+          substitutionString = substitution.getString(),
+          substitutionsString = string; ///
 
-    context.trace(`Added the '${substitutionString}' substitution.`);
+    this.setString(string);
+
+    context.trace(`Added the '${substitutionString}' substitution to the '${substitutionsString}' substitutions.`);
   }
 
   removeSubstitution(substitution, context) {
@@ -216,9 +221,13 @@ export default define(class Substitutions extends Element {
       }
     });
 
-    const substitutionString = substitution.getString();
+    const string = this.asString(),
+          substitutionString = substitution.getString(),
+          substitutionsString = string; ///
+
+    this.setString(string);
 
-    context.trace(`Removed the '${substitutionString}' substitution.`);
+    context.trace(`Removed the '${substitutionString}' substitution from the '${substitutionsString}' substitutions.`);
   }
 
   correlateSubstitutions(substitutions) {
@@ -236,16 +245,6 @@ export default define(class Substitutions extends Element {
     return correlates;
   }
 
-  removeTrivialSubstitutions()  {
-    filter(this.array, (substitution) => {
-      const trivial = substitution.isTrivial();
-
-      if (!trivial) {
-        return true;
-      }
-    });
-  }
-
   clear() {
     clear(this.array);
 
@@ -318,6 +317,10 @@ export default define(class Substitutions extends Element {
     ];
 
     this.savedArray = null;
+
+    const string = this.asString();
+
+    this.setString(string);
   }
 
   continue() {
@@ -332,15 +335,8 @@ export default define(class Substitutions extends Element {
     if (length === 0) {
       string = EMPTY_STRING;
     } else {
-      const substitutionsString = this.array.reduce((substitutionsString, substitution) => {
-        const substitutionString = substitution.getString();
-
-        substitutionsString = (substitutionsString === null) ?
-                                 substitutionString :
-                                  `${substitutionsString}, ${substitutionString}`;
-
-        return substitutionsString;
-      }, null);
+      const substitutions = this.array, ///
+            substitutionsString = substitutionsStringFromSubstitutions(substitutions);
 
       string = substitutionsString; ///
     }
@@ -349,16 +345,38 @@ export default define(class Substitutions extends Element {
   }
 
   static fromArray(array) {
-    const savedArray = [],
-          substitutions = new Substitutions(array, savedArray);
+    let string;
+
+    const context = null;
+
+    string = null;
+
+    const node = null,
+          savedArray = [],
+          substitutions = new Substitutions(context, string, node, array, savedArray);
+
+    string = substitutions.asString();
+
+    substitutions.setString(string);
 
     return substitutions;
   }
 
   static fromNothing() {
-    const array = [],
-          savedArray = null,
-          substitutions = new Substitutions(array, savedArray);
+    let string;
+
+    const context = null;
+
+    string = null;
+
+    const node = null,
+          array = [],
+          savedArray = [],
+          substitutions = new Substitutions(context, string, node, array, savedArray);
+
+    string = substitutions.asString();
+
+    substitutions.setString(string);
 
     return substitutions;
   }

package/src/element/supposition.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 Supposition extends Element {
@@ -32,81 +31,69 @@ export default define(class Supposition extends Element {
 
     context = temporaryContext; ///
 
-    const suppositionString = this.string; ///
+    const node = this.getNode(),
+          suppositionString = this.getString(); ///
 
-    context.trace(`Verifying the '${suppositionString}' supposition...`, this.node);
+    context.trace(`Verifying the '${suppositionString}' supposition...`, 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 '${suppositionString}' supposition 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 '${suppositionString}' supposition because it is nonsense.`, this.node);
     }
 
     if (verifies) {
-      this.context = context;
+      this.setContext(context);
 
-      context.debug(`...verified the '${suppositionString}' supposition.`, this.node);
+      context.debug(`...verified the '${suppositionString}' supposition.`, node);
     }
 
     return verifies;
   }
 
-  unifySupposition(supposition, substitutions, generalContext, specificContext) {
-    let suppositionUnifies;
+  unifyIndependently(substitutions, context) {
+    let unifiesIndependently = false;
 
-    const context = specificContext,  ///
-          specificSupposition = supposition,  ///
-          generalSuppositionString = this.string, ///
-          specificSuppositionString = specificSupposition.getString();
+    const node = this.getNode(),
+          suppositionString = this.getString();
 
-    context.trace(`Unifying the '${specificSuppositionString}' supposition with the '${generalSuppositionString}' supposition...`, this.node);
+    context.trace(`Unifying the '${suppositionString}' supposition independently...`, node);
 
-    const statement = specificSupposition.getStatement(),
-          statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+    const specificContext = context;  ///
 
-    suppositionUnifies = statementUnifies;  ///
+    context = this.getContext();
 
-    if (suppositionUnifies) {
-      context.debug(`...unified the '${specificSuppositionString}' supposition with the '${generalSuppositionString}' supposition.`, this.node);
-    }
+    const generalContext = context; ///
 
-    return suppositionUnifies;
-  }
-
-  unifyIndependently(substitutions, context) {
-    let unifiesIndependently = false;
-
-    const suppositionString = this.string,  ///
-          generalContext = this.context,  ///
-          specificContext = context;  ///
-
-    context.trace(`Unifying the '${suppositionString}' supposition independently...`, this.node);
+    context = specificContext;  ///
 
     if (this.statement !== null) {
       const statementUnifiesIndependently = this.statement.unifyIndependently(substitutions, generalContext, specificContext);
@@ -125,7 +112,7 @@ export default define(class Supposition extends Element {
     }
 
     if (unifiesIndependently) {
-      context.debug(`...unified the '${suppositionString}' supposition independenly.`, this.node);
+      context.debug(`...unified the '${suppositionString}' supposition independenly.`, node);
     }
 
     return unifiesIndependently;
@@ -167,19 +154,6 @@ export default define(class Supposition extends Element {
     return stepOrSubproofUnifies;
   }
 
-  unifyStep(step, substitutions, context) {
-    let stepUnifies;
-
-    context = step.getContext();
-
-    const statement = step.getStatement(),
-          statementUnifies = this.unifyStatement(statement, substitutions, context);
-
-    stepUnifies = statementUnifies;  ///
-
-    return stepUnifies;
-  }
-
   unifySubproof(subproof, substitutions, context) {
     let subproofUnifies = false;
 
@@ -190,14 +164,22 @@ export default define(class Supposition extends Element {
 
     context.trace(`Unifying the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement...`);
 
+    const specificContext = context;  ///
+
+    context = this.getContext();
+
+    const generalContext = context;  ///
+
+    context = specificContext;  ///
+
     if (this.statement !== null) {
-      const context = generalContext, ///
-            subproofAssertion = subproofAssertionFromStatement(this.statement, context);
+      const node = this.getNode(),
+            assertionNode = node, /// 
+            assertion = context.findAssertionByAssertionNode(assertionNode);
 
-      if (subproofAssertion !== null) {
-        const generalContext = this.context,  ///
-              specificContext = context;  ///
+      if (assertion !== null) {}
 
+      if (subproofAssertion !== null) {
         subproofUnifies = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);
       }
     }
@@ -209,6 +191,19 @@ export default define(class Supposition extends Element {
     return subproofUnifies;
   }
 
+  unifyStep(step, substitutions, context) {
+    let stepUnifies;
+
+    context = step.getContext();
+
+    const statement = step.getStatement(),
+          statementUnifies = this.unifyStatement(statement, substitutions, context);
+
+    stepUnifies = statementUnifies;  ///
+
+    return stepUnifies;
+  }
+
   unifyStatement(statement, substitutions, context) {
     let statementUnifies;
 
@@ -232,6 +227,29 @@ export default define(class Supposition extends Element {
     return statementUnifies;
   }
 
+  unifySupposition(supposition, substitutions, generalContext, specificContext) {
+    let suppositionUnifies;
+
+    const node = this.getNode(),
+          context = specificContext,  ///
+          specificSupposition = supposition,  ///
+          generalSuppositionString = this.getString(), ///
+          specificSuppositionString = specificSupposition.getString();
+
+    context.trace(`Unifying the '${specificSuppositionString}' supposition with the '${generalSuppositionString}' supposition...`, node);
+
+    const statement = specificSupposition.getStatement(),
+          statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+
+    suppositionUnifies = statementUnifies;  ///
+
+    if (suppositionUnifies) {
+      context.debug(`...unified the '${specificSuppositionString}' supposition with the '${generalSuppositionString}' supposition.`, node);
+    }
+
+    return suppositionUnifies;
+  }
+
   toJSON() {
     let frames,
         terms;

package/src/element/term.js

@@ -3,9 +3,9 @@
 import { arrayUtilities } from "necessary";
 
 import Element from "../element";
-import verifyMixins from "../mixins/term/verify";
 
 import { define } from "../elements";
+import { validateTerms } from "../utilities/validation";
 import { instantiateTerm } from "../process/instantiate";
 import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 
@@ -30,10 +30,8 @@ export default define(class Term extends Element {
 
   isProvisional() { return this.type.isProvisional(); }
 
-  matchTermNode(termNode) { return this.node.match(termNode); }
-
-  isEqualToVariable(variable) {
-    let variableNodeMathces = false;
+  compareVariable(variable) {
+    let comparesToVaraible = false;
 
     const singular = this.isSingular();
 
@@ -45,19 +43,11 @@ export default define(class Term extends Element {
             matches = variableNodeA.match(variableNodeB);
 
       if (matches) {
-        variableNodeMathces = true;
+        comparesToVaraible = true;
       }
     }
 
-    return variableNodeMathces;
-  }
-
-  isEqualTo(term) {
-    const termNode = term.getNode(),
-          matches = this.node.match(termNode),
-          equalTo = matches;  ///
-
-    return equalTo;
+    return comparesToVaraible;
   }
 
   isGrounded(definedVariables, context) {
@@ -95,31 +85,31 @@ export default define(class Term extends Element {
     return implicitlyGrounded;
   }
 
-  verify(context, verifyAhead) {
-    let verifies;
+  validate(context, verifyAhead) {
+    let validates;
 
     const termString = this.string;  ///
 
-    context.trace(`Verifying the '${termString}' term...`);
+    context.trace(`Validating the '${termString}' term...`);
 
-    verifies = verifyMixins.some((verifyMixin) => {
+    validates = validateTerms.some((validateTerm) => {  ///
       const term = this, ///
-            verifies = verifyMixin(term, context, verifyAhead);
+            termValidates = validateTerm(term, context, verifyAhead);
 
-      if (verifies) {
+      if (termValidates) {
         return true;
       }
     });
 
-    if (verifies) {
+    if (validates) {
       const term = this;  ///
 
       context.addTerm(term);
 
-      context.debug(`...verified the '${termString}' term.`);
+      context.debug(`...validated the '${termString}' term.`);
     }
 
-    return verifies;
+    return validates;
   }
 
   verifyGivenType(type, generalContext, specificContext) {
@@ -128,10 +118,10 @@ export default define(class Term extends Element {
     const typeString = type.getString(),
           termString = this.getString();  ///
 
-    specificContext.trace(`Verifying the '${termString}' term given the '${typeString}' type...`);
+    specificContext.trace(`Validating the '${termString}' term given the '${typeString}' type...`);
 
     const context = specificContext, ///
-          verifies = this.verify(context, () => {
+          validates = this.validate(context, () => {
             let verifiesAhead;
 
             const typeEqualToOrSubTypeOfGivenTypeType = this.type.isEqualToOrSubTypeOf(type);
@@ -143,10 +133,10 @@ export default define(class Term extends Element {
             return verifiesAhead;
           });
 
-    verifiesGivenType = verifies; ///
+    verifiesGivenType = validates; ///
 
     if (verifiesGivenType) {
-      specificContext.debug(`...verified the '${termString}' term given the '${typeString}' type.`);
+      specificContext.debug(`...validated the '${termString}' term given the '${typeString}' type.`);
     }
 
     return verifiesGivenType;