occam-verify-cli 1.0.448 → 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/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/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

@@ -78,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...`);
 
@@ -169,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;  ///
 
@@ -308,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";
 
@@ -29,9 +29,9 @@ 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);
 

package/src/element/{premise.js → proofAssertion/premise.js}

@@ -1,10 +1,10 @@
 "use strict";
 
-import ProofAssertion from "./proofAssertion";
-import TemporaryContext from "../context/temporary";
-import assignAssignments from "../process/assign";
+import ProofAssertion from "../proofAssertion";
+import TransientContext from "../../context/transient";
+import assignAssignments from "../../process/assign";
 
-import { define } from "../elements";
+import { define } from "../../elements";
 import { termsFromJSON,
          framesFromJSON,
          termsToTermsJSON,
@@ -12,7 +12,7 @@ import { termsFromJSON,
          framesToFramesJSON,
          procedureCallFromJSON,
          statementToStatementJSON,
-         procedureCallToProcedureCallJSON } from "../utilities/json";
+         procedureCallToProcedureCallJSON } from "../../utilities/json";
 
 export default define(class Premise extends ProofAssertion {
   constructor(context, string, node, statement, procedureCall) {
@@ -28,9 +28,9 @@ export default define(class Premise extends ProofAssertion {
   verify(context) {
     let verifies = false;
 
-    const temporaryContext = TemporaryContext.fromNothing(context);
+    const transientContext = TransientContext.fromNothing(context);
 
-    context = temporaryContext; ///
+    context = transientContext; ///
 
     const node = this.getNode(),
           premiseString = this.getString(); ///
@@ -83,16 +83,15 @@ export default define(class Premise extends ProofAssertion {
   unifyIndependently(substitutions, context) {
     let unifiesIndependently = false;
 
-    const node = this.getNode(),
-          premiseString = this.getString(); ///
+    const premiseString = this.getString(); ///
 
-    context.trace(`Unifying the '${premiseString}' premise independently...`, node);
+    context.trace(`Unifying the '${premiseString}' premise independently...`);
 
-    const generalContext = context; ///
+    const specificContext = context; ///
 
     context = this.getContext();
 
-    const specificContext = context;  ///
+    const generalContext = context;  ///
 
     context = specificContext;  ///
 
@@ -115,7 +114,7 @@ export default define(class Premise extends ProofAssertion {
     }
 
     if (unifiesIndependently) {
-      context.debug(`...unified the '${premiseString}' premise independenly.`, node);
+      context.debug(`...unified the '${premiseString}' premise independenly.`);
     }
 
     return unifiesIndependently;
@@ -126,8 +125,8 @@ export default define(class Premise extends ProofAssertion {
 
     const subproofOrProofAssertionProofAssertion = subproofOrProofAssertion.isProofAssertion(),
           proofAssertion = subproofOrProofAssertionProofAssertion ?
-                        subproofOrProofAssertion :
-                          null,
+                             subproofOrProofAssertion :
+                               null,
           subproof = subproofOrProofAssertionProofAssertion ?
                         null :
                           subproofOrProofAssertion;
@@ -164,18 +163,19 @@ export default define(class Premise extends ProofAssertion {
   unifyProofAssertion(proofAssertion, substitutions, context) {
     let proofAssertionUnifies = false;
 
-    const node = this.getNode(),
-          premiseString = this.getString(),
+    const premiseString = this.getString(),
           proofAssertionString = proofAssertion.getString();
 
-    context.trace(`Unifying the '${proofAssertionString}' proof assertion with the '${premiseString}' premise...`, node);
-
-    const specificContext = context;  ///
+    context.trace(`Unifying the '${proofAssertionString}' proof assertion with the '${premiseString}' premise...`);
 
     context = this.getContext();
 
     const generalContext = context; ///
 
+    context = proofAssertion.getContext();
+
+    const specificContext = context;  ///
+
     context = specificContext;  ///
 
     const statement = proofAssertion.getStatement(),
@@ -186,7 +186,7 @@ export default define(class Premise extends ProofAssertion {
     }
 
     if (proofAssertionUnifies) {
-      context.debug(`...unified the '${proofAssertionString}' proof assertion with the '${premiseString}' premise.`, node);
+      context.debug(`...unified the '${proofAssertionString}' proof assertion with the '${premiseString}' premise.`);
     }
 
     return proofAssertionUnifies;
@@ -271,7 +271,7 @@ export default define(class Premise extends ProofAssertion {
           frames = framesFromJSON(json, context),
           statement = statementFromJSON(json, context),
           procedureCall = procedureCallFromJSON(json, context),
-          temporaryContext = TemporaryContext.fromTermsAndFrames(terms, frames, context);
+          transientContext = TransientContext.fromTermsAndFrames(terms, frames, context);
 
     let string;
 
@@ -285,7 +285,7 @@ export default define(class Premise extends ProofAssertion {
 
     const node = null;
 
-    context = temporaryContext; ///
+    context = transientContext; ///
 
     const premise = new Premise(context, string, node, statement, procedureCall);