occam-verify-cli 1.0.718 → 1.0.721

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "1.0.718",
+  "version": "1.0.721",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",

package/src/context/file/nominal.js

@@ -498,13 +498,13 @@ export default class NominalFileContext extends FileContext {
 
   findMetatheoremByReference(reference) {
     const metatheorems = this.getMetatheorems(),
-      metatheorem = metatheorems.find((metatheorem) => {
-        const metatheoremComparesToReference = metatheorem.compareReference(reference);
+          metatheorem = metatheorems.find((metatheorem) => {
+            const metatheoremComparesToReference = metatheorem.compareReference(reference);
 
-        if (metatheoremComparesToReference) {
-          return true;
-        }
-      }) || null;
+            if (metatheoremComparesToReference) {
+              return true;
+            }
+          }) || null;
 
     return metatheorem;
   }

package/src/element/assumption.js

@@ -150,7 +150,7 @@ export default define(class Assumption extends Element {
     let statementValidates = false;
 
     const assumptionString = this.getString(),  ///
-      statementString = this.statement.getString();
+          statementString = this.statement.getString();
 
     context.trace(`Validating the '${assumptionString}' assumption's '${statementString}' statement...`);
 
@@ -169,23 +169,6 @@ export default define(class Assumption extends Element {
     return statementValidates;
   }
 
-  validateReferenceAsMetavariable(stated, context) {
-    let referenceValidatesAsMetavariable;
-
-    const referenceString = this.reference.getString(),
-          assumptionString = this.getString(); ///
-
-    context.trace(`Validating the '${assumptionString}' assumption's '${referenceString}' reference as s metavariable...`);
-
-    referenceValidatesAsMetavariable = this.reference.validateAsMetavariable(context);
-
-    if (referenceValidatesAsMetavariable) {
-      context.debug(`...validated the '${assumptionString}' assumption's '${referenceString}' reference as a metavariable.`);
-    }
-
-    return referenceValidatesAsMetavariable;
-  }
-
   validateWhenStated(context) {
     let validatesWhenStated;
 

package/src/element/declaration/metavariable.js

@@ -3,6 +3,7 @@
 import Declaration from "../declaration";
 
 import { define } from "../../elements";
+import { verifyMetavariable } from "../../process/verify";
 
 export default define(class MetavariableDeclaration extends Declaration {
   constructor(context, string, node, metaType, metavariable) {
@@ -34,11 +35,9 @@ export default define(class MetavariableDeclaration extends Declaration {
     const metavariableVerifies = this.verifyMetavariable();
 
     if (metavariableVerifies) {
-      const metavariableTypeVerified = this.verifyMetavariableType();
-
-      if (metavariableTypeVerified) {
-        this.metavariable.setMetaType(this.metaType);
+      const metaTypeVerifies = this.verifyMetaType();
 
+      if (metaTypeVerifies) {
         context.addMetavariable(this.metavariable);
 
         verifies = true;
@@ -52,6 +51,24 @@ export default define(class MetavariableDeclaration extends Declaration {
     return verifies;
   }
 
+  verifyMetaType() {
+    let metaTypeVerifies = true;
+
+    const context = this.getContext(),
+          metaTypeString = this.metaType.getString(),
+          metaTypeDeclarationString = this.getString(); ///
+
+    context.trace(`Verifying the '${metaTypeDeclarationString}' variable declaration's '${metaTypeString}' metaType...`);
+
+    this.metavariable.setMetaType(this.metaType);
+
+    if (metaTypeVerifies) {
+      context.debug(`...verified the '${metaTypeDeclarationString}' variable declaration's '${metaTypeString}' metaType.`);
+    }
+
+    return metaTypeVerifies;
+  }
+
   verifyMetavariable() {
     let metavariableVerifies = false;
 
@@ -61,20 +78,13 @@ export default define(class MetavariableDeclaration extends Declaration {
 
     context.trace(`Verifying the '${metavariableDeclarationString}' variable declaration's '${metavariableString}' metavariable...`);
 
-    const metavariableNode = this.metavariable.getNode(), ///
-          termNode = metavariableNode.getTermNode();
-
-    if (termNode === null) {
-      const metavariableName = this.metavariable.getName(),
-            metavariablePresent = context.isMetavariablePresentByMetavariableName(metavariableName);
+    const metavariableName = this.metavariable.getName(),
+          metavariablePresent = context.isMetavariablePresentByMetavariableName(metavariableName);
 
-      if (!metavariablePresent) {
-        metavariableVerifies = true;
-      } else {
-        context.debug(`The '${metavariableName}' metavariable is already present.`);
-      }
+    if (!metavariablePresent) {
+      metavariableVerifies = this.metavariable.verify(context);
     } else {
-      context.debug(`A term was found in the '${metavariableString}' metavariable when a type should have been present.`);
+      context.debug(`The '${metavariableName}' metavariable is already present.`);
     }
 
     if (metavariableVerifies) {
@@ -84,38 +94,5 @@ export default define(class MetavariableDeclaration extends Declaration {
     return metavariableVerifies;
   }
 
-  verifyMetavariableType() {
-    let metavariableTypeVerified = false;
-
-    const context = this.getContext(),
-          metavariableType = this.metavariable.getType();
-
-    if (metavariableType === null) {
-      metavariableTypeVerified = true;
-    } else {
-      const metavariableTypeString = metavariableType.getString(),
-            metavariableDeclarationString = this.getString(); ///
-
-      context.trace(`Verifying the '${metavariableDeclarationString}' metavariable declaration's '${metavariableTypeString}' metavariable type...`);
-
-      const nominalTypeName = metavariableType.getNominalTypeName(),
-            type = context.findTypeByNominalTypeName(nominalTypeName);
-
-      if (type === null) {
-        this.metavariable.setType(type);
-
-        metavariableTypeVerified = true;
-      } else {
-        context.debug(`The '${metavariableTypeString}' type is not present.`);
-      }
-
-      if (metavariableTypeVerified) {
-        context.debug(`...verified the '${metavariableDeclarationString}' metavariable declaration's '${metavariableTypeString}' metavariable type.`);
-      }
-    }
-
-    return metavariableTypeVerified;
-  }
-
   static name = "MetavariableDeclaration";
 });

package/src/element/equality.js

@@ -102,9 +102,7 @@ export default define(class Equality extends Element {
   isEqual(context) {
     let equal = false;
 
-    const leftTermNode = this.leftTerm.getNode(),
-          rightTermNode = this.rightTerm.getNode(),
-          termsEquate = equateTerms(leftTermNode, rightTermNode, context);
+    const termsEquate = equateTerms(this.leftTerm, this.rightTerm, context);
 
     if (termsEquate) {
       equal = true;

package/src/element/frame.js

@@ -6,23 +6,23 @@ import { define } from "../elements";
 import { literally } from "../utilities/context";
 import { instantiateFrame } from "../process/instantiate";
 import { FRAME_META_TYPE_NAME } from "../metaTypeNames";
-import { referenceFromFrameNode } from "../utilities/element";
+import { metavariableFromFrameNode } from "../utilities/element";
 import { assumptionsStringFromAssumptions } from "../utilities/string";
 
 export default define(class Frame extends Element {
-  constructor(context, string, node, reference, assumptions) {
+  constructor(context, string, node, assumptions, metavariable) {
     super(context, string, node);
 
-    this.reference = reference;
     this.assumptions = assumptions;
+    this.metavariable = metavariable;
   }
 
   getAssumptions() {
     return this.assumptions;
   }
 
-  getReference() {
-    return this.reference;
+  getMetavariable() {
+    return this.metavariable;
   }
 
   getFrameNode() {
@@ -32,30 +32,18 @@ export default define(class Frame extends Element {
     return frameNode;
   }
 
-  getMetavariableName() {
-    const frameNode = this.getFrameNode(),
-          referenceName = frameNode.getMetavariableName();
-
-    return referenceName;
-  }
-
   getMetavariableNode() {
     const frameNode = this.getFrameNode(),
-          referenceNode = frameNode.getMetavariableNode();
+          metavariableNode = frameNode.getMetavariableNode();
 
-    return referenceNode;
+    return metavariableNode;
   }
 
-  getMetavariable() {
-    let metavariable = null;
-
-    const singular = this.isSingular();
-
-    if (singular) {
-      metavariable = this.reference.getMetavariable();
-    }
+  getMetavariableName() {
+    const frameNode = this.getFrameNode(),
+          metavariableName = frameNode.getMetavariableName();
 
-    return metavariable;
+    return metavariableName;
   }
 
   matchFrameNode(frameNode) {
@@ -196,21 +184,24 @@ export default define(class Frame extends Element {
     } else {
       let validates = false;
 
-      const referenceValidates = this.validateReference(stated, context),
-            assumptionsValidate = this.validateAssumptions(stated, context);
+      const metavariableValidates = this.validatMetavariable(stated, context);
 
-      if (referenceValidates && assumptionsValidate) {
-        let validatesWhenStated = false,
-            validatesWhenDerived = false;
+      if (metavariableValidates) {
+        const assumptionsValidate = this.validateAssumptions(stated, context);
 
-        if (stated) {
-          validatesWhenStated = this.validateWhenStated(context);
-        } else {
-          validatesWhenDerived = this.validateWhenDerived(context);
-        }
+        if (assumptionsValidate) {
+          let validatesWhenStated = false,
+              validatesWhenDerived = false;
+
+          if (stated) {
+            validatesWhenStated = this.validateWhenStated(context);
+          } else {
+            validatesWhenDerived = this.validateWhenDerived(context);
+          }
 
-        if (validatesWhenStated || validatesWhenDerived) {
-          validates = true;
+          if (validatesWhenStated || validatesWhenDerived) {
+            validates = true;
+          }
         }
       }
 
@@ -264,36 +255,6 @@ export default define(class Frame extends Element {
     return validatesWhenDerived;
   }
 
-  validateReference(stated, context) {
-    let referenceValidates = false;
-
-    const singular = this.isSingular();
-
-    if (singular) {
-      const frameString = this.getString(), ///
-            referenceString = this.reference.getString();
-
-      context.trace(`Validating the '${frameString}' frame's '${referenceString}' reference...`);
-
-      const metavariable = this.getMetavariable(),
-            metaTypeName = FRAME_META_TYPE_NAME,
-            frameMetaType = context.findMetaTypeByMetaTypeName(metaTypeName),
-            validatesGivenMetaType = metavariable.validateGivenMetaType(frameMetaType, context);
-
-      if (validatesGivenMetaType) {
-        referenceValidates = true;
-      }
-
-      if (referenceValidates) {
-        context.debug(`...validated the '${frameString}' frame's '${referenceString}' reference.`);
-      }
-    } else {
-      referenceValidates = true;
-    }
-
-    return referenceValidates;
-  }
-
   validateAssumption(assumption, context) {
     let assumptionValidates;
 
@@ -348,29 +309,30 @@ export default define(class Frame extends Element {
     return assumptionsValidate;
   }
 
-  validateGivenMetaType(metaType, stated, context) {
-    let validatesGivenMetaType = false;
+  validatMetavariable(stated, context) {
+    let metavariableValidates = false;
 
-    const frameString = this.getString(),  ///
-          metaTypeString = metaType.getString();
+    const singular = this.isSingular();
 
-    context.trace(`Validating the '${frameString}' frame given the '${metaTypeString}' meta-type...`);
+    if (singular) {
+      const frameString = this.getString(), ///
+            metavariableString = this.metavariable.getString();
 
-    const metaTypeName = metaType.getName();
+      context.trace(`Validating the '${frameString}' frame's '${metavariableString}' metavariable...`);
 
-    if (metaTypeName === FRAME_META_TYPE_NAME) {
-      const frame = this.validate(stated, context);
+      const metavariable = this.metavariable.validate(context),  ///
+            metaTypeName = FRAME_META_TYPE_NAME,
+            frameMetaType = context.findMetaTypeByMetaTypeName(metaTypeName),
+            metavariableMetaTypeEqualToFrameMetaType = metavariable.isMetaTypeEqualTo(frameMetaType);
 
-      if (frame !== null) {
-        validatesGivenMetaType = true;
+      if (metavariableMetaTypeEqualToFrameMetaType) {
+        metavariableValidates = true;
       }
+    } else {
+      metavariableValidates = true;
     }
 
-    if (validatesGivenMetaType) {
-      context.debug(`...validated the '${frameString}' frame given the '${metaTypeString}' meta-type.`);
-    }
-
-    return validatesGivenMetaType;
+    return metavariableValidates;
   }
 
   toJSON() {
@@ -389,12 +351,12 @@ export default define(class Frame extends Element {
       const { string } = json,
             frameNode = instantiateFrame(string, context),
             node = frameNode, ///
-            reference = referenceFromFrameNode(frameNode, context),
-            assumptions = assumptionsFromFrameNode(frameNode, context);
+            assumptions = assumptionsFromFrameNode(frameNode, context),
+            metavariable = metavariableFromFrameNode(frameNode, context);
 
       context = null;
 
-      const frame = new Frame(context, string, node, assumptions, reference);
+      const frame = new Frame(context, string, node, assumptions, metavariable);
 
       return frame;
     }, context);

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, context);
+    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) {
+      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, context);
-
-    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) {