occam-verify-cli 1.0.457 → 1.0.473

package/src/element/conclusion.js

@@ -1,9 +1,9 @@
 "use strict";
 
 import Element from "../element";
-import TransientContext from "../context/transient";
 
 import { define } from "../elements";
+import { attempt } from "../utilities/context";
 import { termsFromJSON, framesFromJSON, statementFromJSON, termsToTermsJSON, framesToFramesJSON, statementToStatementJSON } from "../utilities/json";
 
 export  default define(class Conclusion extends Element {
@@ -20,30 +20,28 @@ export  default define(class Conclusion extends Element {
   verify(context) {
     let verifies = false;
 
-    const transientContext = TransientContext.fromNothing(context);
-
-    context = transientContext; ///
-
     const node = this.getNode(),
           conclusionString = this.getString();  ///
 
     context.trace(`Verifying the '${conclusionString}' conclusion...`, node);
 
-    if (this.statement === null) {
-      context.debug(`Unable to verify the '${conclusionString}' conclusion because it is nonsense.`, node);
-    } else {
-      const stated = true,
-            assignments = null,
-            statementValidates = this.statement.validate(assignments, stated, context);
+    if (this.statement !== null) {
+      attempt((context) => {
+        const stated = true,
+              assignments = null,
+              statementValidates = this.statement.validate(assignments, stated, context);
 
-      if (statementValidates) {
-        verifies = true;
-      }
+        if (statementValidates) {
+          this.setContext(context);
+
+          verifies = true;
+        }
+      }, context);
+    } else {
+      context.debug(`Unable to verify the '${conclusionString}' conclusion because it is nonsense.`, node);
     }
 
     if (verifies) {
-      this.setContext(context);
-
       context.debug(`...verified the '${conclusionString}' conclusion.`, node);
     }
 
@@ -108,10 +106,9 @@ export  default define(class Conclusion extends Element {
           frames = framesFromJSON(json, context),
           statement = statementFromJSON(json, context),
           node = null,
-          string = statement.getString(),
-          transientContext = TransientContext.fromTermsAndFrames(terms, frames, context);
+          string = statement.getString();
 
-    context = transientContext; ///
+    context = ephemeralContext; ///
 
     const conclusion = new Conclusion(context, string, node, statement);
 

package/src/element/constructor.js

@@ -27,7 +27,7 @@ export default define(class Constructor extends Element {
     let termUnifies = false;
 
     const termString = term.getString(),
-          constructorString = this.getString();
+          constructorString = this.getString(); ///
 
     context.trace(`Unifying the '${termString}' term with the '${constructorString}' constructor...`);
 

package/src/element/deduction.js

@@ -1,9 +1,10 @@
 "use strict";
 
 import Element from "../element";
-import TransientContext from "../context/transient";
+import EphemeralContext from "../context/ephemeral";
 
 import { define } from "../elements";
+import { attempt } from "../utilities/context";
 import { termsFromJSON, framesFromJSON, statementFromJSON, termsToTermsJSON, framesToFramesJSON, statementToStatementJSON } from "../utilities/json";
 
 export default define(class Deduction extends Element {
@@ -20,30 +21,28 @@ export default define(class Deduction extends Element {
   verify(context) {
     let verifies = false;
 
-    const transientContext = TransientContext.fromNothing(context);
-
-    context = transientContext; ///
-
     const node = this.getNode(),
           deductionString = this.getString();  ///
 
     context.trace(`Verifying the '${deductionString}' deduction...`, node);
 
-    if (this.statement === null) {
-      context.debug(`Unable to verify the '${deductionString}' deduction because it is nonsense.`, node);
-    } else {
-      const stated = true,
-            assignments = null,
-            statementVealidates = this.statement.validate(assignments, stated, context);
+    if (this.statement !== null) {
+      attempt((context) => {
+        const stated = true,
+              assignments = null,
+              statementValidates = this.statement.validate(assignments, stated, context);
+
+        if (statementValidates) {
+          this.setContext(context);
 
-      if (statementVealidates) {
-        verifies = true;
-      }
+          verifies = true;
+        }
+      }, context);
+    } else {
+      context.debug(`Unable to verify the '${deductionString}' deduction because it is nonsense.`, node);
     }
 
     if (verifies) {
-      this.setContext(context);
-
       context.debug(`...verified the '${deductionString}' deduction.`, node);
     }
 
@@ -132,11 +131,7 @@ export default define(class Deduction extends Element {
     const terms = termsFromJSON(json, context),
           frames = framesFromJSON(json, context),
           statement = statementFromJSON(json, context),
-          node = null,
-          string = statement.getString(),
-          transientContext = TransientContext.fromTermsAndFrames(terms, frames, context);
-
-    context = transientContext; ///
+          string = statement.getString();
 
     const deduction = new Deduction(context, string, statement);
 

package/src/element/derivation.js

@@ -27,12 +27,12 @@ export default define(class Derivation extends Element {
     return lastProofAssertion;
   }
 
-  verify(substitutions, context) {
+  verify(context) {
     let verifies;
 
     verifies = this.subproofOrProofAssertions.every((subproofOrProofAssertion) => { ///
       const assignments = [],
-            subproofOrProofAssertionVerifies = subproofOrProofAssertion.verify(substitutions, assignments, context);
+            subproofOrProofAssertionVerifies = subproofOrProofAssertion.verify(assignments, context);
 
       if (subproofOrProofAssertionVerifies) {
         const assignmentsAssigned = assignAssignments(assignments, context);

package/src/element/equality.js

@@ -76,7 +76,7 @@ export default define(class Equality extends Element {
   verify(assignments, stated, context) {
     let verifies = false;
 
-    const equalityString = this.string; ///
+    const equalityString = this.getString(); ///
 
     context.trace(`Verifying the '${equalityString}' equality...`);
 
@@ -113,7 +113,7 @@ export default define(class Equality extends Element {
   verifyTerms(context) {
     let termsVerify;
 
-    const equalityString = this.string; ///
+    const equalityString = this.getString(); ///
 
     context.trace(`Verifying the '${equalityString}' equality's terms...`);
 
@@ -149,7 +149,7 @@ export default define(class Equality extends Element {
   verifyWhenStated(assignments, context) {
     let verifiesWhenStated;
 
-    const equalityString = this.string; ///
+    const equalityString = this.getString(); ///
 
     context.trace(`Verifying the '${equalityString}' stated equality...`);
 
@@ -165,7 +165,7 @@ export default define(class Equality extends Element {
   verifyWhenDerived(context) {
     let verifiesWhenDerived;
 
-    const equalityString = this.string; ///
+    const equalityString = this.getString(); ///
 
     context.trace(`Verifying the '${equalityString}' derived equality...`);
 

package/src/element/equivalence.js

@@ -5,10 +5,11 @@ import { arrayUtilities } from "necessary";
 import Element from "../element";
 
 import { define } from "../elements";
+import { literally } from "../utilities/context";
 import { termsStringFromTerms } from "../utilities/string";
 import { instantiateEquivalence } from "../process/instantiate";
 import { stripBracketsFromTermNode } from "../utilities/brackets";
-import { equalivanceFromEquivalenceNode } from "../utilities/element";
+import { equivalenceFromEquivalenceNode } from "../utilities/element";
 
 const { compress } = arrayUtilities;
 
@@ -22,40 +23,6 @@ export default define(class Equivalence extends Element {
     return this.terms;
   }
 
-  addTerm(term, context) {
-    const termString = term.getString(),
-          equivalenceString = this.asString(); ///
-
-    context.trace(`Adding the '${termString}' term to the '${equivalenceString}' equivalence...`);
-
-    const termA = term, ///
-          termPresent = this.someTerm((term) => {
-            const termB = term, ///
-                  termAEqualToTermB = termA.isEqualTo(termB);
-
-            if (termAEqualToTermB) {
-              return true;
-            }
-          });
-
-    if (!termPresent) {
-      this.terms.push(term);
-
-      const termsString = termsStringFromTerms(this.terms),
-            string = termsString,  ///
-            equalivanceNode = instantiateEquivalence(string, context),
-            equalivance = equalivanceFromEquivalenceNode(equalivanceNode, context);
-
-      this.node = equalivance.getNode();
-
-      this.string = equalivance.getString();
-
-      const equivalenceString = this.string; ///
-
-      context.debug(`...added the '${termString}' term to the '${equivalenceString}' equivalence.`);
-    }
-  }
-
   getType() {
     const type = this.terms.reduce((type, term) => {
       const termType = term.getType();
@@ -76,6 +43,89 @@ export default define(class Equivalence extends Element {
     return type;
   }
 
+  getGroundedTerms(definedVariables, groundedTerms, context) {
+    this.terms.forEach((term) => {
+      const termGrounded = term.isGrounded(definedVariables, context);
+
+      if (termGrounded) {
+        const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
+          const groundedTermNode = groundedTerm.getNode(),
+                groundedTermNodeMatches = term.matchNode(groundedTermNode);
+
+          if (groundedTermNodeMatches) {
+            return true;
+          }
+        })
+
+        if (!termMatchesGroundedTerm) {
+          const groundedTerm = term;
+
+          groundedTerms.push(groundedTerm);
+        }
+      }
+    });
+  }
+
+  getInitiallyGroundedTerms(context) {
+    const initiallyGroundedTerms = this.terms.reduce((initiallyGroundedTerms, term) => {
+      const termInitiallyGrounded = term.isInitiallyGrounded(context);
+
+      if (termInitiallyGrounded) {
+        const initiallyGroundedTerm = term; ///
+
+        initiallyGroundedTerms.push(initiallyGroundedTerm);
+      }
+
+      return initiallyGroundedTerms;
+    }, []);
+
+    return initiallyGroundedTerms;
+  }
+
+  getImplicitlyGroundedTerms(definedVariables, context) {
+    const implicitlyGroundedTerms = this.terms.reduce((implicitlyGroundedTerms, term) => {
+      const termImplicitlyGrounded = term.isImplicitlyGrounded(definedVariables, context);
+
+      if (termImplicitlyGrounded) {
+        const implicitlyGroundedTerm = term; ///
+
+        implicitlyGroundedTerms.push(implicitlyGroundedTerm);
+      }
+
+      return implicitlyGroundedTerms;
+    }, []);
+
+    return implicitlyGroundedTerms;
+  }
+
+  isDisjointFrom(equivalence) {
+    const disjointFrom = equivalence.everyTerm((term) => {
+      const comparesToTerm = this.compareTerm(term);
+
+      if (!comparesToTerm) {
+        return true;
+      }
+    });
+
+    return disjointFrom;
+  }
+
+  isInitiallyGrounded(context) {
+    const initiallyGroundedTerms = this.getInitiallyGroundedTerms(context),
+          initiallyGroundedTermsLength = initiallyGroundedTerms.length,
+          initiallyGrounded = (initiallyGroundedTermsLength > 0);
+
+    return initiallyGrounded;
+  }
+
+  isImplicitlyGrounded(definedVariables, context) {
+    const implicitlyGroundedTerms = this.getImplicitlyGroundedTerms(definedVariables, context),
+          implicitlyGroundedTermsLength = implicitlyGroundedTerms.length,
+          implicitlyGrounded = (implicitlyGroundedTermsLength > 0);
+
+    return implicitlyGrounded;
+  }
+
   compareTerm(term) {
     const termA = term, ///
           comparesToTerm = this.someTerm((term) => {
@@ -135,41 +185,6 @@ export default define(class Equivalence extends Element {
     return variableNodeMatches;
   }
 
-  isDisjointFrom(equivalence) {
-    const disjointFrom = equivalence.everyTerm((term) => {
-      const comparesToTerm = this.compareTerm(term);
-
-      if (!comparesToTerm) {
-        return true;
-      }
-    });
-
-    return disjointFrom;
-  }
-
-  mergedWith(equivalence) {
-    const equivalenceA = this,
-          equivalenceB = equivalence, ///
-          equivalenceATerms = equivalenceA.getTerms(),
-          equivalenceTermsB = equivalenceB.getTerms(),
-          terms = [
-            ...equivalenceATerms,
-            ...equivalenceTermsB
-          ];
-
-    compress(terms, (termA, termB) => {
-      const termAEqualToTermB = termA.isEqualTo(termB);
-
-      if (!termAEqualToTermB) {
-        return true;
-      }
-    });
-
-    equivalence = new Equivalence(terms);
-
-    return equivalence;
-  }
-
   someTerm(callback) { return this.terms.some(callback); }
 
   everyTerm(callback) { return this.terms.every(callback); }
@@ -189,84 +204,49 @@ export default define(class Equivalence extends Element {
     return result;
   }
 
-  getGroundedTerms(definedVariables, groundedTerms, context) {
-    this.terms.forEach((term) => {
-      const termGrounded = term.isGrounded(definedVariables, context);
+  combineTerms(terms) {
+    const combinedTerms = [
+      ...this.terms,
+      ...terms
+    ];
 
-      if (termGrounded) {
-        const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
-          const groundedTermNode = groundedTerm.getNode(),
-                groundedTermNodeMatches = term.matchNode(groundedTermNode);
+    compress(combinedTerms, (combinedTermA, combinedTermB) => {
+      const combinedTermAEqualToCombinedTermB = combinedTermA.isEqualTo(combinedTermB);
 
-          if (groundedTermNodeMatches) {
-            return true;
-          }
-        })
-
-        if (!termMatchesGroundedTerm) {
-          const groundedTerm = term;
-
-          groundedTerms.push(groundedTerm);
-        }
+      if (!combinedTermAEqualToCombinedTermB) {
+        return true;
       }
     });
-  }
-
-  isInitiallyGrounded(context) {
-    const initiallyGroundedTerms = this.getInitiallyGroundedTerms(context),
-          initiallyGroundedTermsLength = initiallyGroundedTerms.length,
-          initiallyGrounded = (initiallyGroundedTermsLength > 0);
 
-    return initiallyGrounded;
+    return combinedTerms;
   }
 
-  isImplicitlyGrounded(definedVariables, context) {
-    const implicitlyGroundedTerms = this.getImplicitlyGroundedTerms(definedVariables, context),
-          implicitlyGroundedTermsLength = implicitlyGroundedTerms.length,
-          implicitlyGrounded = (implicitlyGroundedTermsLength > 0);
-
-    return implicitlyGrounded;
-  }
-
-  getInitiallyGroundedTerms(context) {
-    const initiallyGroundedTerms = this.terms.reduce((initiallyGroundedTerms, term) => {
-      const termInitiallyGrounded = term.isInitiallyGrounded(context);
-
-      if (termInitiallyGrounded) {
-        const initiallyGroundedTerm = term; ///
-
-        initiallyGroundedTerms.push(initiallyGroundedTerm);
-      }
+  mergedWith(equivalence, context) {
+    const terms = equivalence.getTerms(),
+          combinedTerms = this.combineTerms(terms);
 
-      return initiallyGroundedTerms;
-    }, []);
+    return literally((context) => {
+      const terms = combinedTerms,  ///
+            termsString = termsStringFromTerms(terms),
+            string = termsString,  ///
+            equivalenceNode = instantiateEquivalence(string, context),
+            equivalence = equivalenceFromEquivalenceNode(equivalenceNode, context);
 
-    return initiallyGroundedTerms;
+      return equivalence;
+    }, context);
   }
 
-  getImplicitlyGroundedTerms(definedVariables, context) {
-    const implicitlyGroundedTerms = this.terms.reduce((implicitlyGroundedTerms, term) => {
-      const termImplicitlyGrounded = term.isImplicitlyGrounded(definedVariables, context);
-
-      if (termImplicitlyGrounded) {
-        const implicitlyGroundedTerm = term; ///
-
-        implicitlyGroundedTerms.push(implicitlyGroundedTerm);
-      }
-
-      return implicitlyGroundedTerms;
-    }, []);
-
-    return implicitlyGroundedTerms;
-  }
+  static name = "Equivalence";
 
   static fromEquality(equality, context) {
-    const terms = equality.getTerms(),
-          termsString = termsStringFromTerms(terms),
-          string = termsString,  ///
-          equalivanceNode = instantiateEquivalence(string, context),
-          equalivance = equalivanceFromEquivalenceNode(equalivanceNode, context);
+    return literally((context) => {
+      const terms = equality.getTerms(),
+            termsString = termsStringFromTerms(terms),
+            string = termsString,  ///
+            equivalenceNode = instantiateEquivalence(string, context),
+            equivalence = equivalenceFromEquivalenceNode(equivalenceNode, context);
 
-    return equalivance;
+      return equivalence;
+    }, context);
   }
 });

package/src/element/equivalences.js

@@ -73,18 +73,18 @@ export default define(class Equivalences extends Element {
     return equivalence;
   }
 
-  mergedWith(equivalences) {
+  mergedWith(equivalences, context) {
     let  mergedEquivalences = this.clone(); ///
 
     equivalences.forEachEquivalence((equivalence) => {
-      mergedEquivalences = mergedEquivalences.mergedWithEquivalence(equivalence);
+      mergedEquivalences = mergedEquivalences.mergedWithEquivalence(equivalence, context);
     });
 
     return mergedEquivalences;
   }
 
-  mergedWithEquivalence(equivalence) {
-    const equivalences = Equivalences.fromNothing();
+  mergedWithEquivalence(equivalence, context) {
+    const equivalences = Equivalences.fromNothing(context);
 
     let mergedEquivalence = equivalence; ///
 
@@ -94,7 +94,7 @@ export default define(class Equivalences extends Element {
       if (mergedEquivalenceDisjointFromEquivalence) {
         equivalences.addEquivalence(equivalence);
       } else {
-        mergedEquivalence = mergedEquivalence.mergedWith(equivalence);
+        mergedEquivalence = mergedEquivalence.mergedWith(equivalence, context);
       }
     });
 
@@ -139,9 +139,9 @@ export default define(class Equivalences extends Element {
         initiallyGroundedEquivalences,
         implicitlyGroundedEquivalences;
 
-    remainingEquivalences =Equivalences.fromNothing();
+    remainingEquivalences =Equivalences.fromNothing(context);
 
-    initiallyGroundedEquivalences = Equivalences.fromNothing();
+    initiallyGroundedEquivalences = Equivalences.fromNothing(context);
 
     equivalences.separateInitiallyGroundedEquivalences(remainingEquivalences, initiallyGroundedEquivalences, context);
 
@@ -190,6 +190,8 @@ export default define(class Equivalences extends Element {
     return equivalences;
   }
 
+  static name = "Equivalences";
+
   static fromNothing(context) {
     const string = EMPTY_STRING,
           node = null,

package/src/element/error.js

@@ -12,9 +12,11 @@ export default define(class Error extends Element {
   verify() {
     let verifies = false;
 
-    const errorString = this.string;  ///
+    const node = this.getNode(),
+          context = this.getContext(),
+          errorString = this.getString();  ///
 
-    this.context.warning(`The '${errorString}' error cannot be verified.`, this.node);
+    context.warning(`The '${errorString}' error cannot be verified.`, node);
 
     return verifies;
   }