occam-verify-cli 1.0.457 → 1.0.473

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;
   }
 
-  compareStatement(statement, context) {
-    const comparesToStatement = false;
-
-    return comparesToStatement;
-  }
-
   isMetavariableEqualToMetavariable(metavariable) {
     const metavariableEqualToMetavariable = false;
 
     return metavariableEqualToMetavariable;
   }
 
-  isSubstitutionEqualToSubstitution(substitution) {
-    const substitutionEqualToSubstitution = (substitution === null);
+  compareTerm(term, context) {
+    const comparesToTerm = false;
 
-    return substitutionEqualToSubstitution;
+    return comparesToTerm;
+  }
+
+  compareStatement(statement) {
+    const comparesToStatement = false;
+
+    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...`);
 
@@ -145,7 +156,7 @@ export default define(class Term extends Element {
 
   toJSON() {
     const typeJSON = typeToTypeJSON(this.type),
-          string = this.string, ///
+          string = this.getString(), ///
           type = typeJSON,  ///
           json = {
             type,
@@ -158,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/topLevelAssertion/axiom.js

@@ -15,10 +15,9 @@ export default define(class Axiom extends TopLevelAssertion {
   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);
 
@@ -237,12 +236,15 @@ export default define(class Axiom extends TopLevelAssertion {
     const hypothesesCorrelate = topLevelAssertion.correlateHypotheses(context);
 
     if (hypothesesCorrelate) {
-      const deduction = topLevelAssertion.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) {

package/src/element/topLevelAssertion/conjecture.js

@@ -10,8 +10,7 @@ export default define(class Conjecture extends TopLevelAssertion {
 
     const node = this.getNode(),
           context = this.getContext(),
-          conjecture = this,  ///
-          conjectureString = conjecture.getString();
+          conjectureString = this.getString();  ///
 
     context.trace(`Verifying the '${conjectureString}' conjecture...`, node);
 

package/src/element/topLevelAssertion/lemma.js

@@ -8,10 +8,9 @@ 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/topLevelAssertion/theorem.js

@@ -10,7 +10,7 @@ export default define(class Theorem extends TopLevelAssertion {
 
     const node = this.getNode(),
           context = this.getContext(),
-          theoremString = this.string;  ///
+          theoremString = this.getString();  ///
 
     context.trace(`Verifying the '${theoremString}' theorem...`, node);
 

package/src/element/topLevelAssertion.js

@@ -3,9 +3,8 @@
 import { arrayUtilities } from "necessary";
 
 import Element from "../element";
-import elements from "../elements";
-import ScopedContext from "../context/scoped";
 
+import { scope, attempt } from "../utilities/context";
 import { labelsFromJSON,
          deductionFromJSON,
          signatureFromJSON,
@@ -125,25 +124,27 @@ export default class TopLevelAssertion extends Element {
   verify() {
     let verifies = false;
 
-    const labelsVerify = this.verifyLabels();
+    const context = this.getContext();
 
-    if (labelsVerify) {
-      const scopedContext = ScopedContext.fromNothing(this.context),
-            context = scopedContext, ///
-            suppositionsVerify = this.verifySuppositions(context);
+    scope((context) => {
+      const labelsVerify = this.verifyLabels();
 
-      if (suppositionsVerify) {
-        const deductionVerifies = this.verifyDeduction(context);
+      if (labelsVerify) {
+        const suppositionsVerify = this.verifySuppositions(context);
 
-        if (deductionVerifies) {
-          const proofVerifies = this.verifyProof(context);
+        if (suppositionsVerify) {
+          const deductionVerifies = this.verifyDeduction(context);
 
-          if (proofVerifies) {
-            verifies = true;
+          if (deductionVerifies) {
+            const proofVerifies = this.verifyProof(context);
+
+            if (proofVerifies) {
+              verifies = true;
+            }
           }
         }
       }
-    }
+    }, context);
 
     return verifies;
   }
@@ -186,15 +187,14 @@ export default class TopLevelAssertion extends Element {
   }
 
   verifyProof(context) {
-    let proofVerifies;
+    let proofVerifies = true; ///
 
-    if (this.proof === null) {
-      proofVerifies = true;
-    } else {
-      const { Substitutions } = elements,
-            substitutions = Substitutions.fromNothing();
+    if (this.proof !== null) {
+      proofVerifies = attempt((context) => {
+        const proofVerifies = this.proof.verify(this.deduction, context);
 
-      proofVerifies = this.proof.verify(substitutions, this.deduction, context);
+        return proofVerifies;
+      }, context);
     }
 
     return proofVerifies;
@@ -239,12 +239,7 @@ export default class TopLevelAssertion extends Element {
   unifyStepsOrSubproofsWithSupposition(subproofOrProofAssertions, supposition, substitutions, generalContext, specificContext) {
     let subproofOrProofAssertionsUnifiesWithSupposition = false;
 
-    const context = specificContext,  ///
-          suppositionUnifiesIndependently = supposition.unifyIndependently(substitutions, context);
-
-    if (suppositionUnifiesIndependently) {
-      subproofOrProofAssertionsUnifiesWithSupposition = true;
-    } else {
+    if (!subproofOrProofAssertionsUnifiesWithSupposition) {
       const subproofOrProofAssertion = extract(subproofOrProofAssertions, (subproofOrProofAssertion) => {
         const subproofOrProofAssertionUnifies = supposition.unifySubproofOrProofAssertion(subproofOrProofAssertion, substitutions, generalContext, specificContext);
 
@@ -258,6 +253,15 @@ export default class TopLevelAssertion extends Element {
       }
     }
 
+    if (!subproofOrProofAssertionsUnifiesWithSupposition) {
+      const context = specificContext,  ///
+            suppositionUnifiesIndependently = supposition.unifyIndependently(substitutions, context);
+
+      if (suppositionUnifiesIndependently) {
+        subproofOrProofAssertionsUnifiesWithSupposition = true;
+      }
+    }
+
     return subproofOrProofAssertionsUnifiesWithSupposition;
   }
 

package/src/element/topLevelMetaAssertion/metaLemma.js

@@ -10,8 +10,7 @@ export default define(class MetaLemma extends TopLevelMetaAssertion {
 
     const node = this.getNode(),
           context = this.getContext(),
-          metaLemma = this, ///
-          metaLemmaString = metaLemma.getString();
+          metaLemmaString = this.getString(); ///
 
     context.trace(`Verifying the '${metaLemmaString}' meta-lemma...`, node);
 

package/src/element/topLevelMetaAssertion/metatheorem.js

@@ -10,8 +10,7 @@ export default define(class Metatheorem extends TopLevelMetaAssertion {
 
     const node = this.getNode(),
           context = this.getContext(),
-          metaLemma = this, ///
-          metaLemmaString = metaLemma.getString();
+          metaLemmaString = this.getString(); ///
 
     context.trace(`Verifying the '${metaLemmaString}' metatheorem...`, node);
 

package/src/element/topLevelMetaAssertion.js

@@ -1,8 +1,8 @@
 "use strict";
 
 import Element from "../element";
-import ScopedContext from "../context/scoped";
 
+import { scope } from "../utilities/context";
 import { labelFromJSON,
          labelToLabelJSON,
          deductionFromJSON,
@@ -56,25 +56,27 @@ export default class TopLevelMetaAssertion extends Element {
   verify() {
     let verifies = false;
 
-    const labelVerifies = this.verifyLabel();
+    const context = this.getContext();
 
-    if (labelVerifies) {
-      const scopedContext = ScopedContext.fromNothing(this.context),
-            context = scopedContext, ///
-            suppositionsVerify = this.verifySuppositions(context);
+    scope((context) => {
+      const labelVerifies = this.verifyLabel();
 
-      if (suppositionsVerify) {
-        const deductionVerifies = this.verifyDeduction(context);
+      if (labelVerifies) {
+        const suppositionsVerify = this.verifySuppositions(context);
 
-        if (deductionVerifies) {
-          const proofVerifies = this.verifyProof(context);
+        if (suppositionsVerify) {
+          const deductionVerifies = this.verifyDeduction(context);
 
-          if (proofVerifies) {
-            verifies = true;
+          if (deductionVerifies) {
+            const proofVerifies = this.verifyProof(context);
+
+            if (proofVerifies) {
+              verifies = true;
+            }
           }
         }
       }
-    }
+    }, context);
 
     return verifies;
   }