occam-verify-cli 1.0.448 → 1.0.472

package/src/element/assumption.js

@@ -34,7 +34,7 @@ export default define(class Assumption extends Element {
   compareSubstitution(substitution, context) {
     let comparesToSubstituion = false;
 
-    const assumptionString = this.string,  ///
+    const assumptionString = this.getString(),  ///
           substitutionString = substitution.getString();
 
     context.trace(`Comparing the '${assumptionString}' assumption to the '${substitutionString}' substitution...`);
@@ -71,75 +71,59 @@ export default define(class Assumption extends Element {
     return comparesToSubstituion;
   }
 
-  verify(assignments, stated, context) {
-    let verifies = false;
+  validate(assignments, stated, context) {
+    let validates = false;
 
-    const assumptionString = this.string;  ///
+    const assumptionString = this.getString();  ///
 
-    context.trace(`Verifying the '${assumptionString}' assumption...`);
+    context.trace(`Validating the '${assumptionString}' assumption...`);
 
     const simple = this.isSimple();
 
     if (simple) {
-      const referenceVerifiesAsMetavariable = this.verifyReferenceAsMetavariable(assignments, stated, context);
+      const referenceValidatesAsMetavariable = this.validateReferenceAsMetavariable(assignments, stated, context);
 
-      verifies = referenceVerifiesAsMetavariable; ///
+      if (referenceValidatesAsMetavariable) {
+        validates = true;
+      }
     } else {
-      const referenceVerified = this.verifyReference(assignments, stated, context);
+      const referenceValidates = this.reference.validate(context);
 
-      if (referenceVerified) {
+      if (referenceValidates) {
         const statementValidates = this.validateStatement(assignments, stated, context);
 
         if (statementValidates) {
-          let verifiesWhenStated = false,
-              verifiesWhenDerived = false;
+          let validatesWhenStated = false,
+              validatesWhenDerived = false;
 
           if (stated) {
-            verifiesWhenStated = this.verifyWhenStated(assignments, context);
+            validatesWhenStated = this.validateWhenStated(assignments, context);
           } else {
-            verifiesWhenDerived = this.verifyWhenDerived(context);
+            validatesWhenDerived = this.validateWhenDerived(context);
           }
 
-          if (verifiesWhenStated || verifiesWhenDerived) {
-            verifies = true;
+          if (validatesWhenStated || validatesWhenDerived) {
+            validates = true;
           }
         }
       }
 
-      if (verifies) {
-        context.debug(`...verified the '${assumptionString}' assumption.`);
+      if (validates) {
+        context.debug(`...validated the '${assumptionString}' assumption.`);
       }
     }
 
-    return verifies;
-  }
-
-  verifyReference(assignments, stated, context) {
-    let referenceVerified;
-
-    const referenceString = this.reference.getString(),
-          assumptionString = this.string; ///
-
-    context.trace(`Verifying the '${assumptionString}' assumption's '${referenceString}' reference...`);
-
-    referenceVerified = this.reference.verify(context);
-
-    if (referenceVerified) {
-      context.debug(`...verified the '${assumptionString}' assumption's '${referenceString}' reference.`);
-    }
-
-    return referenceVerified;
+    return validates;
   }
 
   validateStatement(assignments, stated, context) {
-    let statementValidates;
+    let statementValidates = true;  ///
 
-    if (this.statement === null) {
-      statementValidates = true;
-    } else {
-      const statementString = this.statement.getString();
+    if (this.statement !== null) {
+      const assumptionString = this.getString(),
+            statementString = this.statement.getString();
 
-      context.trace(`Validating the '${statementString}' statement...`);
+      context.trace(`Validating the '${assumptionString}' assumption's '${statementString}' statement...`);
 
       stated = true;  ///
 
@@ -148,83 +132,77 @@ export default define(class Assumption extends Element {
       statementValidates = this.statement.validate(assignments, stated, context);
 
       if (statementValidates) {
-        context.debug(`...validated the '${statementString}' statement.`);
+        context.debug(`...validated the '${assumptionString}' assumption's '${statementString}' statement.`);
       }
     }
 
     return statementValidates;
   }
 
-  verifyReferenceAsMetavariable(assignments, stated, context) {
-    let referenceVerifiesAsMetavariable = false;
+  validateReferenceAsMetavariable(assignments, stated, context) {
+    let referenceValidatesAsMetavariable;
 
     const referenceString = this.reference.getString(),
-          assumptionString = this.string; ///
+          assumptionString = this.getString(); ///
 
-    context.trace(`Verifying the '${assumptionString}' assumption's '${referenceString}' reference as s metavariable...`);
+    context.trace(`Validating the '${assumptionString}' assumption's '${referenceString}' reference as s metavariable...`);
 
-    const metavariable = this.reference.getMetavariable(),
-          metavariableName = metavariable.getName(),
-          metavariablePresent = context.isMetavariablePresentByMetavariableName(metavariableName);
-
-    if (metavariablePresent) {
-      referenceVerifiesAsMetavariable = true;
-    }
+    referenceValidatesAsMetavariable = this.reference.validateAsMetavariable(context);
 
-    if (referenceVerifiesAsMetavariable) {
-      context.debug(`...verified the '${assumptionString}' assumption's '${referenceString}' reference as a metavariable.`);
+    if (referenceValidatesAsMetavariable) {
+      context.debug(`...validated the '${assumptionString}' assumption's '${referenceString}' reference as a metavariable.`);
     }
 
-    return referenceVerifiesAsMetavariable;
+    return referenceValidatesAsMetavariable;
   }
 
-  verifyWhenStated(assignments, context) {
-    let verifiesWhenStated;
+  validateWhenStated(assignments, context) {
+    let validatesWhenStated;
 
-    const assumptionString = this.string;  ///
+    const assumptionString = this.getString();  ///
 
-    context.trace(`Verifying the '${assumptionString}' stated assumption...`);
+    context.trace(`Validating the '${assumptionString}' stated assumption...`);
 
     const metavariablePresent = context.isMetavariablePresentByReference(this.reference);
 
     if (metavariablePresent) {
-      verifiesWhenStated = true;
+      validatesWhenStated = true;
     } else {
-      const metaLemmaMetatheorems = context.findMetaLemmaMetatheoremsByReference(this.reference),
-            metaLemmaMetatheoremsUnify = metaLemmaMetatheorems.every((metaLemmaMetatheorem) => {
-              const metaLemmaMetatheoremUnifies = this.unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context);
+      const topLevelMetaAssertions = context.findTopLevelMetaAssertionsByReference(this.reference),
+            topLevelMetaAssertionsUnify = topLevelMetaAssertions.every((topLevelMetaAssertion) => {
+              const topLevelMetaAssertionUnifies = this.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
 
-              if (metaLemmaMetatheoremUnifies) {
+              if (topLevelMetaAssertionUnifies) {
                 return true;
               }
             });
 
-      verifiesWhenStated = metaLemmaMetatheoremsUnify; ///
+      validatesWhenStated = topLevelMetaAssertionsUnify; ///
     }
 
-    if (verifiesWhenStated) {
-      context.debug(`...verified the '${assumptionString}' stated assumption.`);
+    if (validatesWhenStated) {
+      context.debug(`...validated the '${assumptionString}' stated assumption.`);
     }
 
-    return verifiesWhenStated;
+    return validatesWhenStated;
   }
 
-  verifyWhenDerived(context) {
-    let verifiesWhenDerived;
+  validateWhenDerived(context) {
+    let validatesWhenDerived;
 
-    const assumptionString = this.string;  ///
+    const assumptionString = this.getString();  ///
 
-    context.trace(`Verifying the '${assumptionString}' derived assumption...`);
+    context.trace(`Validating the '${assumptionString}' derived assumption...`);
 
-    const metaLemmaMetatheoremPresent = context.isMetaLemmaMetatheoremPresentByReference(this.reference);
+    const topLevelMetaAssertionPresent = context.isTopLevelMetaAssertionPresentByReference(this.reference);
 
-    verifiesWhenDerived = metaLemmaMetatheoremPresent; ///
+    validatesWhenDerived = topLevelMetaAssertionPresent; ///
 
-    if (verifiesWhenDerived) {
-      context.debug(`...verified the '${assumptionString}' derived assumption.`);
+    if (validatesWhenDerived) {
+      context.debug(`...validated the '${assumptionString}' derived assumption.`);
     }
 
-    return verifiesWhenDerived;
+    return validatesWhenDerived;
   }
 
   unifyStatement(statement, substitutions, generalContext, specificContext) {
@@ -260,7 +238,7 @@ export default define(class Assumption extends Element {
 
     const context = generalContext, ///
           labelString = label.getString(),
-          assumptionString = this.string;  //;/
+          assumptionString = this.getString();  //;/
 
     context.trace(`Unifying the '${labelString}' label with the '${assumptionString}' assumption...`);
 
@@ -275,28 +253,28 @@ export default define(class Assumption extends Element {
     return labelUnifiesWithReference;
   }
 
-  unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context) {
-    let metaLemmaMetatheoremUnifies = false;
+  unifyTopLevelMetaAssertion(topLevelMetaAssertion, context) {
+    let topLevelMetaAssertionUnifies = false;
 
-    const assumptionString = this.string,  ///
-          metaLemmaMetatheoremString = metaLemmaMetatheorem.getString();
+    const assumptionString = this.getString(),  ///
+          topLevelMetaAssertionString = topLevelMetaAssertion.getString();
 
-    context.trace(`Unifying the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${assumptionString}' assumption...`);
+    context.trace(`Unifying the '${topLevelMetaAssertionString}' top level meta-assertion with the '${assumptionString}' assumption...`);
 
     const generalContext = context; ///
 
-    context = metaLemmaMetatheorem.getContext();  ///
+    context = topLevelMetaAssertion.getContext();  ///
 
     const { Substitutions } = elements,
           specificContext = context,  ///
-          labelSubstitutions = Substitutions.fromNothing(),
-          label = metaLemmaMetatheorem.getLabel(),
+          labelSubstitutions = Substitutions.fromNothing(context),
+          label = topLevelMetaAssertion.getLabel(),
           substitutions = labelSubstitutions, ///
           labelUnifies = this.unifyLabel(label, substitutions, generalContext, specificContext);
 
     if (labelUnifies) {
-      const statementSubstitutions = Substitutions.fromNothing(),
-            statement = metaLemmaMetatheorem.getStatement(),
+      const statementSubstitutions = Substitutions.fromNothing(context),
+            statement = topLevelMetaAssertion.getStatement(),
             substitutions = statementSubstitutions, ///
             statementUUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
 
@@ -304,18 +282,18 @@ export default define(class Assumption extends Element {
         const labelSubstitutionsCorrelateStatementSubstitutions = labelSubstitutions.correlateSubstitutions(statementSubstitutions);
 
         if (labelSubstitutionsCorrelateStatementSubstitutions) {
-          metaLemmaMetatheoremUnifies = true; ///
+          topLevelMetaAssertionUnifies = true; ///
         }
       }
     }
 
-    if (metaLemmaMetatheoremUnifies) {
+    if (topLevelMetaAssertionUnifies) {
       context = generalContext; ///
 
-      context.trace(`...unified the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${assumptionString}' assumption...`);
+      context.trace(`...unified the '${topLevelMetaAssertionString}' top level meta-assertion with the '${assumptionString}' assumption...`);
     }
 
-    return metaLemmaMetatheoremUnifies;
+    return topLevelMetaAssertionUnifies;
   }
 
   toJSON() {

package/src/element/combinator/bracketed.js

@@ -3,7 +3,6 @@
 import Combinator from "../combinator";
 
 import { define } from "../../elements";
-import { bracketedCombinatorFromNothing } from "../../utilities/instance";
 
 export default define(class BracketedCombinator extends Combinator {
   unifyStatement(statement, assignments, stated, context) {
@@ -23,10 +22,4 @@ export default define(class BracketedCombinator extends Combinator {
   }
 
   static name = "BracketedCombinator";
-
-  static fromNothing() {
-    const bracketedCombinator = bracketedCombinatorFromNothing();
-
-    return bracketedCombinator;
-  }
 });

package/src/element/conclusion.js

@@ -1,9 +1,9 @@
 "use strict";
 
 import Element from "../element";
-import TemporaryContext from "../context/temporary";
 
 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 temporaryContext = TemporaryContext.fromNothing(context);
-
-    context = temporaryContext; ///
-
     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) {
+          this.setContext(context);
 
-      if (statementValidates) {
-        verifies = true;
-      }
+          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);
     }
 
@@ -53,14 +51,18 @@ export  default define(class Conclusion extends Element {
   unifyStatement(statement, substitutions, context) {
     let statementUnifies;
 
-    const conclusion = this,  ///
-          statementString = statement.getString(),
-          conclusionString = conclusion.getString();
+    const statementString = statement.getString(),
+          conclusionString = this.getString();  ///
 
     context.trace(`Unifying the '${statementString}' statement with the '${conclusionString}' conclusion...`);
 
-    const generalContext = this.context,  ///
-          specificContext = context;  ///
+    const specificContext = context;  ///
+
+    context = this.getContext();
+
+    const generalContext = context;  ///
+
+    context = specificContext;  ///
 
     statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
 
@@ -104,10 +106,9 @@ export  default define(class Conclusion extends Element {
           frames = framesFromJSON(json, context),
           statement = statementFromJSON(json, context),
           node = null,
-          string = statement.getString(),
-          temporaryContext = TemporaryContext.fromTermsAndFrames(terms, frames, context);
+          string = statement.getString();
 
-    context = temporaryContext; ///
+    context = ephemeralContext; ///
 
     const conclusion = new Conclusion(context, string, node, statement);
 

package/src/element/constructor/bracketed.js

@@ -4,7 +4,6 @@ import elements from "../../elements";
 import Constructor from "../constructor";
 
 import { define } from "../../elements";
-import { bracketedConstructorFromNothing } from "../../utilities/instance";
 
 export default define(class BracketedConstructor extends Constructor {
   unifyTerm(term, context, verifyAhead) {
@@ -53,10 +52,4 @@ export default define(class BracketedConstructor extends Constructor {
   }
 
   static name = "BracketedConstructor";
-
-  static fromNothing() {
-    const bracketedConstructor = bracketedConstructorFromNothing();
-
-    return bracketedConstructor;
-  }
 });

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/declaration/combinator.js

@@ -3,7 +3,6 @@
 import Declaration from "../declaration";
 
 import { define } from "../../elements";
-import { verifyStatement } from "../../process/verify";
 
 export default define(class CombinatorDeclaration extends Declaration {
   constructor(context, string, node, combinator) {

package/src/element/declaration/metavariable.js

@@ -76,7 +76,7 @@ export default define(class MetavariableDeclaration extends Declaration {
           context = this.getContext(),
           metavariableString = metavariable.getString();
 
-    context.trace(`Verifying the '${metavariableString}' metavariable when declared...`, node);
+    context.trace(`Verifying the '${metavariableString}' metavariable...`, node);
 
     const metavariableNode = metavariable.getNode(), ///
           termNode = metavariableNode.getTermNode();
@@ -98,7 +98,7 @@ export default define(class MetavariableDeclaration extends Declaration {
     }
 
     if (metavariableVerifies) {
-      context.debug(`...verified the '${metavariableString}' metavariable when declared.`, node);
+      context.debug(`...verified the '${metavariableString}' metavariable.`, node);
     }
 
     return metavariableVerifies;

package/src/element/declaration/variable.js

@@ -65,7 +65,7 @@ export default define(class VariableDeclaration extends Declaration {
       context.debug(`...verified the '${variableString}' variable.`, node);
     }
 
-    return  variableVerifies;
+    return variableVerifies;
   }
 
   verifyVariableType() {
@@ -82,7 +82,9 @@ export default define(class VariableDeclaration extends Declaration {
 
     context.trace(`Verifying the '${typeString}' type...`, node);
 
-    const nominalTypeName = type.getNominalTypeName();
+    const includeSupertypes = false,
+          provisional = type.isProvisional(includeSupertypes),
+          nominalTypeName = type.getNominalTypeName();
 
     type = context.findTypeByNominalTypeName(nominalTypeName);
 
@@ -91,9 +93,7 @@ export default define(class VariableDeclaration extends Declaration {
     if (!typePresent) {
       context.debug(`The '${typeString}' type is not present.`, node);
     } else {
-      const includeSupertypes = false,
-            provisional = type.isProvisional(includeSupertypes),
-            typeComparesToProvisional = type.compareProvisional(provisional);
+      const typeComparesToProvisional = type.compareProvisional(provisional);
 
       if (!typeComparesToProvisional) {
         provisional ?

package/src/element/deduction.js

@@ -1,9 +1,10 @@
 "use strict";
 
 import Element from "../element";
-import TemporaryContext from "../context/temporary";
+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 temporaryContext = TemporaryContext.fromNothing(context);
-
-    context = temporaryContext; ///
-
     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 (statementVealidates) {
-        verifies = true;
-      }
+        if (statementValidates) {
+          this.setContext(context);
+
+          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);
     }
 
@@ -53,14 +52,18 @@ export default define(class Deduction extends Element {
   unifyStatement(statement, substitutions, context) {
     let statementUnifies;
 
-    const deduction = this,  ///
-          statementString = statement.getString(),
-          deductionString = deduction.getString();
+    const statementString = statement.getString(),
+          deductionString = this.getString();  ///
 
     context.trace(`Unifying the '${statementString}' statement with the '${deductionString}' deduction...`);
 
-    const generalContext = this.context,  ///
-          specificContext = context;  ///
+    const specificContext = context;  ///
+
+    context = this.getContext();
+
+    const generalContext = context;  ///
+
+    context = specificContext;  ///
 
     statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
 
@@ -72,22 +75,25 @@ export default define(class Deduction extends Element {
   }
 
   unifyDeduction(deduction, substitutions, generalContext, specificContext) {
-    let deductionUnifies;
+    let deductionUnifies = false;
 
     const context = specificContext,  ///
+          generalDeduction = this,  ///
           specificDeduction = deduction,  ///
-          generalDeductionString = this.string, ///
+          generalDeductionString = generalDeduction.getString(),
           specificDeductionString = specificDeduction.getString();
 
-    context.trace(`Unifying the '${specificDeductionString}' deduction with the '${generalDeductionString}' deduction...`, this.node);
+    context.trace(`Unifying the '${specificDeductionString}' deduction with the '${generalDeductionString}' deduction...`);
 
     const statement = specificDeduction.getStatement(),
           statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
 
-    deductionUnifies = statementUnifies;  ///
+    if (statementUnifies) {
+      deductionUnifies = true;
+    }
 
     if (deductionUnifies) {
-      context.debug(`...unified the '${specificDeductionString}' deduction with the '${generalDeductionString}' deduction.`, this.node);
+      context.debug(`...unified the '${specificDeductionString}' deduction with the '${generalDeductionString}' deduction.`);
     }
 
     return deductionUnifies;
@@ -125,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(),
-          temporaryContext = TemporaryContext.fromTermsAndFrames(terms, frames, context);
-
-    context = temporaryContext; ///
+          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);