occam-verify-cli 1.0.587 → 1.0.602

package/src/element/substitutions.js

@@ -7,46 +7,9 @@ import { define } from "../elements";
 import { EMPTY_STRING } from "../constants";
 import { substitutionsStringFromSubstitutions } from "../utilities/string";
 
-const { find, first, clear, prune, filter, extract, compress, correlate } = arrayUtilities;
+const { first, extract, correlate } = arrayUtilities;
 
 export default define(class Substitutions extends Element {
-  constructor(context, string, node, array, savedArray) {
-    super(context, string, node);
-
-    this.array = array;
-    this.savedArray = savedArray;
-  }
-
-  getArray() {
-    return this.array;
-  }
-
-  getSavedArray() {
-    return this.savedArray;
-  }
-
-  getMetavariables() {
-    const metavariables = [];
-
-    this.forEachSubstitution((substitution) => {
-      const metavariable = substitution.getMetavariable();
-
-      if (metavariable !== null) {
-        metavariables.push(metavariable);
-      }
-    });
-
-    compress(metavariables, (metavariableA, metavariableB) => {
-      const metavariableAEqualToMetavariableB = metavariableB.isEqualTo(metavariableA);
-
-      if (!metavariableAEqualToMetavariableB) {
-        return true;
-      }
-    });
-
-    return metavariables;
-  }
-
   getNonTrivialLength() {
     const nonTrivialLength = this.reduceSubstitution((nonTrivialLength, substitution) => {
       const substitutionTrivial = substitution.isTrivial();
@@ -73,124 +36,8 @@ export default define(class Substitutions extends Element {
     return firstSubstitution;
   }
 
-  getLength() { return this.array.length; }
-
-  mapSubstitution(callback) { return this.array.map(callback); }
-
-  someSubstitution(callback) { return this.array.some(callback); }
-
-  everySubstitution(callback) { return this.array.every(callback); }
-
-  reduceSubstitution(callback, initialValue) { return this.array.reduce(callback, initialValue); }
-
-  forEachSubstitution(callback) { this.array.forEach(callback); }
-
   extractSubstitution(callbcak) { return extract(this.array, callbcak); }
 
-  findSubstitutions(callback) {
-    let string;
-
-    const array = find(this.array, callback),
-          context = null;
-
-    string = null;
-
-    const node = null,
-          savedArray = [],
-          substitutions = new Substitutions(context, string, node, array, savedArray);
-
-    string = substitutions.asString();
-
-    substitutions.setString(string);
-
-    return substitutions;
-  }
-
-  findSubstitutionByVariable(variable) {
-    const substitution = this.findSubstitution((substitution) => {
-      const substitutionVariable = substitution.getVariable();
-
-      if (substitutionVariable !== null) {
-        const substitutionVariableEqualToVariable = substitutionVariable.isEqualTo(variable);
-
-        if (substitutionVariableEqualToVariable) {
-          return true;
-        }
-      }
-    }) || null;
-
-    return substitution;
-  }
-
-  findSubstitutionsByMetavariable(metavariable) {
-    const substitutions = this.findSubstitutions((substitution) => {
-      const substitutionMetavariableEqualToMetavariable = substitution.isMetavariableEqualToMetavariable(metavariable);
-
-      if (substitutionMetavariableEqualToMetavariable) {
-        return true;
-      }
-    });
-
-    return substitutions;
-  }
-
-  findComplexSubstitutionsByMetavariable(metavariable) {
-    const complexSubstitutions = this.findSubstitutions((substitution) => {
-      const substitutionComplex = substitution.isComplex();
-
-      if (substitutionComplex) {
-        const complexSubstitution = substitution, ///
-              complexSubstitutionMetavariableEqualToMetavariable = complexSubstitution.isMetavariableEqualToMetavariable(metavariable);
-
-        if (complexSubstitutionMetavariableEqualToMetavariable) {
-          return true;
-        }
-      }
-    });
-
-    return complexSubstitutions;
-  }
-
-  isSubstitutionPresentByVariable(variable) {
-    const substitution = this.findSubstitutionByVariable(variable),
-          substitutionPresent = (substitution !== null);
-
-    return substitutionPresent;
-  }
-
-  addSubstitution(substitution, context) {
-    const substitutionString = substitution.getString(),
-          substitutionsString = this.asString();  ///
-
-    this.array.push(substitution);
-
-    const string = this.asString();
-
-    this.setString(string);
-
-    context.trace(`Added the '${substitutionString}' substitution to the '${substitutionsString}' substitutions.`);
-  }
-
-  removeSubstitution(substitution, context) {
-    const substitutionA = substitution; ///
-
-    prune(this.array, (substitution) => {
-      const substitutionB = substitution; ///
-
-      if (substitutionA !== substitutionB) {
-        return true;
-      }
-    });
-
-    const string = this.asString(),
-          substitutionString = substitution.getString(),
-          substitutionsString = string; ///
-
-    this.setString(string);
-
-    context.trace(`Removed the '${substitutionString}' substitution from the '${substitutionsString}' substitutions.`);
-  }
-
   correlateSubstitutions(substitutions) {
     const array = substitutions.getArray(),
           arrayA = array, ///
@@ -206,100 +53,6 @@ export default define(class Substitutions extends Element {
     return correlates;
   }
 
-  clear() {
-    clear(this.array);
-
-    this.savedArray = null;
-  }
-
-  resolve(context) {
-    const metavariables = this.getMetavariables();
-
-    metavariables.forEach((metavariable) => {
-      const complexSubstitutions = this.findComplexSubstitutionsByMetavariable(metavariable),
-            complexSubstitutionsResolved = complexSubstitutions.everySubstitution((complexSubstitution) => {
-              let resolved;
-
-              const substitutions = this, ///
-                    substitution = complexSubstitution; ///
-
-              resolved = substitution.isResolved();
-
-              if (!resolved) {
-                substitution.resolve(substitutions, context);
-              }
-            });
-
-      if (complexSubstitutionsResolved) {
-        return true;
-      }
-    });
-  }
-
-  areResolved() {
-    const metavariables = this.getMetavariables(),
-          resolved = metavariables.every((metavariable) => {
-            const complexSubstitutions = this.findComplexSubstitutionsByMetavariable(metavariable),
-                  complexSubstitutionsResolved = complexSubstitutions.everySubstitution((complexSubstitution) => {
-                        const complexSubstitutionResolved = complexSubstitution.isResolved();
-
-                        if (complexSubstitutionResolved) {
-                          return true;
-                        }
-                      });
-
-                    if (complexSubstitutionsResolved) {
-                      return true;
-                    }
-                  });
-
-    return resolved;
-  }
-
-  snapshot(context) {
-    const substitutionsString = this.getString(); ///
-
-    context.trace(`Taking a snapshot of the '${substitutionsString}' substitutions.`);
-
-    this.savedArray = [
-      ...this.array
-    ];
-  }
-
-  rollback(context) {
-    const substitutionsString = this.getString(); ///
-
-    context.trace(`Rolling back the '${substitutionsString}' substitutions.`);
-
-    const array = [
-      ...this.array
-    ];
-
-    leftDifference(array, this.savedArray);
-
-    array.forEach((substitution) => {
-      this.removeSubstitution(substitution, context);
-    });
-
-    this.array = [
-      ...this.savedArray
-    ];
-
-    this.savedArray = null;
-
-    const string = this.asString();
-
-    this.setString(string);
-  }
-
-  continue(context) {
-    const substitutionsString = this.getString(); ///
-
-    context.trace(`Continuing with the '${substitutionsString}' substitutions.`);
-
-    this.savedArray = null;
-  }
-
   asString() {
     let string;
 
@@ -329,13 +82,3 @@ export default define(class Substitutions extends Element {
     return substitutions;
   }
 });
-
-function leftDifference(arrayA, arrayB) {
-  filter(arrayA, (elementA) => {
-    const arrayBIncludesElementA = arrayB.includes(elementA);
-
-    if (!arrayBIncludesElementA) {
-      return true;
-    }
-  });
-}

package/src/element/term.js

@@ -24,15 +24,47 @@ export default define(class Term extends Element {
     this.type = type;
   }
 
-  isSingular() {
+  getTermNode() {
     const node = this.getNode(),
-          termNode = node,  ///
-          singular = termNode.isSingular();
+          termNode = node;  ///
 
-    return singular;
+    return termNode;
   }
 
-  isProvisional() { return this.type.isProvisional(); }
+  getVariableIdentifier() {
+    const termNode = this.getTermNode(),
+          variableIdentifier = termNode.getVariableIdentifier();
+
+    return variableIdentifier;
+  }
+
+  matchTermNode(termNode) {
+    const termNodeA = termNode; ///
+
+    termNode = this.getTermNode();
+
+    const termNodeB = termNode, ///
+      termNodeAAMatchesTermBNodeB = termNodeA.match(termNodeB),
+      equalTo = termNodeAAMatchesTermBNodeB; ///
+
+    return equalTo;
+  }
+
+  isValid(context) {
+    const termNode = this.getTermNode(),
+          termPresent = context.isTermPresentByTermNode(termNode),
+          valid = termPresent;  ///
+
+    return valid;
+  }
+
+  isEqualTo(term) {
+    const termNode = term.getNode(),
+          termNodeMatches = this.matchTermNode(termNode),
+          equalTo = termNodeMatches;  ///
+
+    return equalTo;
+  }
 
   isGrounded(definedVariables, context) {
     const term  = this, ///
@@ -53,6 +85,15 @@ export default define(class Term extends Element {
     return grounded;
   }
 
+  isSingular() {
+    const termNode = this.getTermNode(),
+          singular = termNode.isSingular();
+
+    return singular;
+  }
+
+  isProvisional() { return this.type.isProvisional(); }
+
   isInitiallyGrounded(context) {
     const term  = this, ///
           variables = variablesFromTerm(term, context),
@@ -69,24 +110,6 @@ export default define(class Term extends Element {
     return implicitlyGrounded;
   }
 
-  getVariableIdentifier() {
-    const node = this.getNode(),
-          variableIdentifier = node.getVariableIdentifier();
-
-    return variableIdentifier;
-  }
-
-  isEqualTo(term) {
-    const termA = this, ///
-          termB = term, ///
-          termANode = termA.getNode(),
-          termBNode = termB.getNode(),
-          termANodeMatchesTermBNode = termANode.match(termBNode),
-          equalTo = termANodeMatchesTermBNode; ///
-
-    return equalTo;
-  }
-
   compareParameter(parameter) {
     let comparesToParamter = false;
 
@@ -114,21 +137,29 @@ export default define(class Term extends Element {
 
     context.trace(`Validating the '${termString}' term...`);
 
-    validates = validateTerms.some((validateTerm) => {  ///
-      const term = this, ///
-            termValidates = validateTerm(term, context, verifyForwards);
+    const valid = this.isValid(context);
 
-      if (termValidates) {
-        return true;
-      }
-    });
+    if (valid) {
+      validates = true;
 
-    if (validates) {
-      const term = this;  ///
+      context.debug(`...the '${termString}' term is already valid.`);
+    } else {
+      validates = validateTerms.some((validateTerm) => {  ///
+        const term = this, ///
+              termValidates = validateTerm(term, context, verifyForwards);
+
+        if (termValidates) {
+          return true;
+        }
+      });
+
+      if (validates) {
+        const term = this;  ///
 
-      context.addTerm(term);
+        context.addTerm(term);
 
-      context.debug(`...validated the '${termString}' term.`);
+        context.debug(`...validated the '${termString}' term.`);
+      }
     }
 
     return validates;

package/src/element/topLevelAssertion/axiom.js

@@ -246,7 +246,7 @@ export default define(class Axiom extends TopLevelAssertion {
     const signatureVerifies = this.verifySignature();
 
     if (signatureVerifies) {
-      verifies = super.verify();
+      verifies = await super.verify();
     }
 
     if (verifies) {

package/src/element/topLevelAssertion/conjecture.js

@@ -16,7 +16,7 @@ export default define(class Conjecture extends TopLevelAssertion {
 
     context.trace(`Verifying the '${conjectureString}' conjecture...`);
 
-    verifies = super.verify();
+    verifies = await super.verify();
 
     if (verifies) {
       const conjecture = this;  ///

package/src/element/topLevelAssertion/theorem.js

@@ -16,7 +16,7 @@ export default define(class Theorem extends TopLevelAssertion {
 
     context.trace(`Verifying the '${theoremString}' theorem...`);
 
-    verifies = super.verify();
+    verifies = await super.verify();
 
     if (verifies) {
       const theorem = this; ///