occam-verify-cli 1.0.715 → 1.0.721

package/src/element/metavariable.js

@@ -7,17 +7,17 @@ import elements from "../elements";
 import { define } from "../elements";
 import { literally } from "../utilities/context";
 import { EMPTY_STRING } from "../constants";
-import { metaTypeToMetaTypeJSON } from "../utilities/json";
 import { instantiateMetavariable } from "../process/instantiate";
-import { nameFromMetavariableNode } from "../utilities/element";
-import { typeFromJSON, metaTypeFromJSON, typeToTypeJSON } from "../utilities/json";
+import { metaTypeFromJSON, metaTypeToMetaTypeJSON } from "../utilities/json";
 import { unifyMetavariable, unifyMetavariableIntrinsically } from "../process/unify";
+import { nameFromMetavariableNode, termFromMetavariableNode, typeFromMetavariableNode } from "../utilities/element";
 
 export default define(class Metavariable extends Element {
-  constructor(context, string, node, name, type, metaType) {
+  constructor(context, string, node, name, term, type, metaType) {
     super(context, string, node);
     
     this.name = name;
+    this.term = term;
     this.type = type;
     this.metaType = metaType;
   }
@@ -26,6 +26,10 @@ export default define(class Metavariable extends Element {
     return this.name;
   }
 
+  getTerm() {
+    return this.term;
+  }
+
   getType() {
     return this.type;
   }
@@ -34,28 +38,26 @@ export default define(class Metavariable extends Element {
     return this.metaType;
   }
 
-  setType(type) {
-    this.type = type;
-  }
-
   setMetaType(metaType) {
     this.metaType = metaType;
   }
 
   getMetavariableNode() {
     const node = this.getNode(),
-          metavarialbeNode = node;  ///
+          metavariableNode = node;  ///
 
-    return metavarialbeNode;
+    return metavariableNode;
   }
 
   getMetavariableName() {
-    const metavarialbeNode = this.getMetavariableNode(),
-          metavariableName = metavarialbeNode.getMetavariableName();
+    const metavariableNode = this.getMetavariableNode(),
+          metavariableName = metavariableNode.getMetavariableName();
 
     return metavariableName;
   }
 
+  isMetaTypeEqualTo(metaType) { return this.metaType.isEqualTo(metaType); }
+
   compare(metavariable) {
     const metavariableName = metavariable.getName(),
           comparesToMetavariableName = this.compareMetavariableName(metavariableName),
@@ -64,8 +66,6 @@ export default define(class Metavariable extends Element {
     return comparesToMetavariable;
   }
 
-  isMetaTypeEqualTo(metaType) { return this.metaType.isEqualTo(metaType); }
-
   compareMetavariableName(metavariableName) {
     const nameMetavariableName = (this.name === metavariableName),
           comparesToMetavariableName = nameMetavariableName;  ///
@@ -85,52 +85,140 @@ export default define(class Metavariable extends Element {
     return metavariableNodeMatches;
   }
 
+  verify(context) {
+    let verifies = false;
+
+    const metavariableString = this.getString();
+
+    context.trace(`Verifying the '${metavariableString}' metavariable...`);
+
+    const termVerifies = this.verifyTerm(context);
+
+    if (termVerifies) {
+      const typeVerifies = this.verifyType(context);
+
+      if (typeVerifies) {
+        verifies = true;
+      }
+    }
+
+    if (verifies) {
+      context.debug(`...verified the '${metavariableString}' metavariable.`);
+    }
+
+    return verifies;
+  }
+
+  verifyTerm(context) {
+    let termVerifies = true;  ///
+
+    if (this.term !== null) {
+      const termString = this.term.getString(),
+            metavariableString = this.getString();
+
+      termVerifies = false;
+
+      context.trace(`A '${termString}' term is present in the '${metavariableString}' metavariable.`);
+    }
+
+    return termVerifies;
+  }
+
+  verifyType(context) {
+    let typeVerifies = true;  ///
+
+    if (this.type !== null) {
+      const typeString = this.type.getString(),
+            metavariableString = this.getString();
+
+      context.trace(`Verifying the '${metavariableString}' metavariable's '${typeString}' type...`);
+
+      const typeName = this.type.getName(),
+            typePresent = context.isTypePresentByTypeName(typeName);
+
+      if (!typePresent) {
+        typeVerifies = false;
+
+        context.error(`Type '${typeName}' is not present.`);
+      }
+
+      if (typeVerifies) {
+        context.debug(`...verifieds the '${metavariableString}' metavariable's '${typeString}' type.`);
+      }
+    }
+
+    return typeVerifies;
+  }
+
   validate(context) {
-    let validates = false;
+    let metavariable = null;
 
     const metavariableString = this.getString(); ///
 
     context.trace(`Validating the '${metavariableString}' metavariable...`);
 
-    const metavariable = this, ///
-          metavariablePresent = context.isMetavariablePresent(metavariable);
+    let validates = false;
+
+    const termValidates = this.validateTerm(context);
+
+    if (termValidates) {
+      const typeValidates = this.validateType(context);
 
-    if (metavariablePresent) {
-      validates = true;
+      if (typeValidates) {
+        const metavariableName = this.name, ///
+              metavariable = context.findMetavariableByMetavariableName(metavariableName);
+
+        if (metavariable !== null) {
+          const metaType = metavariable.getMetaType();
+
+          this.metaType = metaType;
+        }
+
+        validates = true;
+      }
     }
 
     if (validates) {
-      context.debug(`...va;idated the '${metavariableString}' metavariable.`);
+      metavariable = this;  ///
+
+      context.debug(`...validated the '${metavariableString}' metavariable.`);
     }
 
-    return validates;
+    return metavariable;
   }
 
-  validateGivenMetaType(metaType, context) {
-    let validatesGivenMetaType = false;
+  validateTerm(context) {
+    let termValidates = true;
 
-    const metaTypeString = metaType.getString(),
-          metavariableString = this.getString();  ///
+    if (this.term !== null) {
+      const termString = this.term.getString(),
+            metavariableString = this.getString();
 
-    context.trace(`Validating the '${metavariableString}' metavariable given the '${metaTypeString}' meta-type...`);
+      context.trace(`Validating the '${metavariableString}' metavariable's '${termString}' term...`);
 
-    let metavariable = this;  ///
+      termValidates = this.term.validate(context);
 
-    metavariable = context.findMetavariable(metavariable);
-
-    if (metavariable !== null) {
-      const metavariableMetaTypeEqualToMetaType = metavariable.isMetaTypeEqualTo(metaType);
-
-      if (metavariableMetaTypeEqualToMetaType) {
-        validatesGivenMetaType = true;
+      if (termValidates) {
+        context.debug(`...validated the '${metavariableString}' metavariable's '${termString}' term.`);
       }
     }
 
-    if (validatesGivenMetaType) {
-      context.debug(`...validated the '${metavariableString}' metavariable given the '${metaTypeString}' meta-type.`);
+    return termValidates;
+  }
+
+  validateType(context) {
+    let typeValidates = true;  ///
+
+    if (this.type !== null) {
+      const typeString = this.type.getString(),
+            metavariableString = this.getString();
+
+      typeValidates = false;
+
+      context.trace(`A '${typeString}' type is present in the '${metavariableString}' metavariable.`);
     }
 
-    return validatesGivenMetaType;
+    return typeValidates;
   }
 
   unifyFrame(frame, generalContext, specificContext) {
@@ -438,14 +526,11 @@ export default define(class Metavariable extends Element {
   }
 
   toJSON() {
-    const typeJSON = typeToTypeJSON(this.type),
-          metaTypeJSON = metaTypeToMetaTypeJSON(this.metaType),
-          type = typeJSON,  ///
+    const metaTypeJSON = metaTypeToMetaTypeJSON(this.metaType),
           metaType = metaTypeJSON,  ///
           string = this.getString(), ///
           json = {
             string,
-            type,
             metaType
           };
 
@@ -460,9 +545,10 @@ export default define(class Metavariable extends Element {
             metavariableNode = instantiateMetavariable(string, context),
             node = metavariableNode,  ///
             name = nameFromMetavariableNode(metavariableNode, context),
-            type = typeFromJSON(json, context),
+            term = termFromMetavariableNode(metavariableNode, context),
+            type = typeFromMetavariableNode(metavariableNode, context),
             metaType = metaTypeFromJSON(json, context),
-            metavariable = new Metavariable(context, string, node, name, type, metaType);
+            metavariable = new Metavariable(context, string, node, name, term, type, metaType);
 
       return metavariable;
     }, context);

package/src/element/proofAssertion/step.js

@@ -133,7 +133,7 @@ export default define(class Step extends ProofAssertion {
   }
 
   validateReference(context) {
-    let referenceValidates = true;
+    let referenceValidates = true;  ///
 
     if (this.reference !== null) {
       const stepString = this.getString(),  ///
@@ -167,8 +167,8 @@ export default define(class Step extends ProofAssertion {
       const stated = true,
             satisfiesAssertion = this.satisfiesAssertion.validate(stated, context);
 
-      if (satisfiesAssertion !== null) {
-        satisfiesAssertionValidates = true;
+      if (satisfiesAssertion === null) {
+        satisfiesAssertionValidates = false;
       }
 
       if (satisfiesAssertionValidates) {

package/src/element/proofAssertion.js

@@ -38,9 +38,7 @@ export default class ProofAssertion extends Element {
 
     const leftStatement = statement,  ///
           rightStatement = this.statement,  ///
-          leftStatementNode = leftStatement.getNode(),
-          rightStatementNode = rightStatement.getNode(),
-          statementsEquate = equateStatements(leftStatementNode, rightStatementNode, context);
+          statementsEquate = equateStatements(leftStatement, rightStatement, context);
 
     if (statementsEquate) {
       comparesToStatement = true;

package/src/element/reference.js

@@ -125,20 +125,41 @@ export default define(class Reference extends Element {
     } else {
       let validates = false;
 
-      if (!validates) {
-        const metavariableValidates = this.validateMetavariable(context);
-
-        if (metavariableValidates) {
-          validates = true;
-        }
-      }
-
-      if (!validates) {
-        const reference = this, ///
-              labelPresent = context.isLabelPresentByReference(reference);
-
-        if (labelPresent) {
-          validates = true;
+      const metavariableValidates = this.validateMetavariable(context);
+
+      if (metavariableValidates) {
+        const referenceMetaTypeName = REFERENCE_META_TYPE_NAME,
+              referenceMetaType = context.findMetaTypeByMetaTypeName(referenceMetaTypeName),
+              metaType = this.metavariable.getMetaType();
+
+        if (metaType === null) {
+          const reference = this, ///
+                labelPresent = context.isLabelPresentByReference(reference);
+
+          if (labelPresent) {
+            validates = true;
+          } else {
+            context.debug(`There is no label for the '${referenceString}' reference.`);
+          }
+        } else {
+          const metavariableMetaTypeEqualToReferenceMetaType = this.metavariable.isMetaTypeEqualTo(referenceMetaType);
+
+          if (metavariableMetaTypeEqualToReferenceMetaType) {
+            const reference = this, ///
+                  metavariablePresent = context.isMetavariablePresentByReference(reference);
+
+            if (metavariablePresent) {
+              validates = true;
+            } else {
+              context.debug(`There is no metavariable for the '${referenceString}' reference.`);
+            }
+          } else {
+            const metaTypeString = metaType.getString(),
+                  metavariableString = this.metavariable.getString(),
+                  reerenceMetaTypeString = referenceMetaType.getString();
+
+            context.debug(`The '${referenceString}' reference's '${metavariableString}' metavariable's '${metaTypeString}' meta-type should be the '${reerenceMetaTypeString}' meta-type.`);
+          }
         }
       }
 
@@ -162,44 +183,19 @@ export default define(class Reference extends Element {
 
     context.trace(`Validating the '${referenceString}' reference's '${metavariableString}' metavariable...'`);
 
-    const metaTypeName = REFERENCE_META_TYPE_NAME,
-          referenceMetaType = context.findMetaTypeByMetaTypeName(metaTypeName),
-          metaType = referenceMetaType, ///
-          metavariable = context.findMetavariable(this.metavariable);
+    const metavariable = this.metavariable.validate(context);
 
     if (metavariable !== null) {
-      const metavariableValidatesGivenMetaType = metavariable.validateGivenMetaType(metaType, context);
-
-      if (metavariableValidatesGivenMetaType) {
-        metavariableValidates = true;
-      }
-    } else {
-      context.debug(`The '${metavariableString}' metavariable is not present.`);
-    }
-
-    return metavariableValidates;
-  }
-
-  validateAsMetavariable(context) {
-    let validatesAsMetavariable = false;
-
-    const referenceString = this.getString(); ///
+      this.metavariable = metavariable;
 
-    context.trace(`Validating the '${referenceString}' reference as a metavaraible...`);
-
-    const metavariable = this.getMetavariable(),
-          metavariableName = metavariable.getName(),
-          metavariablePresent = context.isMetavariablePresentByMetavariableName(metavariableName);
-
-    if (metavariablePresent) {
-      validatesAsMetavariable = true;
+      metavariableValidates = true;
     }
 
-    if (validatesAsMetavariable) {
-      context.debug(`...validated the '${referenceString}' reference as a metavaraible.`);
+    if (metavariableValidates) {
+      context.debug(`...validated the '${referenceString}' reference's '${metavariableString}' metavariable.'`);
     }
 
-    return validatesAsMetavariable;
+    return metavariableValidates;
   }
 
   unifyLabel(label, context) {
@@ -301,8 +297,11 @@ export default define(class Reference extends Element {
       const { string } = json,
             referenceNode = instantiateReference(string, context),
             node = referenceNode,  ///
-            metavariable = metavariableFromReferenceNode(referenceNode, context),
-            reference = new Reference(context, string, node, metavariable);
+            metavariable = metavariableFromReferenceNode(referenceNode, context);
+
+      context = null;
+
+      const reference = new Reference(context, string, node, metavariable);
 
       return reference;
     }, context);

package/src/element/statement.js

@@ -8,7 +8,6 @@ import { literally } from "../utilities/context";
 import { unifyStatement } from "../process/unify";
 import { validateStatements } from "../utilities/validation";
 import { instantiateStatement } from "../process/instantiate";
-import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 
 const { match, backwardsSome } = arrayUtilities;
 
@@ -209,31 +208,6 @@ export default define(class Statement extends Element {
     return statement;
   }
 
-  validateGivenMetaType(metaType, stated, context) {
-    let validatesGivenMetaType = false;
-
-    const metaTypeString = metaType.getString(),
-          statementString = this.getString();  ///
-
-    context.trace(`Validating the '${statementString}' statement given the '${metaTypeString}' meta-type...`);
-
-    const metaTypeName = metaType.getName();
-
-    if (metaTypeName === STATEMENT_META_TYPE_NAME) {
-      const statement = this.validate(stated, context)
-
-      if (statement !== null) {
-        validatesGivenMetaType = true;
-      }
-    }
-
-    if (validatesGivenMetaType) {
-      context.debug(`...validated the '${statementString}' statement given the '${metaTypeString}' meta-type.`);
-    }
-
-    return validatesGivenMetaType;
-  }
-
   unifySubproof(subproof, generalContext, specificContext) {
     let subproofUnifies = false;
 
@@ -338,7 +312,7 @@ export default define(class Statement extends Element {
   }
 
   toJSON() {
-    const string = this.getString(),  ///
+    const string = this.getString(),
           json = {
             string
           };

package/src/element/substitution/frame.js

@@ -170,17 +170,6 @@ export default define(class FrameSubstitution extends Substitution {
     return replacementFrameValidates;
   }
 
-  toJSON() {
-    const { name } = this.constructor,
-          string = this.getString(),
-          json = {
-            name,
-            string
-          };
-
-    return json;
-  }
-
   static name = "FrameSubstitution";
 
   static fromJSON(json, context) {

package/src/element/substitution/reference.js

@@ -164,17 +164,6 @@ export default define(class ReferenceSubstitution extends Substitution {
     return replacementReferenceValidates;
   }
 
-  toJSON() {
-    const { name } = this.constructor,
-          string = this.getString(),
-          json = {
-            name,
-            string
-          };
-
-    return json;
-  }
-
   static name = "ReferenceSubstitution";
 
   static fromJSON(json, context) {

package/src/element/substitution/statement.js

@@ -319,17 +319,6 @@ export default define(class StatementSubstitution extends Substitution {
     }
   }
 
-  toJSON() {
-    const { name } = this.constructor,
-          string = this.getString(),
-          json = {
-            name,
-            string
-          };
-
-    return json;
-  }
-
   static name = "StatementSubstitution";
 
   static fromJSON(json, context) {

package/src/element/substitution/term.js

@@ -179,17 +179,6 @@ export default define(class TermSubstitution extends Substitution {
     return replacementTermValidates;
   }
 
-  toJSON() {
-    const { name } = this.constructor,
-          string = this.getString(),
-          json = {
-            name,
-            string
-          };
-
-    return json;
-  }
-
   static name = "TermSubstitution";
 
   static fromJSON(json, context) {

package/src/element/substitution.js

@@ -165,4 +165,15 @@ export default class Substitution extends Element {
 
     return resolved;
   }
+
+  toJSON() {
+    const { name } = this.constructor,
+          string = this.getString(),
+          json = {
+            name,
+            string
+          };
+
+    return json;
+  }
 }

package/src/element/variable.js

@@ -95,31 +95,6 @@ export default define(class Variable extends Element {
     return validates;
   }
 
-  validateType(context) {
-    let typeValidates = false;
-
-    const typeString = this.type.getString();
-
-    context.trace(`Validating the '${typeString}' type...`);
-
-    const prefixedTypeName = this.type.getPrefixedName(),
-          type = context.findTypeByPrefixedTypeName(prefixedTypeName);
-
-    if (type === null) {
-      context.debug(`The '${typeString}' type is not present.`);
-    } else {
-      this.type = type; ///
-
-      typeValidates = true;
-    }
-
-    if (typeValidates) {
-      context.debug(`...validated the '${typeString}' type.`);
-    }
-
-    return typeValidates;
-  }
-
   unifyTerm(term, generalContext, specificContext) {
     let termUnifies = false;
 

package/src/process/equate.js

@@ -63,10 +63,12 @@ class EquationalPass extends EquivalencePass {
 
 const equationalPass = new EquationalPass();
 
-export function equateTerms(leftTermNode, rightTermNode, context) {
+export function equateTerms(leftTerm, rightTerm, context) {
   let termsEquate;
 
-  const leftNode = leftTermNode, ///
+  const leftTermNode = leftTerm.getNode(),
+        rightTermNode = rightTerm.getNode(),
+        leftNode = leftTermNode, ///
         rightNode = rightTermNode, ///
         success = equationalPass.run(leftNode, rightNode, context);
 
@@ -75,10 +77,12 @@ export function equateTerms(leftTermNode, rightTermNode, context) {
   return termsEquate;
 }
 
-export function equateStatements(leftStatementNode, rightStatementNode, context) {
+export function equateStatements(leftStatement, rightStatement, context) {
   let statementsEquate;
 
-  const leftNode = leftStatementNode, ///
+  const leftStatementNode = leftStatement.getNode(),
+        rightStatementNode = rightStatement.getNode(),
+        leftNode = leftStatementNode, ///
         rightNode = rightStatementNode, ///
         success = equationalPass.run(leftNode, rightNode, context);