occam-verify-cli 1.0.714 → 1.0.718

package/package.json

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

package/src/context/file/nominal.js

@@ -362,13 +362,12 @@ export default class NominalFileContext extends FileContext {
     this.trace(`Added the '${metavariableString}' metavariable to the '${filePath}' file context.`)
   }
 
-  findMetavariable(metavariable) {
+  findMetavariable(metavariable, context) {
     const metavariables = this.getMetavariables(),
           specificMetavariable = metavariable;  ///
 
     metavariable = metavariables.find((metavariable) => {
-      const context = this, ///
-            generalMetavariable = metavariable, ///
+      const generalMetavariable = metavariable, ///
             metavariableUnifies = generalMetavariable.unifyMetavariable(specificMetavariable, context);
 
       if (metavariableUnifies) {

package/src/context.js

@@ -108,14 +108,6 @@ export default class Context extends ContextBase {
     return subproofOrProofAssertions;
   }
 
-  findMetavariable(metavariable) {
-    const context = this.getContext();
-
-    metavariable = context.findMetavariable(metavariable);  ///
-
-    return metavariable;
-  }
-
   findRuleByReference(reference) {
     const context = this.getContext(),
           rule = context.findRuleByReference(reference);
@@ -144,6 +136,18 @@ export default class Context extends ContextBase {
     return metaType;
   }
 
+  findMetavariable(metavariable, context) {
+    const childContext = context; ///
+
+    context = this.getContext();
+
+    const parentContext = context; ///
+
+    metavariable = parentContext.findMetavariable(metavariable, childContext);  ///
+
+    return metavariable;
+  }
+
   findTermByTermNode(termNode) {
     const context = this.getContext(),
           term = context.findTermByTermNode(termNode);
@@ -271,8 +275,8 @@ export default class Context extends ContextBase {
     return procedure;
   }
 
-  isMetavariablePresent(metavariable) {
-    metavariable = this.findMetavariable(metavariable); ///
+  isMetavariablePresent(metavariable, context) {
+    metavariable = this.findMetavariable(metavariable, context);  ///
 
     const metavariablePresent = (metavariable !== null);
 

package/src/element/assertion/contained.js

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

package/src/element/assertion/defined.js

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

package/src/element/assertion/property.js

@@ -200,17 +200,6 @@ export default define(class PropertyAssertion extends Assertion {
     context.addAssignment(assignment);
   }
 
-  toJSON() {
-    const { name } = this.constructor,
-          string = this.getString(),
-          json = {
-            name,
-            string
-          };
-
-    return json;
-  }
-
   static name = "PropertyAssertion";
 
   static fromJSON(json, context) {

package/src/element/assertion/satisfies.js

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

package/src/element/assertion/subproof.js

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

package/src/element/assertion.js

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

package/src/element/declaration/metavariable.js

@@ -34,9 +34,15 @@ export default define(class MetavariableDeclaration extends Declaration {
     const metavariableVerifies = this.verifyMetavariable();
 
     if (metavariableVerifies) {
-      context.addMetavariable(this.metavariable);
+      const metavariableTypeVerified = this.verifyMetavariableType();
 
-      verifies = true;
+      if (metavariableTypeVerified) {
+        this.metavariable.setMetaType(this.metaType);
+
+        context.addMetavariable(this.metavariable);
+
+        verifies = true;
+      }
     }
 
     if (verifies) {
@@ -58,23 +64,17 @@ export default define(class MetavariableDeclaration extends Declaration {
     const metavariableNode = this.metavariable.getNode(), ///
           termNode = metavariableNode.getTermNode();
 
-    if (termNode !== null) {
-      context.debug(`A term was found in the '${metavariableString}' metavariable when a type should have been present.`);
-    } else {
+    if (termNode === null) {
       const metavariableName = this.metavariable.getName(),
             metavariablePresent = context.isMetavariablePresentByMetavariableName(metavariableName);
 
-      if (metavariablePresent) {
-        context.debug(`The '${metavariableName}' metavariable is already present.`);
+      if (!metavariablePresent) {
+        metavariableVerifies = true;
       } else {
-        const metavariableTypeVerified = this.verifyMetavariableType();
-
-        if (metavariableTypeVerified) {
-          this.metavariable.setMetaType(this.metaType);
-
-          metavariableVerifies = true;
-        }
+        context.debug(`The '${metavariableName}' metavariable is already present.`);
       }
+    } else {
+      context.debug(`A term was found in the '${metavariableString}' metavariable when a type should have been present.`);
     }
 
     if (metavariableVerifies) {
@@ -101,12 +101,12 @@ export default define(class MetavariableDeclaration extends Declaration {
       const nominalTypeName = metavariableType.getNominalTypeName(),
             type = context.findTypeByNominalTypeName(nominalTypeName);
 
-      if (type !== null) {
-        context.debug(`The '${metavariableTypeString}' type is not present.`);
-      } else {
+      if (type === null) {
         this.metavariable.setType(type);
 
         metavariableTypeVerified = true;
+      } else {
+        context.debug(`The '${metavariableTypeString}' type is not present.`);
       }
 
       if (metavariableTypeVerified) {

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 { metavariableFromFrameNode } from "../utilities/element";
+import { referenceFromFrameNode } from "../utilities/element";
 import { assumptionsStringFromAssumptions } from "../utilities/string";
 
 export default define(class Frame extends Element {
-  constructor(context, string, node, assumptions, metavariable) {
+  constructor(context, string, node, reference, assumptions) {
     super(context, string, node);
 
+    this.reference = reference;
     this.assumptions = assumptions;
-    this.metavariable = metavariable;
   }
 
   getAssumptions() {
     return this.assumptions;
   }
 
-  getMetavariable() {
-    return this.metavariable;
+  getReference() {
+    return this.reference;
   }
 
   getFrameNode() {
@@ -34,16 +34,28 @@ export default define(class Frame extends Element {
 
   getMetavariableName() {
     const frameNode = this.getFrameNode(),
-          metavariableName = frameNode.getMetavariableName();
+          referenceName = frameNode.getMetavariableName();
 
-    return metavariableName;
+    return referenceName;
   }
 
   getMetavariableNode() {
     const frameNode = this.getFrameNode(),
-          metavariableNode = frameNode.getMetavariableNode();
+          referenceNode = frameNode.getMetavariableNode();
 
-    return metavariableNode;
+    return referenceNode;
+  }
+
+  getMetavariable() {
+    let metavariable = null;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      metavariable = this.reference.getMetavariable();
+    }
+
+    return metavariable;
   }
 
   matchFrameNode(frameNode) {
@@ -184,10 +196,10 @@ export default define(class Frame extends Element {
     } else {
       let validates = false;
 
-      const assumptionsValidate = this.validateAssumptions(stated, context),
-            metavariablevalidates = this.validateMetavariable(stated, context);
+      const referenceValidates = this.validateReference(stated, context),
+            assumptionsValidate = this.validateAssumptions(stated, context);
 
-      if (assumptionsValidate && metavariablevalidates) {
+      if (referenceValidates && assumptionsValidate) {
         let validatesWhenStated = false,
             validatesWhenDerived = false;
 
@@ -252,6 +264,36 @@ 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;
 
@@ -306,41 +348,6 @@ export default define(class Frame extends Element {
     return assumptionsValidate;
   }
 
-  validateMetavariable(stated, context) {
-    let metavariableValidates = false;
-
-    const singular = this.isSingular();
-
-    if (singular) {
-      const frameString = this.getString(), ///
-            metavraibleString = this.metavariable.getString();
-
-      context.trace(`Validating the '${frameString}' frame's '${metavraibleString}' metavariable...`);
-
-      const metavariablePresent = context.isMetavariablePresent(this.metavariable);
-
-      if (metavariablePresent) {
-        const metaTypeName = FRAME_META_TYPE_NAME,
-              frameMetaType = context.findMetaTypeByMetaTypeName(metaTypeName),
-              metavariableValidateGivenMetaType = this.metavariable.validateGivenMetaType(frameMetaType, context);
-
-        if (metavariableValidateGivenMetaType) {
-          metavariableValidates = true;
-        }
-      } else {
-        context.debug(`The '${frameString}' frame's '${metavraibleString}' metavariable is not present.`);
-      }
-
-      if (metavariableValidates) {
-        context.debug(`...validated the '${frameString}' frame's '${metavraibleString}' metavariable.`);
-      }
-    } else {
-      metavariableValidates = true;
-    }
-
-    return metavariableValidates;
-  }
-
   validateGivenMetaType(metaType, stated, context) {
     let validatesGivenMetaType = false;
 
@@ -381,13 +388,13 @@ export default define(class Frame extends Element {
     const frame = literally((context) => {
       const { string } = json,
             frameNode = instantiateFrame(string, context),
-            node = frameNode,  ///
-            assumptions = assumptionsFromFrameNode(frameNode, context),
-            metavariable = metavariableFromFrameNode(frameNode, context);
+            node = frameNode, ///
+            reference = referenceFromFrameNode(frameNode, context),
+            assumptions = assumptionsFromFrameNode(frameNode, context);
 
       context = null;
 
-      const frame = new Frame(context, string, node, assumptions, metavariable);
+      const frame = new Frame(context, string, node, assumptions, reference);
 
       return frame;
     }, context);

package/src/element/metavariable.js

@@ -93,14 +93,14 @@ export default define(class Metavariable extends Element {
     context.trace(`Validating the '${metavariableString}' metavariable...`);
 
     const metavariable = this, ///
-          metavariablePresent = context.isMetavariablePresent(metavariable);
+          metavariablePresent = context.isMetavariablePresent(metavariable, context);
 
     if (metavariablePresent) {
       validates = true;
     }
 
     if (validates) {
-      context.debug(`...va;idated the '${metavariableString}' metavariable.`);
+      context.debug(`...validated the '${metavariableString}' metavariable.`);
     }
 
     return validates;
@@ -116,7 +116,7 @@ export default define(class Metavariable extends Element {
 
     let metavariable = this;  ///
 
-    metavariable = context.findMetavariable(metavariable);
+    metavariable = context.findMetavariable(metavariable, context);
 
     if (metavariable !== null) {
       const metavariableMetaTypeEqualToMetaType = metavariable.isMetaTypeEqualTo(metaType);

package/src/element/reference.js

@@ -165,7 +165,7 @@ export default define(class Reference extends Element {
     const metaTypeName = REFERENCE_META_TYPE_NAME,
           referenceMetaType = context.findMetaTypeByMetaTypeName(metaTypeName),
           metaType = referenceMetaType, ///
-          metavariable = context.findMetavariable(this.metavariable);
+          metavariable = context.findMetavariable(this.metavariable, context);
 
     if (metavariable !== null) {
       const metavariableValidatesGivenMetaType = metavariable.validateGivenMetaType(metaType, context);

package/src/element/statement.js

@@ -338,7 +338,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/utilities/element.js

@@ -123,12 +123,12 @@ export function frameFromFrameNode(frameNode, context) {
   const { Frame } = elements,
         node = frameNode, ///
         string = context.nodeAsString(node),
-        assumptions = assumptionsFromFrameNode(frameNode, context),
-        metavariable = metavariableFromFrameNode(frameNode, context);
+        reference = referenceFromFrameNode(frameNode, context),
+        assumptions = assumptionsFromFrameNode(frameNode, context);
 
   context = null;
 
-  const frame = new Frame(context, string, node, assumptions, metavariable);
+  const frame = new Frame(context, string, node, reference, assumptions);
 
   return frame;
 }
@@ -532,6 +532,19 @@ export function metatheoremFromMetatheoremNode(metatheoremNode, context) {
   return metatheorem;
 }
 
+export function referencesFromMetavariableNode(metavariableNode, context) {
+  const { Reference } = elements,
+        node = metavariableNode, ///
+        string = context.nodeAsString(node),
+        metavariable = metavariableFromMetavariableNode(metavariableNode, context);
+
+  context = null;
+
+  const reference = new Reference(context, string, node, metavariable);
+
+  return reference
+}
+
 export function metavariableFromMetavariableNode(metavariableNode, context) {
   const { Metavariable } = elements,
         node = metavariableNode,  ///
@@ -953,6 +966,18 @@ export function conclusionFromRuleNode(ruleNode, context) {
   return conclusion;
 }
 
+export function referenceFromFrameNode(frameNode, context) {
+  let reference = null;
+
+  const metavariableNode = frameNode.getMetavariableNode();
+
+  if (metavariableNode !== null) {
+    reference = referencesFromMetavariableNode(metavariableNode, context);
+  }
+
+  return reference;
+}
+
 export function theoremFromSectionNode(sectionNode, context) {
   let theorem = null;