occam-verify-cli 1.0.448 → 1.0.472

package/src/element/judgement.js

@@ -22,114 +22,94 @@ export default define(class Judgement extends Element {
     return this.assumption;
   }
 
-  isSingular() { return this.node.isSingular(); }
+  isSingular() {
+    const node = this.getNode(),
+          singular = node.isSingular();
+
+    return singular;
+  }
 
   getMetavariable() { return this.frame.getMetavariable(); }
 
-  verify(assignments, stated, context) {
-    let verifies = false;
+  validate(assignments, stated, context) {
+    let validates = false;
 
-    const judgementString = this.string;  ///
+    const judgementString = this.getString();  ///
 
-    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;
+  validateWhenStated(assignments, context) {
+    let validatesWhenStated;
 
-    const frameString = this.frame.getString();
+    const judgementString = this.getString();  ///
 
-    context.trace(`Verifying the '${frameString}' frame...`);
+    context.trace(`Validating the '${judgementString}' stated judgement...`);
 
-    frameVerifies = this.frame.verify(assignments, stated, context);
+    validatesWhenStated = true;
 
-    if (frameVerifies) {
-      context.debug(`...verified the '${frameString}' frame.`);
+    if (validatesWhenStated) {
+      context.debug(`...validated the '${judgementString}' stated judgement.`);
     }
 
-    return frameVerifies;
-  }
-
-  verifyDeclaration(assignments, stated, context) {
-    let declarationVerifies;
-
-    declarationVerifies = this.assumption.verify(assignments, stated, context);
-
-    return declarationVerifies;
+    return validatesWhenStated;
   }
 
-  verifyWhenStated(assignments, context) {
-    let verifiesWhenStated;
+  validateWhenDerived(context) {
+    let validatesWhenDerived = false;
 
-    const judgementString = this.string;  ///
+    const judgementString = this.getString();  ///
 
-    context.trace(`Verifying the '${judgementString}' stated judgement...`);
-
-    verifiesWhenStated = true;
-
-    if (verifiesWhenStated) {
-      context.debug(`...verified the '${judgementString}' stated judgement.`);
-    }
-
-    return verifiesWhenStated;
-  }
-
-  verifyWhenDerived(context) {
-    let verifiesWhenDerived = 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

@@ -41,14 +41,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

@@ -5,9 +5,9 @@ import elements from "../elements";
 
 import { define } from "../elements";
 import { EMPTY_STRING } from "../constants";
-import { instantiateMetavariable } from "../process/instantiate";
-import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
-import { metaTypeFromJSON, metaTypeToMetaTypeJSON } from "../utilities/json";
+import { synthetically } from "../utilities/context";
+import { typeToTypeJSON } from "../utilities/json";
+import { metaTypeToMetaTypeJSON } from "../utilities/json";
 import { unifyMetavariable, unifyMetavariableIntrinsically } from "../process/unify";
 
 export default define(class Metavariable extends Element {
@@ -45,6 +45,8 @@ export default define(class Metavariable extends Element {
     return nameEqualTo;
   }
 
+  isMetaTypeEqualTo(metaType) { return this.metaType.isEqualTo(metaType); }
+
   compareMetavariableName(metavariableName) {
     const nameMetavariableName = (this.name === metavariableName),
           comparesToMetavariableName = nameMetavariableName;  ///
@@ -52,8 +54,6 @@ export default define(class Metavariable extends Element {
     return comparesToMetavariableName;
   }
 
-  isMetaTypeEqualTo(metaType) { return this.metaType.isEqualTo(metaType); }
-
   validate(context) {
     let validates = false;
 
@@ -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...`);
 
@@ -105,10 +105,11 @@ export default define(class Metavariable extends Element {
   unifyFrame(frame, substitutions, generalContext, specificContext) {
     let frameUnifies = false;
 
-    const frameString = frame.getString(),
+    const context = specificContext,  ///
+          frameString = frame.getString(),
           metavariableString = this.getString(); ///
 
-    specificContext.trace(`Unifying the '${frameString}' frame with the '${metavariableString}' metavariable...`);
+    context.trace(`Unifying the '${frameString}' frame with the '${metavariableString}' metavariable...`);
 
     const frameMetavariableUnifies = this.unifyFrameMetavariable(frame, substitutions, generalContext, specificContext);
 
@@ -127,20 +128,20 @@ export default define(class Metavariable extends Element {
           frameUnifies = true;
         }
       } else {
-        const { FrameSubstitution } = elements,
-              context = specificContext,  ///
-              metavariable = this,  ///
-              frameSubstitution = FrameSubstitution.fromFrameAndMetavariable(frame, metavariable, context),
-              substitution = frameSubstitution;  ///
+        const metavariable = this;  ///
 
-        substitutions.addSubstitution(substitution, context);
+        synthetically((context) => {
+          const { FrameSubstitution } = elements;
+
+          FrameSubstitution.fromFrameAndMetavariable(frame, metavariable, context);
+        }, generalContext, specificContext);
 
         frameUnifies = true;
       }
     }
 
     if (frameUnifies) {
-      specificContext.debug(`...unified the '${frameString}' frame with the '${metavariableString}' metavariable.`);
+      context.debug(`...unified the '${frameString}' frame with the '${metavariableString}' metavariable.`);
     }
 
     return frameUnifies;
@@ -149,13 +150,14 @@ export default define(class Metavariable extends Element {
   unifyStatement(statement, substitution, substitutions, generalContext, specificContext) {
     let statementUnifies = false;
 
-    const statementString = statement.getString(),
+    const context = specificContext,  ///
+          statementString = statement.getString(),
           metavariableString = this.getString(), ///
           substitutionString = (substitution !== null) ?
                                   substitution.getString() :
                                     EMPTY_STRING;
 
-    specificContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}${substitutionString}' metavariable...`);
+    context.trace(`Unifying the '${statementString}' statement with the '${metavariableString}${substitutionString}' metavariable...`);
 
     const statementMetavariableUnifies = this.unifyStatementMetavariable(statement, substitutions, generalContext, specificContext);
 
@@ -169,26 +171,29 @@ 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);
+        const metavariable = this;  ///
 
-        substitution = statementSubstitution;  ///
+        synthetically((context) => {
+          const { StatementSubstitution } = elements;
 
-        substitutions.addSubstitution(substitution, context);
+          (substitution !== null) ?
+            StatementSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context) :
+              StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context);
+
+        }, generalContext, specificContext);
 
         statementUnifies = true;
       }
     }
 
     if (statementUnifies) {
-      specificContext.debug(`...unified the '${statementString}' statement with the '${metavariableString}${substitutionString}' metavariable.`);
+      context.debug(`...unified the '${statementString}' statement with the '${metavariableString}${substitutionString}' metavariable.`);
     }
 
     return statementUnifies;
@@ -197,42 +202,43 @@ export default define(class Metavariable extends Element {
   unifyReference(reference, substitutions, generalContext, specificContext) {
     let referenceUnifies = false;
 
-    const referenceString = reference.getString(),
+    const context = specificContext,  ///
+          referenceString = reference.getString(),
           metavariableString = this.getString(); ///
 
-    specificContext.trace(`Unifying the '${referenceString}' reference with the '${metavariableString}' metavariable...`);
+    context.trace(`Unifying the '${referenceString}' reference with the '${metavariableString}' metavariable...`);
 
     const referenceMetavariableUnifies = this.unifyReferenceMetavariable(reference, substitutions, generalContext, specificContext);
 
     if (referenceMetavariableUnifies) {
       referenceUnifies = true;
     } else {
-      const context = specificContext,  ///
-            metavariable = this, ///
+      const metavariable = this, ///
             simpleSubstitutionPresent = substitutions.isSimpleSubstitutionPresentByMetavariable(metavariable);
 
       if (simpleSubstitutionPresent) {
         const simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariable(metavariable), ///
               substitution = simpleSubstitution,  ///
-              substitutionReferenceEqualToReference = substitution.isReferenceEqualToReference(reference, context);
+              substitutionReferenceEqualToReference = substitution.isReferenceEqualToReference(reference);
 
         if (substitutionReferenceEqualToReference) {
           referenceUnifies = true;
         }
       } else {
-        const { ReferenceSubstitution } = elements,
-              metavariable = this,
-              referenceSubstitution = ReferenceSubstitution.fromReferenceAndMetavariable(reference, metavariable, context),
-              substitution = referenceSubstitution;  ///
+        const metavariable = this;  ///
 
-        substitutions.addSubstitution(substitution, context);
+        synthetically((context) => {
+          const { ReferenceSubstitution } = elements;
+
+          ReferenceSubstitution.fromReferenceAndMetavariable(reference, metavariable, context);
+        }, generalContext, specificContext);
 
         referenceUnifies = true;
       }
     }
 
     if (referenceUnifies) {
-      specificContext.debug(`...unified the '${referenceString}' reference with the '${metavariableString}' metavariable.`);
+      context.debug(`...unified the '${referenceString}' reference with the '${metavariableString}' metavariable.`);
     }
 
     return referenceUnifies;
@@ -241,19 +247,25 @@ export default define(class Metavariable extends Element {
   unifyMetavariable(metavariable, context) {
     let metavariableUnifies;
 
-    const generalContext = context, ///
-          specificContext = context,  ///
-          generalMetavariable = this, ///
+    const specificContext = context; ///
+
+    context = this.getContext();
+
+    const generalContext = context;  ///
+
+    context = specificContext;  ///
+
+    const generalMetavariable = this, ///
           specificMetavariable = metavariable,  ///
           generalMetavariableString = generalMetavariable.getString(),
           specificMetavariableString = specificMetavariable.getString();
 
-    specificContext.trace(`Unifying the '${specificMetavariableString}' metavariable with the '${generalMetavariableString}' metavariable...`);
+    context.trace(`Unifying the '${specificMetavariableString}' metavariable with the '${generalMetavariableString}' metavariable...`);
 
     metavariableUnifies = unifyMetavariable(generalMetavariable, specificMetavariable, generalContext, specificContext);
 
     if (metavariableUnifies) {
-      specificContext.debug(`...unified the '${specificMetavariableString}' metavariable with the '${generalMetavariableString}' metavariable.`);
+      context.debug(`...unified the '${specificMetavariableString}' metavariable with the '${generalMetavariableString}' metavariable.`);
     }
 
     return metavariableUnifies;
@@ -267,8 +279,8 @@ export default define(class Metavariable extends Element {
           specificContextFilePath = specificContext.getFilePath();
 
     if (generalContextFilePath === specificContextFilePath) {
-      const metavariable = this,
-            metavariableString = this.getString(), ///
+      const metavariable = this,  ///
+            metavariableString = metavariable.getString(),
             frameMetavariableEqualToMetvariable = frame.isMetavariableEqualToMetavariable(metavariable, context);
 
       if (frameMetavariableEqualToMetvariable) {
@@ -308,7 +320,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) {
@@ -348,7 +360,7 @@ export default define(class Metavariable extends Element {
 
     if (generalContextFilePath === specificContextFilePath) {
       const metavariable = this,  ///
-            metavariableString = this.getString(), ///
+            metavariableString = metavariable.getString(),
             referenceMetavariableEqualToMetvariable = reference.isMetavariableEqualToMetavariable(metavariable);
 
       if (referenceMetavariableEqualToMetvariable) {
@@ -392,15 +404,6 @@ export default define(class Metavariable extends Element {
   static name = "Metavariable";
 
   static fromJSON(json, context) {
-    const { string } = json,
-          metavariableNode = instantiateMetavariable(string, context),
-          metavariableName = metavariableNode.getMetavariableName(),
-          name = metavariableName,  ///
-          node = metavariableNode,  ///
-          type = typeFromJSON(json, context),
-          metaType = metaTypeFromJSON(json, context),
-          metavariable = new Metavariable(context, string, node, name, type, metaType);
-
-    return metavariable;
+    ///
   }
 });

package/src/element/parameter.js

@@ -5,16 +5,21 @@ import Element from "../element";
 import { define } from "../elements";
 
 export default define(class Parameter extends Element {
-  constructor(context, string, node, name) {
-    super(context, string, node);
+  constructor(context, string, node, name, identifier) {
+    super(context, string, node, identifier);
 
     this.name = name;
+    this.identifier = identifier;
   }
   
   getName() {
     return this.name;
   }
 
+  getIdentifier() {
+    return this.identifier;
+  }
+
   findReplacementNode(substitutions) {
     let replacementNode = null;
 
@@ -25,7 +30,7 @@ export default define(class Parameter extends Element {
             if (substitutionComparesToParamter) {
               return true;
             }
-          });
+          }) || null;
 
     if (substitution !== null) {
       replacementNode = substitution.getReplacementNode();
@@ -46,10 +51,10 @@ export default define(class Parameter extends Element {
   static name = "Parameter";
 
   static fromJSON(json, context) {
-    const { name } = json,
+    const { name, identifier } = json,
           string = null,
           node = null,
-          parameter = new Parameter(context, string, node, name);
+          parameter = new Parameter(context, string, node, name, identifier);
 
     return parameter;
   }

package/src/element/procedureCall.js

@@ -10,6 +10,7 @@ import { parametersFromJSON, procedureReferenceFromJSON, parametersToParametersJ
 export default define(class ProcedureCall extends Element {
   constructor(context, string, node, parameters, procedureReference) {
     super(context, string, node);
+
     this.parameters = parameters;
     this.procedureReference = procedureReference;
   }
@@ -24,23 +25,24 @@ export default define(class ProcedureCall extends Element {
 
   getName() { return this.procedureReference.getName(); }
 
-  findNodes(substitutions) {
-    const nodes = this.parameters.map((parameter) => {
-      const replacementNode = parameter.findReplacementNode(substitutions),
-            node = replacementNode;  ///
+  findNodes(context) {
+    const substitutions = context.getSubstitutions(),
+          nodes = this.parameters.map((parameter) => {
+            const replacementNode = parameter.findReplacementNode(substitutions),
+                  node = replacementNode;  ///
 
-      return node;
-    });
+            return node;
+          });
 
     return nodes;
   }
 
-  verify(assignments, stated, context) {
-    let verifies = false;
+  validate(context) {
+    let validates = false;
 
-    const procedureCallString = this.string; ///
+    const procedureCallString = this.getString(); ///
 
-    context.trace(`Verifying the '${procedureCallString}' procedure call...`, this.node);
+    context.trace(`Validating the '${procedureCallString}' procedure call...`);
 
     const name = this.getName(),
           procedure = context.findProcedureByName(name);
@@ -49,30 +51,30 @@ export default define(class ProcedureCall extends Element {
       const procedureBoolean = procedure.isBoolean();
 
       if (procedureBoolean) {
-        verifies = true;
+        validates = true;
       } else {
-        context.trace(`The '${procedureCallString}' procedure is not boolean.`, this.node);
+        context.trace(`The '${procedureCallString}' procedure is not boolean.`);
       }
     } else {
-      context.trace(`The '${procedureCallString}' procedure is not present.`, this.node);
+      context.trace(`The '${procedureCallString}' procedure is not present.`);
     }
 
-    if (verifies) {
-      context.debug(`...verified the '${procedureCallString}' procedure call.`, this.node);
+    if (validates) {
+      context.debug(`...validated the '${procedureCallString}' procedure call.`);
     }
 
-    return verifies;
+    return validates;
   }
 
   unifyIndependently(substitutions, context) {
     let unifiesIndependently = false;
 
-    const procedureCallString = this.string; ///
+    const procedureCallString = this.getString(); ///
 
     context.trace(`Unifying the '${procedureCallString}' procedure call independently...`);
 
     const name = this.getName(),
-          nodes = this.findNodes(substitutions),
+          nodes = this.findNodes(context),
           procedure = context.findProcedureByName(name),
           expressions = Expressions.fromNodes(nodes, context);
 

package/src/element/proof.js

@@ -1,8 +1,8 @@
 "use strict";
 
 import Element from "../element";
-import LocalContext from "../context/local";
 
+import { scope } from "../utilities/context";
 import { define } from "../elements";
 
 export default define(class Proof extends Element {
@@ -26,28 +26,26 @@ export default define(class Proof extends Element {
     return statement;
   }
 
-  verify(substitutions, conclusion, context) {
+  verify(conclusion, context) {
     let verifies = false;
 
-    const localContext = LocalContext.fromNothing(context); ///
+    scope((context) => {
+      const derivationVerifies = this.derivation.verify(context);
 
-    context = localContext; ///
+      if (derivationVerifies) {
+        const lastProofAssertion = context.getLastProofAssertion();
 
-    const derivationVerifies = this.derivation.verify(substitutions, context);
+        if (lastProofAssertion !== null) {
+          const statement = this.getStatement(),
+                conclusionStatement = conclusion.getStatement(),
+                conclusionStatementEqualToStatement = conclusionStatement.isEqualTo(statement);
 
-    if (derivationVerifies) {
-      const lastProofAssertion = context.getLastProofAssertion();
-
-      if (lastProofAssertion !== null) {
-        const statement = this.getStatement(),
-              conclusionStatement = conclusion.getStatement(),
-              conclusionStatementEqualToStatement = conclusionStatement.isEqualTo(statement);
-
-        if (conclusionStatementEqualToStatement) {
-          verifies = true;
+          if (conclusionStatementEqualToStatement) {
+            verifies = true;
+          }
         }
       }
-    }
+    }, context);
 
     return verifies;
   }