occam-verify-cli 1.0.448 → 1.0.472

package/src/element/substitution.js

@@ -7,54 +7,12 @@ export default class Substitution extends Element {
     super(context, string, node);
   }
 
-  getTerm() {
-    const term = null;
-
-    return term;
-  }
-
-  getFrame() {
-    const frame = null;
-
-    return frame;
-  }
-
-  getVariable() {
-    const variable = null;
-
-    return variable;
-  }
-
-  getReference() {
-    const reference = null;
-
-    return reference;
-  }
-
-  getStatement() {
-    const statement = null;
-
-    return statement;
-  }
-
-  getMetavariable() {
-    const metavariableNode = null;
-
-    return metavariableNode;
-  }
-
   getSubstitution() {
     const substitution = null;
 
     return substitution;
   }
 
-  getReplacementNode() {
-    const replacementNode = null;
-
-    return replacementNode;
-  }
-
   isSimple() {
     const simple = true;
 
@@ -74,40 +32,34 @@ export default class Substitution extends Element {
     return trivial;
   }
 
-  isTermEqualToTerm(term, context) {
-    const termEqualToTerm = false;
-
-    return termEqualToTerm;
-  }
-
   isFrameEqualToFrame(frame) {
     const frameEqualToFrame = false;
 
     return frameEqualToFrame;
   }
 
-  isReferenceEqualToReference(reference, context) {
+  isReferenceEqualToReference(reference) {
     const referenceEqualToReference = false;
 
     return referenceEqualToReference;
   }
 
-  isStatementEqualToStatement(statement, context) {
-    const statementEqualToStatement = false;
-
-    return statementEqualToStatement;
-  }
-
   isMetavariableEqualToMetavariable(metavariable) {
     const metavariableEqualToMetavariable = false;
 
     return metavariableEqualToMetavariable;
   }
 
-  isSubstitutionEqualToSubstitution(substitution) {
-    const substitutionEqualToSubstitution = (substitution === null);
+  compareTerm(term, context) {
+    const comparesToTerm = false;
+
+    return comparesToTerm;
+  }
+
+  compareStatement(statement) {
+    const comparesToStatement = false;
 
-    return substitutionEqualToSubstitution;
+    return comparesToStatement;
   }
 
   compareParameter(parameter) {
@@ -116,6 +68,12 @@ export default class Substitution extends Element {
     return comparesToParameter;
   }
 
+  compareSubstitution(substitution) {
+    const comparesToSubstitution = false;
+
+    return comparesToSubstitution;
+  }
+
   resolve(substitutions, context) {
     const resolved = true;
 

package/src/element/substitutions.js

@@ -8,7 +8,7 @@ import { define } from "../elements";
 import { EMPTY_STRING } from "../constants";
 import { substitutionsStringFromSubstitutions } from "../utilities/string";
 
-const { find, first, clear, prune, filter, compress, correlate } = arrayUtilities;
+const { find, first, clear, prune, filter, extract, compress, correlate } = arrayUtilities;
 
 export default define(class Substitutions extends Element {
   constructor(context, string, node, array, savedArray) {
@@ -78,7 +78,7 @@ export default define(class Substitutions extends Element {
 
   mapSubstitution(callback) { return this.array.map(callback); }
 
-  findSubstitution(callback) { return this.array.find(callback) || null; }  ///
+  findSubstitution(callback) { return this.array.find(callback) }
 
   someSubstitution(callback) { return this.array.some(callback); }
 
@@ -88,9 +88,23 @@ export default define(class Substitutions extends Element {
 
   forEachSubstitution(callback) { this.array.forEach(callback); }
 
+  extractSubstitution(callbcak) { return extract(this.array, callbcak); }
+
   findSubstitutions(callback) {
+    let string;
+
     const array = find(this.array, callback),
-          substitutions = Substitutions.fromArray(array);
+          context = null;
+
+    string = null;
+
+    const node = null,
+          savedArray = [],
+          substitutions = new Substitutions(context, string, node, array, savedArray);
+
+    string = substitutions.asString();
+
+    substitutions.setString(string);
 
     return substitutions;
   }
@@ -106,7 +120,7 @@ export default define(class Substitutions extends Element {
           return true;
         }
       }
-    });
+    }) || null;
 
     return substitution;
   }
@@ -135,7 +149,7 @@ export default define(class Substitutions extends Element {
           return true;
         }
       }
-    });
+    }) || null;
 
     return simpleSubstitution;
   }
@@ -165,13 +179,13 @@ export default define(class Substitutions extends Element {
 
       if (substitutionMetavariableEqualToMetavariable) {
         const substitutionB = substitution, ///
-              substitutionBSubstitutionEqualToSubstitutionA = substitutionB.isSubstitutionEqualToSubstitution(substitutionA);
+              substitutionBSubstitutionComparesToSubstitutionA = substitutionB.compareSubstitution(substitutionA);
 
-        if (substitutionBSubstitutionEqualToSubstitutionA) {
+        if (substitutionBSubstitutionComparesToSubstitutionA) {
           return true;
         }
       }
-    });
+    }) || null;
 
     return substitution;
   }
@@ -199,11 +213,12 @@ export default define(class Substitutions extends Element {
   }
 
   addSubstitution(substitution, context) {
+    const substitutionString = substitution.getString(),
+          substitutionsString = this.asString();  ///
+
     this.array.push(substitution);
 
-    const string = this.asString(),
-          substitutionString = substitution.getString(),
-          substitutionsString = string; ///
+    const string = this.asString();
 
     this.setString(string);
 
@@ -295,13 +310,21 @@ export default define(class Substitutions extends Element {
     return resolved;
   }
 
-  snapshot() {
+  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
     ];
@@ -323,7 +346,11 @@ export default define(class Substitutions extends Element {
     this.setString(string);
   }
 
-  continue() {
+  continue(context) {
+    const substitutionsString = this.getString(); ///
+
+    context.trace(`Continuing with the '${substitutionsString}' substitutions.`);
+
     this.savedArray = null;
   }
 
@@ -344,40 +371,15 @@ export default define(class Substitutions extends Element {
     return string;
   }
 
-  static fromArray(array) {
-    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() {
-    let string;
-
-    const context = null;
-
-    string = null;
+  static name = "Substitutions";
 
+  static fromNothing(context) {
     const node = null,
+          string = EMPTY_STRING,
           array = [],
           savedArray = [],
           substitutions = new Substitutions(context, string, node, array, savedArray);
 
-    string = substitutions.asString();
-
-    substitutions.setString(string);
-
     return substitutions;
   }
 });

package/src/element/term.js

@@ -6,8 +6,7 @@ import Element from "../element";
 
 import { define } from "../elements";
 import { validateTerms } from "../utilities/validation";
-import { instantiateTerm } from "../process/instantiate";
-import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
+import { typeToTypeJSON } from "../utilities/json";
 
 const { filter, compress } = arrayUtilities;
 
@@ -26,30 +25,15 @@ export default define(class Term extends Element {
     this.type = type;
   }
 
-  isSingular() { return this.node.isSingular(); }
+  isSingular() {
+    const node = this.getNode(),
+          singular = node.isSingular();
 
-  isProvisional() { return this.type.isProvisional(); }
-
-  compareVariable(variable) {
-    let comparesToVaraible = false;
-
-    const singular = this.isSingular();
-
-    if (singular) {
-      const variableNode = variable.getNode(),
-            singularVariableNode = this.node.getSingularVariableNode(),
-            variableNodeA = variableNode, ///
-            variableNodeB = singularVariableNode, ///
-            matches = variableNodeA.match(variableNodeB);
-
-      if (matches) {
-        comparesToVaraible = true;
-      }
-    }
-
-    return comparesToVaraible;
+    return singular;
   }
 
+  isProvisional() { return this.type.isProvisional(); }
+
   isGrounded(definedVariables, context) {
     const term  = this, ///
           variables = variablesFromTerm(term, context);
@@ -85,10 +69,37 @@ export default define(class Term extends Element {
     return implicitlyGrounded;
   }
 
+  getVariableIdentifier() {
+    const node = this.getNode(),
+          variableIdentifier = node.getVariableIdentifier();
+
+    return variableIdentifier;
+  }
+
+  compareParameter(parameter) {
+    let comparesToParamter = false;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      const parameterIdentifier = parameter.getIdentifier();
+
+      if (parameterIdentifier !== null) {
+        const variableIdentifier = this.getVariableIdentifier();
+
+        if (parameterIdentifier === variableIdentifier) {
+          comparesToParamter = true;
+        }
+      }
+    }
+
+    return comparesToParamter;
+  }
+
   validate(context, verifyAhead) {
     let validates;
 
-    const termString = this.string;  ///
+    const termString = this.getString();  ///
 
     context.trace(`Validating the '${termString}' term...`);
 
@@ -112,16 +123,15 @@ export default define(class Term extends Element {
     return validates;
   }
 
-  verifyGivenType(type, generalContext, specificContext) {
-    let verifiesGivenType;
+  validateGivenType(type, context) {
+    let validatesGivenType = false;
 
     const typeString = type.getString(),
           termString = this.getString();  ///
 
-    specificContext.trace(`Validating the '${termString}' term given the '${typeString}' type...`);
+    context.trace(`Validating the '${termString}' term given the '${typeString}' type...`);
 
-    const context = specificContext, ///
-          validates = this.validate(context, () => {
+    const validates = this.validate(context, () => {
             let verifiesAhead;
 
             const typeEqualToOrSubTypeOfGivenTypeType = this.type.isEqualToOrSubTypeOf(type);
@@ -133,18 +143,20 @@ export default define(class Term extends Element {
             return verifiesAhead;
           });
 
-    verifiesGivenType = validates; ///
+    if (validates) {
+      validatesGivenType = true;
+    }
 
-    if (verifiesGivenType) {
-      specificContext.debug(`...validated the '${termString}' term given the '${typeString}' type.`);
+    if (validatesGivenType) {
+      context.debug(`...validated the '${termString}' term given the '${typeString}' type.`);
     }
 
-    return verifiesGivenType;
+    return validatesGivenType;
   }
 
   toJSON() {
     const typeJSON = typeToTypeJSON(this.type),
-          string = this.string, ///
+          string = this.getString(), ///
           type = typeJSON,  ///
           json = {
             type,
@@ -157,13 +169,7 @@ export default define(class Term extends Element {
   static name = "Term";
 
   static fromJSON(json, context) {
-    const { string } = json,
-          termNode = instantiateTerm(string, context),
-          node = termNode,  ///
-          type = typeFromJSON(json, context),
-          term = new Term(context, string, node, type);
-
-    return term;
+    ///
   }
 });
 

package/src/element/{axiom.js → topLevelAssertion/axiom.js}

@@ -1,10 +1,10 @@
 "use strict";
 
-import AxiomLemmaTheoremConjecture  from "./axiomLemmaTheoremConjecture";
+import TopLevelAssertion  from "../../node/topLevelAssertion";
 
-import { define } from "../elements";
+import { define } from "../../elements";
 
-export default define(class Axiom extends AxiomLemmaTheoremConjecture {
+export default define(class Axiom extends TopLevelAssertion {
   isSatisfiable() {
     const signature = this.getSignature(),
           satisfiable = (signature !== null);
@@ -15,10 +15,9 @@ export default define(class Axiom extends AxiomLemmaTheoremConjecture {
   verify() {
     let verifies;
 
-    const axiom = this, ///
-          node = this.getNode(),
+    const node = this.getNode(),
           context = this.getContext(),
-          axiomString = axiom.getString();
+          axiomString = this.getString(); ///
 
     context.trace(`Verifying the '${axiomString}' axiom...`, node);
 
@@ -225,42 +224,45 @@ export default define(class Axiom extends AxiomLemmaTheoremConjecture {
     return lastProofAssertionUnifies;
   }
 
-  unifyAxiomLemmaTheoremOrConjecture(axiomLemmaTheoremOrConjecture, substitutions, context) {
-    let axiomLemmaTheoremOrConjectureUnifies = false;
+  unifyTopLevelAssertion(topLevelAssertion, substitutions, context) {
+    let topLevelAssertionUnifies = false;
 
     const node = this.getNode(),
           axiomString = this.getString(),
-          axiomLemmaTheoremOrConjectureString = axiomLemmaTheoremOrConjecture.getString();
+          topLevelAssertionString = topLevelAssertion.getString();
 
-    context.trace(`Unifying the '${axiomLemmaTheoremOrConjectureString}' axiom, lemma, theorem or conjecture with the '${axiomString}' axiom...`, node);
+    context.trace(`Unifying the '${topLevelAssertionString}' top level assertion with the '${axiomString}' axiom...`, node);
 
-    const hypothesesCorrelate = axiomLemmaTheoremOrConjecture.correlateHypotheses(context);
+    const hypothesesCorrelate = topLevelAssertion.correlateHypotheses(context);
 
     if (hypothesesCorrelate) {
-      const deduction = axiomLemmaTheoremOrConjecture.getDeduction(),  ///
-            specificContext = context;  ///
+      const specificContext = context;  ///
 
       context = this.getContext();
 
-      const generalContext = context, ///
+      const generalContext = context; ///
+
+      context = specificContext;  ///
+
+      const deduction = topLevelAssertion.getDeduction(),
             deductionUnifies = this.unifyDeduction(deduction, substitutions, generalContext, specificContext);
 
       if (deductionUnifies) {
-        const suppositions = axiomLemmaTheoremOrConjecture.getSuppositions(),
+        const suppositions = topLevelAssertion.getSuppositions(),
               suppositionsUnify = this.unifySuppositions(suppositions, substitutions, generalContext, specificContext);
 
-        axiomLemmaTheoremOrConjectureUnifies = suppositionsUnify; ///
+        topLevelAssertionUnifies = suppositionsUnify; ///
       }
     }
 
-    if (axiomLemmaTheoremOrConjectureUnifies) {
-      context.debug(`...unified the '${axiomLemmaTheoremOrConjectureString}' axiom, lemma, theorem or conjecture with the '${axiomString}' axiom.`, node);
+    if (topLevelAssertionUnifies) {
+      context.debug(`...unified the '${topLevelAssertionString}' top level assertion with the '${axiomString}' axiom.`, node);
     }
 
-    return axiomLemmaTheoremOrConjectureUnifies;
+    return topLevelAssertionUnifies;
   }
 
   static name = "Axiom";
 
-  static fromJSON(json, context) { return AxiomLemmaTheoremConjecture.fromJSON(Axiom, json, context); }
+  static fromJSON(json, context) { return TopLevelAssertion.fromJSON(Axiom, json, context); }
 });

package/src/element/{conjecture.js → topLevelAssertion/conjecture.js}

@@ -1,17 +1,16 @@
 "use strict";
 
-import AxiomLemmaTheoremConjecture from "./axiomLemmaTheoremConjecture";
+import TopLevelAssertion from "../topLevelAssertion";
 
-import { define } from "../elements";
+import { define } from "../../elements";
 
-export default define(class Conjecture extends AxiomLemmaTheoremConjecture {
+export default define(class Conjecture extends TopLevelAssertion {
   verify() {
     let verifies;
 
     const node = this.getNode(),
           context = this.getContext(),
-          conjecture = this,  ///
-          conjectureString = conjecture.getString();
+          conjectureString = this.getString();  ///
 
     context.trace(`Verifying the '${conjectureString}' conjecture...`, node);
 
@@ -30,5 +29,5 @@ export default define(class Conjecture extends AxiomLemmaTheoremConjecture {
 
   static name = "Conjecture";
 
-  static fromJSON(json, context) { return AxiomLemmaTheoremConjecture.fromJSON(Conjecture, json, context); }
+  static fromJSON(json, context) { return TopLevelAssertion.fromJSON(Conjecture, json, context); }
 });

package/src/element/{lemma.js → topLevelAssertion/lemma.js}

@@ -1,17 +1,16 @@
 "use strict";
 
-import AxiomLemmaTheoremConjecture from "./axiomLemmaTheoremConjecture";
+import TopLevelAssertion from "../topLevelAssertion";
 
-import { define } from "../elements";
+import { define } from "../../elements";
 
-export default define(class Lemma extends AxiomLemmaTheoremConjecture {
+export default define(class Lemma extends TopLevelAssertion {
   verify() {
     let verifies;
 
-    const lemma = this, ///
-          node = this.getNode(),
+    const node = this.getNode(),
           context = this.getContext(),
-          lemmaString = lemma.getString();
+          lemmaString = this.getString(); ///
 
     (lemmaString === null) ?
       context.trace(`Verifying a lemma...`, node) :

package/src/element/{theorem.js → topLevelAssertion/theorem.js}

@@ -1,16 +1,16 @@
 "use strict";
 
-import AxiomLemmaTheoremConjecture from "./axiomLemmaTheoremConjecture";
+import TopLevelAssertion from "../topLevelAssertion";
 
-import { define } from "../elements";
+import { define } from "../../elements";
 
-export default define(class Theorem extends AxiomLemmaTheoremConjecture {
+export default define(class Theorem extends TopLevelAssertion {
   verify() {
     let verifies;
 
     const node = this.getNode(),
           context = this.getContext(),
-          theoremString = this.string;  ///
+          theoremString = this.getString();  ///
 
     context.trace(`Verifying the '${theoremString}' theorem...`, node);
 
@@ -29,5 +29,5 @@ export default define(class Theorem extends AxiomLemmaTheoremConjecture {
 
   static name = "Theorem";
 
-  static fromJSON(json, context) { return AxiomLemmaTheoremConjecture.fromJSON(Theorem, json, context); }
+  static fromJSON(json, context) { return TopLevelAssertion.fromJSON(Theorem, json, context); }
 });