occam-verify-cli 1.0.444 → 1.0.457

package/src/element/deduction.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import Element from "../element";
-import TemporaryContext from "../context/temporary";
+import TransientContext from "../context/transient";
 
 import { define } from "../elements";
 import { termsFromJSON, framesFromJSON, statementFromJSON, termsToTermsJSON, framesToFramesJSON, statementToStatementJSON } from "../utilities/json";
@@ -20,9 +20,9 @@ export default define(class Deduction extends Element {
   verify(context) {
     let verifies = false;
 
-    const temporaryContext = TemporaryContext.fromNothing(context);
+    const transientContext = TransientContext.fromNothing(context);
 
-    context = temporaryContext; ///
+    context = transientContext; ///
 
     const node = this.getNode(),
           deductionString = this.getString();  ///
@@ -53,14 +53,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 +76,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;
@@ -127,9 +134,9 @@ export default define(class Deduction extends Element {
           statement = statementFromJSON(json, context),
           node = null,
           string = statement.getString(),
-          temporaryContext = TemporaryContext.fromTermsAndFrames(terms, frames, context);
+          transientContext = TransientContext.fromTermsAndFrames(terms, frames, context);
 
-    context = temporaryContext; ///
+    context = transientContext; ///
 
     const deduction = new Deduction(context, string, statement);
 

package/src/element/derivation.js

@@ -10,35 +10,35 @@ import { define } from "../elements";
 const { last } = arrayUtilities;
 
 export default define(class Derivation extends Element {
-  constructor(context, string, node, stepsOrSubproofs) {
+  constructor(context, string, node, subproofOrProofAssertions) {
     super(context, string, node);
 
-    this.stepsOrSubproofs = stepsOrSubproofs;
+    this.subproofOrProofAssertions = subproofOrProofAssertions;
   }
 
-  getStepsOrSubproofs() {
-    return this.stepsOrSubproofs;
+  getSubproofOrProofAssertions() {
+    return this.subproofOrProofAssertions;
   }
 
-  getLastStep() {
-    const lastStepOrSubproof = last(this.stepsOrSubproofs),
-          lastStep = lastStepOrSubproof;  ///
+  getLastProofAssertion() {
+    const lastSubproofOrProofAssertion = last(this.subproofOrProofAssertions),
+          lastProofAssertion = lastSubproofOrProofAssertion;  ///
 
-    return lastStep;
+    return lastProofAssertion;
   }
 
   verify(substitutions, context) {
     let verifies;
 
-    verifies = this.stepsOrSubproofs.every((stepOrSubproof) => { ///
+    verifies = this.subproofOrProofAssertions.every((subproofOrProofAssertion) => { ///
       const assignments = [],
-            stepOrSubproofVerifies = stepOrSubproof.verify(substitutions, assignments, context);
+            subproofOrProofAssertionVerifies = subproofOrProofAssertion.verify(substitutions, assignments, context);
 
-      if (stepOrSubproofVerifies) {
+      if (subproofOrProofAssertionVerifies) {
         const assignmentsAssigned = assignAssignments(assignments, context);
 
         if (assignmentsAssigned) {
-          context.addStepOrSubproof(stepOrSubproof);
+          context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
           return true;
         }

package/src/element/frame.js

@@ -6,7 +6,6 @@ import Element from "../element";
 import elements from "../elements";
 
 import { define } from "../elements";
-import { S, NOTHING } from "../constants";
 import { FRAME_META_TYPE_NAME } from "../metaTypeNames";
 
 const { first } = arrayUtilities;
@@ -115,7 +114,7 @@ export default define(class Frame extends Element {
   compareSubstitutions(substitutions, context) {
     let comparesToSubstitutions;
 
-    const frameString = this.string,  ///
+    const frameString = this.getString(),  ///
           substitutionsString = substitutions.asString();
 
     context.trace(`Comparing the '${frameString}' frame to the '${substitutionsString}' substitutions...`);
@@ -135,114 +134,103 @@ export default define(class Frame extends Element {
     return comparesToSubstitutions;
   }
 
-  verify(assignments, stated, context) {
-    let verifies = false;
+  validate(assignments, stated, context) {
+    let validates = false;
 
-    const frameString = this.string;  ///
+    const frameString = this.getString();  ///
 
-    context.trace(`Verifying the '${frameString}' frame...`);
+    context.trace(`Validating the '${frameString}' frame...`);
 
-    const assumptionsVerify = this.verifyAssumptions(assignments, stated, context);
+    const assumptionsValidate = this.validateAssumptions(assignments, stated, context);
 
-    if (assumptionsVerify) {
-      let verifiesWhenStated = false,
-          verifiesWhenDerived = false;
+    if (assumptionsValidate) {
+      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) {
+    if (validates) {
       const frame = this; ///
 
       context.addFrame(frame);
 
-      context.debug(`...verified the '${frameString}' frame.`);
+      context.debug(`...validated the '${frameString}' frame.`);
     }
 
-    return verifies;
+    return validates;
   }
 
-  verifyWhenStated(assignments, context) {
-    let verifiesWhenStated = false;
+  validateWhenStated(assignments, context) {
+    let validatesWhenStated = false;
 
-    const frameString = this.string;  ///
+    const frameString = this.getString();  ///
 
-    context.trace(`Verifying the '${frameString}' stated frame...`);
+    context.trace(`Validating the '${frameString}' stated frame...`);
 
     const singular = this.isSingular();
 
     if (!singular) {
       context.trace(`The '${frameString}' stated frame must be singular.`);
     } else {
-      verifiesWhenStated = true;
+      validatesWhenStated = true;
     }
 
-    if (verifiesWhenStated) {
-      context.debug(`...verified the '${frameString}' stated frame.`);
+    if (validatesWhenStated) {
+      context.debug(`...validated the '${frameString}' stated frame.`);
     }
 
-    return verifiesWhenStated;
+    return validatesWhenStated;
   }
 
-  verifyWhenDerived(context) {
-    let verifiesWhenDerived;
+  validateWhenDerived(context) {
+    let validatesWhenDerived;
 
-    const frameString = this.string;  ///
+    const frameString = this.getString();  ///
 
     context.trace(`Verifying the '${frameString}' derived frame...`);
 
-    verifiesWhenDerived = true;
+    validatesWhenDerived = true;
 
-    if (verifiesWhenDerived) {
+    if (validatesWhenDerived) {
       context.debug(`...verified the '${frameString}' derived frame.`);
     }
 
-    return verifiesWhenDerived;
+    return validatesWhenDerived;
   }
 
-  verifyAssumptions(assignments, stated, context) {
-    let assumptionsVerify = true;  ///
+  validateAssumptions(assignments, stated, context) {
+    let assumptionsValidate = true;  ///
 
     const length = this.getLength();
 
     if (length > 0) {
-      const sOrNothing = (length > 1) ?
-                           S :
-                             NOTHING,
-            assumptionsString = assumptionsStringFromAssumptions(this.assumptions);
-
-      context.trace(`Verifying the '${assumptionsString}' assumption${sOrNothing}...`);
-
       stated = true;  ///
 
       assignments = null; ///
 
-      assumptionsVerify = this.assumptions.every((assumption) => {
-        const assumptionVerifies = assumption.verify(assignments, stated, context);
+      assumptionsValidate = this.assumptions.every((assumption) => {
+        const assumptionVerifies = assumption.validate(assignments, stated, context);
 
         return assumptionVerifies;
       });
-
-      if (assumptionsVerify) {
-        context.debug(`...verified the '${assumptionsString}' assumption${sOrNothing}.`);
-      }
     }
 
-    return assumptionsVerify;
+    return assumptionsValidate;
   }
 
   validateGivenMetaType(metaType, assignments, stated, context) {
     let validatesGivenMetaType = false;
 
-    const frameString = this.string,  ///
+    const frameString = this.getString(),  ///
           metaTypeString = metaType.getString();
 
     context.trace(`Validatin the '${frameString}' frame given the '${metaTypeString}' meta-type...`);

package/src/element/hypothesis.js

@@ -1,7 +1,6 @@
 "use strict";
 
 import Element from "../element";
-import elements from "../elements";
 import assignAssignments from "../process/assign";
 
 import { define } from "../elements";
@@ -36,11 +35,9 @@ export default define(class Hypothesis extends Element {
         const assignmentsAssigned = assignAssignments(assignments, context);
 
         if (assignmentsAssigned) {
-          const { Step } = elements,
-                step = Step.fromStatement(this.statement, context),
-                stepOrSubproof = step;  ///
+          const subproofOrProofAssertion = this;  ///
 
-          context.addStepOrSubproof(stepOrSubproof);
+          context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
           verifies = true;
         }
@@ -56,26 +53,27 @@ export default define(class Hypothesis extends Element {
     return verifies;
   }
 
-  isEqualToStep(step, context) {
-    let equalToStep = false;
+  compareProofAssertion(proofAssertion, context) {
+    let comparesToProofAssertion = false;
 
-    const stepString = step.getString(),
-          hypothesisString = this.string; ///
+    const node = this.getNode(),
+          hypothesisString = this.getString(), ///
+          proofAssertionString = proofAssertion.getString();
 
-    context.trace(`Is the '${hypothesisString}' hypothesis equal to the '${stepString}' step...`, this.node);
+    context.trace(`Is the '${hypothesisString}' hypothesis equal to the '${proofAssertionString}' proof assertion...`, node);
 
-    const stepStatement = step.getStatement(),
-          statementEqualToStepStatement = this.statement.isEqualTo(stepStatement);
+    const proofAssertionStatement = proofAssertion.getStatement(),
+          statementEqualToStepStatement = this.statement.isEqualTo(proofAssertionStatement);
 
     if (statementEqualToStepStatement) {
-      equalToStep = true;
+      comparesToProofAssertion = true;
     }
 
-    if (equalToStep) {
-      context.trace(`...the '${hypothesisString}' hypothesis is equal to the '${stepString}' step.`, this.node);
+    if (comparesToProofAssertion) {
+      context.trace(`...the '${hypothesisString}' hypothesis is equal to the '${proofAssertionString}' proof assertion.`, node);
     }
 
-    return equalToStep;
+    return comparesToProofAssertion;
   }
 
   toJSON() {

package/src/element/judgement.js

@@ -26,110 +26,85 @@ export default define(class Judgement extends Element {
 
   getMetavariable() { return this.frame.getMetavariable(); }
 
-  verify(assignments, stated, context) {
-    let verifies = false;
+  validate(assignments, stated, context) {
+    let validates = false;
 
     const judgementString = this.string;  ///
 
-    context.trace(`Verifying the '${judgementString}' judgement...`);
+    context.trace(`Validating the '${judgementString}' judgement...`);
 
-    const frameVerifies = this.verifyFrame(assignments, stated, context);
+    const frameValidates = this.frame.validate(assignments, stated, context);
 
-    if (frameVerifies) {
-      const declarationVerifies = this.verifyDeclaration(assignments, stated, context);
+    if (frameValidates) {
+      const assumptionValidates = this.assumption.validate(assignments, stated, context);
 
-      if (declarationVerifies) {
-        let verifiesWhenStated = false,
-            verifiesWhenDerived = false;
+      if (assumptionValidates) {
+        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) {
+    if (validates) {
       if (stated) {
         this.assign(assignments, context);
       }
     }
 
-    if (verifies) {
-      context.debug(`...verified the '${judgementString}' judgement.`);
+    if (validates) {
+      context.debug(`...validated the '${judgementString}' judgement.`);
     }
 
-    return verifies;
+    return validates;
   }
 
-  verifyFrame(assignments, stated, context) {
-    let frameVerifies;
-
-    const frameString = this.frame.getString();
-
-    context.trace(`Verifying the '${frameString}' frame...`);
-
-    frameVerifies = this.frame.verify(assignments, stated, context);
-
-    if (frameVerifies) {
-      context.debug(`...verified the '${frameString}' frame.`);
-    }
-
-    return frameVerifies;
-  }
-
-  verifyDeclaration(assignments, stated, context) {
-    let declarationVerifies;
-
-    declarationVerifies = this.assumption.verify(assignments, stated, context);
-
-    return declarationVerifies;
-  }
-
-  verifyWhenStated(assignments, context) {
-    let verifiesWhenStated;
+  validateWhenStated(assignments, context) {
+    let validatesWhenStated;
 
     const judgementString = this.string;  ///
 
-    context.trace(`Verifying the '${judgementString}' stated judgement...`);
+    context.trace(`Validating the '${judgementString}' stated judgement...`);
 
-    verifiesWhenStated = true;
+    validatesWhenStated = true;
 
-    if (verifiesWhenStated) {
-      context.debug(`...verified the '${judgementString}' stated judgement.`);
+    if (validatesWhenStated) {
+      context.debug(`...validated the '${judgementString}' stated judgement.`);
     }
 
-    return verifiesWhenStated;
+    return validatesWhenStated;
   }
 
-  verifyWhenDerived(context) {
-    let verifiesWhenDerived = false;
+  validateWhenDerived(context) {
+    let validatesWhenDerived = false;
 
     const judgementString = this.string;  ///
 
-    context.trace(`Verifying the '${judgementString}' derived judgement...`);
+    context.trace(`Validating the '${judgementString}' derived judgement...`);
 
     const metavariable = this.assumption.getMetavariable(),
           reference = referenceFromMetavariable(metavariable, context),
-          metaLemmaMetatheorem = context.findMetaLemmaMetatheoremByReference(reference),
-          substitutions = metaLemmaMetatheorem.getSubstitutions(),
+          topLevelMetaAssertion = context.findTopLevelMetaAssertionByReference(reference),
+          substitutions = topLevelMetaAssertion.getSubstitutions(),
           frameComparesToSubstitutions = this.frame.compareSubstitutions(substitutions, context);
 
     if (frameComparesToSubstitutions) {
-      verifiesWhenDerived = true;
-
+      validatesWhenDerived = true;
     }
 
-    if (verifiesWhenDerived) {
-      context.debug(`...verified the '${judgementString}' derived judgement.`);
+    if (validatesWhenDerived) {
+      context.debug(`...validated the '${judgementString}' derived judgement.`);
     }
 
-    return verifiesWhenDerived;
+    return validatesWhenDerived;
   }
 
   assign(assignments, context) {

package/src/element/metaType.js

@@ -3,6 +3,7 @@
 import Element from "../element";
 
 import { define } from "../elements";
+import { findMetaTypeFromTypeName } from "../metaTypes";
 
 export default define(class MetaType extends Element {
   constructor(context, string, node, name) {
@@ -41,14 +42,13 @@ export default define(class MetaType extends Element {
   static fromJSON(json, context) {
     const { name } = json,
           metaTypeName = name,  ///
-          metaType = metaTypeFromMetaTypeName(metaTypeName);
+          metaType = findMetaTypeByMetaTypeName(metaTypeName);
 
     return metaType;
   }
 
-  static fromName(name) {
-    const context = null,
-          string = name,
+  static fromName(name, context) {
+    const string = name,
           node = null,
           metaType = new MetaType(context, string, node, name);
 

package/src/element/metavariable.js

@@ -46,7 +46,8 @@ export default define(class Metavariable extends Element {
   }
 
   compareMetavariableName(metavariableName) {
-    const comparesToMetavariableName = (metavariableName === this.name);
+    const nameMetavariableName = (this.name === metavariableName),
+          comparesToMetavariableName = nameMetavariableName;  ///
 
     return comparesToMetavariableName;
   }
@@ -54,7 +55,7 @@ export default define(class Metavariable extends Element {
   isMetaTypeEqualTo(metaType) { return this.metaType.isEqualTo(metaType); }
 
   validate(context) {
-    let validates;
+    let validates = false;
 
     const metavariableString = this.getString(); ///
 
@@ -63,7 +64,9 @@ export default define(class Metavariable extends Element {
     const metavariable = this, ///
           metavariablePresent = context.isMetavariablePresent(metavariable);
 
-    validates = metavariablePresent; ///
+    if (metavariablePresent) {
+      validates = true;
+    }
 
     if (validates) {
       context.debug(`...va;idated the '${metavariableString}' metavariable.`);
@@ -75,8 +78,8 @@ export default define(class Metavariable extends Element {
   validateGivenMetaType(metaType, context) {
     let validatesGivenMetaType = false;
 
-    const metavariableString = this.getString(),  ///
-          metaTypeString = metaType.getString();
+    const metaTypeString = metaType.getString(),
+          metavariableString = this.getString();  ///
 
     context.trace(`Validating the '${metavariableString}' metavariable given the '${metaTypeString}' meta-type...`);
 
@@ -87,7 +90,9 @@ export default define(class Metavariable extends Element {
     if (metavariable !== null) {
       const metavariableMetaTypeEqualToMetaType = metavariable.isMetaTypeEqualTo(metaType);
 
-      validatesGivenMetaType = metavariableMetaTypeEqualToMetaType;  ///
+      if (metavariableMetaTypeEqualToMetaType) {
+        validatesGivenMetaType = true;
+      }
     }
 
     if (validatesGivenMetaType) {
@@ -164,15 +169,17 @@ export default define(class Metavariable extends Element {
       if (substitutionPresent) {
         substitution = substitutions.findSubstitutionByMetavariableAndSubstitution(metavariable, substitution); ///
 
-        const substitutionStatementEqualToStatement = substitution.isStatementEqualToStatement(statement, context);
+        const substitutionComparesToStatement = substitution.compareStatement(statement, context);
 
-        if (substitutionStatementEqualToStatement) {
+        if (substitutionComparesToStatement) {
           statementUnifies = true;
         }
       } else {
         const { StatementSubstitution } = elements,
               metavariable = this,
-              statementSubstitution = StatementSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context);
+              statementSubstitution = (substitution !== null ) ?
+                                        StatementSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context) :
+                                          StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context);
 
         substitution = statementSubstitution;  ///
 
@@ -303,7 +310,7 @@ export default define(class Metavariable extends Element {
 
     if (generalContextFilePath === specificContextFilePath) {
       const metavariable = this,  ///
-            metavariableString = this.getString(), ///
+            metavariableString = metavariable.getString(),
             statementMetavariableEqualToMetvariable = statement.isMetavariableEqualToMetavariable(metavariable, context);
 
       if (statementMetavariableEqualToMetvariable) {

package/src/element/proof.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import Element from "../element";
-import LocalContext from "../context/local";
+import ScopedContext from "../context/scoped";
 
 import { define } from "../elements";
 
@@ -16,12 +16,12 @@ export default define(class Proof extends Element {
     return this.derivation;
   }
 
-  getLastStep() { return this.derivation.getLastStep(); }
+  getLastProofAssertion() { return this.derivation.getLastProofAssertion(); }
 
   getStatement() {
-    const lastStep = this.getLastStep(),
-          lastStepStatement = lastStep.getStatement(),
-          statement = lastStepStatement; ///
+    const lastProofAssertion = this.getLastProofAssertion(),
+          lastProofAssertionStatement = lastProofAssertion.getStatement(),
+          statement = lastProofAssertionStatement; ///
 
     return statement;
   }
@@ -29,16 +29,16 @@ export default define(class Proof extends Element {
   verify(substitutions, conclusion, context) {
     let verifies = false;
 
-    const localContext = LocalContext.fromNothing(context); ///
+    const scopedContext = ScopedContext.fromNothing(context); ///
 
-    context = localContext; ///
+    context = scopedContext; ///
 
     const derivationVerifies = this.derivation.verify(substitutions, context);
 
     if (derivationVerifies) {
-      const lastStep = context.getLastStep();
+      const lastProofAssertion = context.getLastProofAssertion();
 
-      if (lastStep !== null) {
+      if (lastProofAssertion !== null) {
         const statement = this.getStatement(),
               conclusionStatement = conclusion.getStatement(),
               conclusionStatementEqualToStatement = conclusionStatement.isEqualTo(statement);