occam-verify-cli 1.0.230 → 1.0.234

package/src/dom/declaration/variable.js

@@ -5,14 +5,14 @@ import dom from "../../dom";
 import { domAssigned } from "../../dom";
 
 export default domAssigned(class VariableDeclaration {
-  constructor(fileContext, string, variable) {
-    this.fileContext = fileContext;
+  constructor(context, string, variable) {
+    this.context = context;
     this.string = string;
     this.variable = variable;
   }
 
-  getFileContext() {
-    return this.fileContext;
+  getContext() {
+    return this.context;
   }
 
   getString() {
@@ -28,7 +28,7 @@ export default domAssigned(class VariableDeclaration {
 
     const variableDeclarationString = this.getString();
 
-    this.fileContext.trace(`Verifying the '${variableDeclarationString}' variable declaration...`);
+    this.context.trace(`Verifying the '${variableDeclarationString}' variable declaration...`);
 
     const variableTypeVerifies = this.verifyVariableType();
 
@@ -36,14 +36,14 @@ export default domAssigned(class VariableDeclaration {
       const variableVerifies = this.verifyVariable();
 
       if (variableVerifies) {
-        this.fileContext.addVariable(this.variable);
+        this.context.addVariable(this.variable);
 
         verifies = true;
       }
     }
 
     if (verifies) {
-      this.fileContext.debug(`...verified the '${variableDeclarationString}' variable declaration.`);
+      this.context.debug(`...verified the '${variableDeclarationString}' variable declaration.`);
     }
 
     return verifies;
@@ -54,19 +54,19 @@ export default domAssigned(class VariableDeclaration {
 
     const variableString = this.variable.getString();
 
-    this.fileContext.trace(`Verifying the '${variableString}' variable...`);
+    this.context.trace(`Verifying the '${variableString}' variable...`);
 
     const variableName = this.variable.getName(),
-          variablePresent = this.fileContext.isVariablePresentByVariableName(variableName);
+          variablePresent = this.context.isVariablePresentByVariableName(variableName);
 
     if (variablePresent) {
-      this.fileContext.debug(`The '${variableName}' variable is already present.`);
+      this.context.debug(`The '${variableName}' variable is already present.`);
     } else {
       variableVerifies = true;
     }
 
     if ( variableVerifies) {
-      this.fileContext.debug(`...verified the '${variableString}' variable.`);
+      this.context.debug(`...verified the '${variableString}' variable.`);
     }
 
     return  variableVerifies;
@@ -82,24 +82,24 @@ export default domAssigned(class VariableDeclaration {
     const typeName = type.getName(),
           typeString = type.getString();
 
-    this.fileContext.trace(`Verifying the '${typeString}' type...`);
+    this.context.trace(`Verifying the '${typeString}' type...`);
 
     const includeSupertypes = false,
           provisional = type.isProvisional(includeSupertypes);
 
-    type = this.fileContext.findTypeByTypeName(typeName);
+    type = this.context.findTypeByTypeName(typeName);
 
     const typePresent = (type !== null)
 
     if (!typePresent) {
-      this.fileContext.debug(`The '${typeString}' type is not present.`);
+      this.context.debug(`The '${typeString}' type is not present.`);
     } else {
       const provisionalMatches = type.matchProvisional(provisional);
 
       if (!provisionalMatches) {
         provisional ?
-          this.fileContext.debug(`The '${typeString}' type is present but not provisional.`) :
-            this.fileContext.debug(`The '${typeString}' type is present but provisional.`);
+          this.context.debug(`The '${typeString}' type is present but not provisional.`) :
+            this.context.debug(`The '${typeString}' type is present but provisional.`);
       } else {
         this.variable.setType(type);
 
@@ -108,7 +108,7 @@ export default domAssigned(class VariableDeclaration {
     }
 
     if (variableTypeVerifies) {
-      this.fileContext.debug(`...verified the '${typeString}' type.`);
+      this.context.debug(`...verified the '${typeString}' type.`);
     }
 
     return variableTypeVerifies;
@@ -116,12 +116,12 @@ export default domAssigned(class VariableDeclaration {
 
   static name = "VariableDeclaration";
 
-  static fromVariableDeclarationNode(variableDeclarationNode, fileContext) {
+  static fromVariableDeclarationNode(variableDeclarationNode, context) {
     const { Variable } = dom,
           node = variableDeclarationNode, ///
-          string = fileContext.nodeAsString(node),
-          variable = Variable.fromVariableDeclarationNode(variableDeclarationNode, fileContext),
-          variableDeclaration = new VariableDeclaration(fileContext, string, variable);
+          string = context.nodeAsString(node),
+          variable = Variable.fromVariableDeclarationNode(variableDeclarationNode, context),
+          variableDeclaration = new VariableDeclaration(context, string, variable);
 
     return variableDeclaration;
   }

package/src/dom/declaration.js

@@ -217,9 +217,11 @@ export default domAssigned(class Declaration {
 
     context.trace(`Unifying the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${declarationString}' declaration...`);
 
-    const fileContext = metaLemmaMetatheorem.getFileContext(),
-          generalContext = context, ///
-          specificContext = fileContext,
+    const generalContext = context; ///
+
+    context = metaLemmaMetatheorem.getContext();  ///
+
+    const specificContext = context,  ///
           labelSubstitutions = Substitutions.fromNothing(),
           label = metaLemmaMetatheorem.getLabel(),
           substitutions = labelSubstitutions, ///

package/src/dom/deduction.js

@@ -95,19 +95,19 @@ export default domAssigned(class Deduction {
 
   static name = "Deduction";
 
-  static fromJSON(json, fileContext) {
-    const statement = statementFromJSON(json, fileContext),
+  static fromJSON(json, context) {
+    const statement = statementFromJSON(json, context),
           string = statement.getString(),
           deduction = new Deduction(string, statement);
 
     return deduction;
   }
 
-  static fromDeductionNode(deductionNode, fileContext) {
+  static fromDeductionNode(deductionNode, context) {
     const { Statement } = dom,
           node = deductionNode,  ///
-          string = fileContext.nodeAsString(node),
-          statement = Statement.fromDeductionNode(deductionNode, fileContext),
+          string = context.nodeAsString(node),
+          statement = Statement.fromDeductionNode(deductionNode, context),
           deduction = new Deduction(string, statement);
 
     return deduction;

package/src/dom/derivation.js

@@ -52,22 +52,22 @@ export default domAssigned(class Derivation {
 
   static name = "Derivation";
 
-  static fromDerivationNode(derivationNode, fileContext) {
-    const stepsOrSubproofs = stepsOrSubproofsFromDerivationNode(derivationNode, fileContext),
+  static fromDerivationNode(derivationNode, context) {
+    const stepsOrSubproofs = stepsOrSubproofsFromDerivationNode(derivationNode, context),
           derivation = new Derivation(stepsOrSubproofs);
 
     return derivation;
   }
 });
 
-function stepsOrSubproofsFromDerivationNode(derivationNode, fileContext) {
+function stepsOrSubproofsFromDerivationNode(derivationNode, context) {
   const { Step, Subproof } = dom,
         stepOrSubproofNodes = derivationNode.getStepOrSubproofNodes(),
         stepsOrSubproofs = stepOrSubproofNodes.map((stepOrSubproofNode) => {
           let stepOrSubproof;
 
-          const step = Step.fromStepOrSubproofNode(stepOrSubproofNode, fileContext),
-                subproof = Subproof.fromStepOrSubproofNode(stepOrSubproofNode, fileContext);
+          const step = Step.fromStepOrSubproofNode(stepOrSubproofNode, context),
+                subproof = Subproof.fromStepOrSubproofNode(stepOrSubproofNode, context);
 
           if (false) {
             ///

package/src/dom/error.js

@@ -3,13 +3,13 @@
 import { domAssigned } from "../dom";
 
 export default domAssigned(class Error {
-  constructor(fileContext, string) {
-    this.fileContext = fileContext;
+  constructor(context, string) {
+    this.context = context;
     this.string = string;
   }
 
-  getFileContext() {
-    return this.fileContext;
+  getContext() {
+    return this.context;
   }
 
   getString() {
@@ -21,17 +21,17 @@ export default domAssigned(class Error {
 
     const errorString = this.string;  ///
 
-    this.fileContext.warning(`The '${errorString}' error cannot be verified.`);
+    this.context.warning(`The '${errorString}' error cannot be verified.`);
 
     return verifies;
   }
 
   static name = "Error";
 
-  static fromErrorNode(errorNode, fileContext) {
+  static fromErrorNode(errorNode, context) {
     const node = errorNode, ///
-          string = fileContext.nodeAsString(node),
-          error = new Error(fileContext, string);
+          string = context.nodeAsString(node),
+          error = new Error(context, string);
 
     return error;
   }

package/src/dom/hypothesis.js

@@ -0,0 +1,119 @@
+"use strict";
+
+import dom from "../dom";
+
+import { domAssigned } from "../dom";
+import { assignAssignments } from "../utilities/assignments";
+import { subproofAssertionFromStatement } from "../utilities/context";
+import { statementFromJSON, statementToStatementJSON } from "../utilities/json";
+
+export default domAssigned(class Hypothesis {
+  constructor(string, statement) {
+    this.string = string;
+    this.statement = statement;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getStatement() {
+    return this.statement;
+  }
+
+  verify(context) {
+    let verifies = false;
+
+    const hypothesisString = this.string; ///
+
+    context.trace(`Verifying the '${hypothesisString}' hypothesis...`);
+
+    if (false) {
+      ///
+    } else if (this.statement !== null) {
+      const stated = true,
+            assignments = [],
+            statementVerifies = this.statement.verify(assignments, stated, context);
+
+      if (statementVerifies) {
+        const assignmentsAssigned = assignAssignments(assignments, context);
+
+        if (assignmentsAssigned) {
+          const { Step } = dom,
+                step = Step.fromStatement(this.statement, context),
+                stepOrSubproof = step;  ///
+
+          context.addStepOrSubproof(stepOrSubproof);
+
+          verifies = true;
+        }
+      }
+    } else {
+      context.debug(`Unable to verify the '${hypothesisString}' hypothesis because it is nonsense.`);
+    }
+
+    if (verifies) {
+      context.debug(`...verified the '${hypothesisString}' hypothesis.`);
+    }
+
+    return verifies;
+  }
+
+  isEqualToStep(step, context) {
+    let equalToStep = false;
+
+    const stepString = step.getString(),
+          hypothesisString = this.string; ///
+
+    context.trace(`Is the '${hypothesisString}' hypothesis equal to the '${stepString}' step...`);
+
+    const stepStatement = step.getStatement(),
+          statementEqualToStepStatement = this.statement.isEqualTo(stepStatement);
+
+    if (statementEqualToStepStatement) {
+      equalToStep = true;
+    }
+
+    if (equalToStep) {
+      context.trace(`...the '${hypothesisString}' hypothesis is equal to the '${stepString}' step.`);
+    }
+
+    return equalToStep;
+  }
+
+  toJSON() {
+    const statementJSON = statementToStatementJSON(this.statement),
+          statement = statementJSON,  ///
+          json = {
+            statement
+          };
+
+    return json;
+  }
+
+  static name = "Hypothesis";
+
+  static fromJSON(json, context) {
+    const statement = statementFromJSON(json, context);
+
+    let string;
+
+    if (statement !== null) {
+      string = statement.getString();
+    }
+
+    const hypothesis = new Hypothesis(string, statement);
+
+    return hypothesis;
+  }
+
+  static fromHypothesisNode(hypothesisNode, context) {
+    const { Statement } = dom,
+          node = hypothesisNode, ///
+          string = context.nodeAsString(node),
+          statement = Statement.fromHypothesisNode(hypothesisNode, context),
+          hypothesis = new Hypothesis(string, statement);
+
+    return hypothesis
+  }
+});

package/src/dom/label.js

@@ -1,23 +1,22 @@
 "use strict";
 
 import dom from "../dom";
-import LocalContext from "../context/local";
 
 import { domAssigned } from "../dom";
 import { metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
 
 export default domAssigned(class Label {
-  constructor(metavariable, fileContext) {
+  constructor(context, metavariable) {
+    this.context = context;
     this.metavariable = metavariable;
-    this.fileContext = fileContext;
   }
 
-  getMetavariable() {
-    return this.metavariable;
+  getContext() {
+    return this.context;
   }
 
-  getFileContext() {
-    return this.fileContext;
+  getMetavariable() {
+    return this.metavariable;
   }
 
   getString() { return this.metavariable.getString(); }
@@ -56,28 +55,28 @@ export default domAssigned(class Label {
 
     const labelString = this.getString(); ///
 
-    this.fileContext.trace(`Verifying the '${labelString}' label...`);
+    this.context.trace(`Verifying the '${labelString}' label...`);
 
     let labelPresent;
 
     if (nameOnly) {
       const metavariableName = this.getMetavariableName();
 
-      labelPresent = this.fileContext.isLabelPresentByMetavariableName(metavariableName);
+      labelPresent = this.context.isLabelPresentByMetavariableName(metavariableName);
     } else {
       const metavariable = this.getMetavariable();
 
-      labelPresent = this.fileContext.isLabelPresentByMetavariable(metavariable);
+      labelPresent = this.context.isLabelPresentByMetavariable(metavariable);
     }
 
     if (labelPresent) {
-      this.fileContext.debug(`The '${labelString}' label is already present.`);
+      this.context.debug(`The '${labelString}' label is already present.`);
     } else {
       verifies = true;
     }
 
     if (verifies) {
-      this.fileContext.debug(`...verified the '${labelString}' label.`);
+      this.context.debug(`...verified the '${labelString}' label.`);
     }
 
     return verifies;
@@ -95,18 +94,17 @@ export default domAssigned(class Label {
 
   static name = "Label";
 
-  static fromJSON(json, fileContext) {
-    const metavariable = metavariableFromJSON(json, fileContext),
-          label = new Label(metavariable, fileContext);
+  static fromJSON(json, context) {
+    const metavariable = metavariableFromJSON(json, context),
+          label = new Label(context, metavariable);
 
     return label;
   }
 
-  static fromLabelNode(labelNode, fileContext) {
+  static fromLabelNode(labelNode, context) {
     const { Metavariable } = dom,
-          localContext = LocalContext.fromFileContext(fileContext),
-          metavariable = Metavariable.fromLabelNode(labelNode, localContext),
-          label = new Label(metavariable, fileContext);
+          metavariable = Metavariable.fromLabelNode(labelNode, context),
+          label = new Label(context, metavariable);
 
     return label;
   }

package/src/dom/lemma.js

@@ -9,23 +9,23 @@ export default domAssigned(class Lemma extends TopLevelAssertion {
     let verifies;
 
     const lemma = this, ///
-          fileContext = this.getFileContext(),
+          context = this.getContext(),
           lemmaString = lemma.getString();
 
     (lemmaString === null) ?
-      fileContext.trace(`Verifying a lemma...`) :
-        fileContext.trace(`Verifying the '${lemmaString}' lemma...`);
+      context.trace(`Verifying a lemma...`) :
+        context.trace(`Verifying the '${lemmaString}' lemma...`);
 
     verifies = super.verify();
 
     if (verifies) {
       const lemma = this; ///
 
-      fileContext.addLemma(lemma);
+      context.addLemma(lemma);
 
       (lemmaString === null) ?
-        fileContext.debug(`...verified a lemma.`) :
-          fileContext.debug(`...verified the '${lemmaString}' lemma.`);
+        context.debug(`...verified a lemma.`) :
+          context.debug(`...verified the '${lemmaString}' lemma.`);
     }
 
     return verifies;
@@ -33,9 +33,9 @@ export default domAssigned(class Lemma extends TopLevelAssertion {
 
   static name = "Lemma";
 
-  static fromLemmaNode(lemmaNode, fileContext) {
+  static fromLemmaNode(lemmaNode, context) {
     const node = lemmaNode, ///
-          lemma = TopLevelAssertion.fromNode(Lemma, node, fileContext);
+          lemma = TopLevelAssertion.fromNode(Lemma, node, context);
 
     return lemma;
   }

package/src/dom/metaLemma.js

@@ -8,20 +8,20 @@ export default domAssigned(class MetaLemma extends TopLevelMetaAssertion {
   verify() {
     let verifies;
 
-    const metaLemma = this, ///
-          fileContext = this.getFileContext(),
+    const context = this.getContext(),
+          metaLemma = this, ///
           metaLemmaString = metaLemma.getString();
 
-    fileContext.trace(`Verifying the '${metaLemmaString}' meta-lemma...`);
+    context.trace(`Verifying the '${metaLemmaString}' meta-lemma...`);
 
     verifies = super.verify();
 
     if (verifies) {
       const metaTheorem = this; ///
 
-      fileContext.addMetatheorem(metaTheorem);
+      context.addMetatheorem(metaTheorem);
 
-      fileContext.debug(`...verified the '${metaLemmaString}' meta-lemma.`);
+      context.debug(`...verified the '${metaLemmaString}' meta-lemma.`);
     }
 
     return verifies;
@@ -29,11 +29,11 @@ export default domAssigned(class MetaLemma extends TopLevelMetaAssertion {
 
   static name = "MetaLemma";
 
-  static fromJSON(json, fileContext) { return TopLevelMetaAssertion.fromJSON(MetaLemma, json, fileContext); }
+  static fromJSON(json, context) { return TopLevelMetaAssertion.fromJSON(MetaLemma, json, context); }
 
-  static fromMetaLemmaNode(metaLemmaNode, fileContext) {
+  static fromMetaLemmaNode(metaLemmaNode, context) {
     const node = metaLemmaNode, ///
-          metaLemma = TopLevelMetaAssertion.fromNode(MetaLemma, node, fileContext);
+          metaLemma = TopLevelMetaAssertion.fromNode(MetaLemma, node, context);
 
     return metaLemma;
   }

package/src/dom/metaType.js

@@ -1,7 +1,5 @@
 "use strict";
 
-import LocalContext from "../context/local";
-
 import { domAssigned } from "../dom";
 import { FRAME_META_TYPE_NAME, REFERENCE_META_TYPE_NAME, STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 
@@ -43,7 +41,7 @@ class MetaType {
 
   static name = "MetaType";
 
-  static fromJSON(json, fileContext) {
+  static fromJSON(json, context) {
     const { name } = json,
           metaTypeName = name,  ///
           metaType = metaTypeFromMetaTypeName(metaTypeName);
@@ -57,10 +55,8 @@ class MetaType {
     return metaType;
   }
 
-  static fromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext) {
+  static fromMetavariableDeclarationNode(metavariableDeclarationNode, context) {
     const metaTypeNode = metavariableDeclarationNode.getMetaTypeNode(),
-          localContext = LocalContext.fromFileContext(fileContext),
-          context = localContext, ///
           metaType = metaTypeFromMetaTypeNode(metaTypeNode, context);
 
     return metaType;

package/src/dom/metatheorem.js

@@ -8,20 +8,20 @@ export default domAssigned(class Metatheorem extends TopLevelMetaAssertion {
   verify() {
     let verifies;
 
-    const metaLemma = this, ///
-          fileContext = this.getFileContext(),
+    const context = this.getContext(),
+          metaLemma = this, ///
           metaLemmaString = metaLemma.getString();
 
-    fileContext.trace(`Verifying the '${metaLemmaString}' metatheorem...`);
+    context.trace(`Verifying the '${metaLemmaString}' metatheorem...`);
 
     verifies = super.verify();
 
     if (verifies) {
       const metaTheorem = this; ///
 
-      fileContext.addMetatheorem(metaTheorem);
+      context.addMetatheorem(metaTheorem);
 
-      fileContext.debug(`...verified the '${metaLemmaString}' metatheorem.`);
+      context.debug(`...verified the '${metaLemmaString}' metatheorem.`);
     }
 
     return verifies;
@@ -29,11 +29,11 @@ export default domAssigned(class Metatheorem extends TopLevelMetaAssertion {
 
   static name = "Metatheorem";
 
-  static fromJSON(json, fileContext) { return TopLevelMetaAssertion.fromJSON(Metatheorem, json, fileContext); }
+  static fromJSON(json, context) { return TopLevelMetaAssertion.fromJSON(Metatheorem, json, context); }
 
-  static fromMetatheoremNode(metatheoremNode, fileContext) {
+  static fromMetatheoremNode(metatheoremNode, context) {
     const node = metatheoremNode, ///
-          metatheorem = TopLevelMetaAssertion.fromNode(Metatheorem, node, fileContext);
+          metatheorem = TopLevelMetaAssertion.fromNode(Metatheorem, node, context);
 
     return metatheorem;
   }

package/src/dom/metavariable.js

@@ -1,7 +1,6 @@
 "use strict";
 
 import dom from "../dom";
-import LocalContext from "../context/local";
 import MetavariablePartialContext from "../context/partial/metavariable";
 
 import { domAssigned } from "../dom";
@@ -442,10 +441,10 @@ export default domAssigned(class Metavariable {
 
   static name = "Metavariable";
 
-  static fromJSON(json, fileContext) {
+  static fromJSON(json, context) {
     const { string } = json,
-          lexer = fileContext.getLexer(),
-          parser = fileContext.getParser(),
+          lexer = context.getLexer(),
+          parser = context.getParser(),
           metavariablePartialContext = MetavariablePartialContext.fromStringLexerAndParser(string, lexer, parser),
           metavariableTokens = metavariablePartialContext.getMetavariableTokens(),
           metavariableNode = metavariablePartialContext.getMetavariableNode(),
@@ -453,8 +452,8 @@ export default domAssigned(class Metavariable {
           name = metavariableName,  ///
           node = metavariableNode,  ///
           tokens = metavariableTokens, ///
-          type = typeFromJSON(json, fileContext),
-          metaType = metaTypeFromJSON(json, fileContext),
+          type = typeFromJSON(json, context),
+          metaType = metaTypeFromJSON(json, context),
           metavariable = new Metavariable(string, node, tokens, name, type, metaType);
 
     return metavariable;
@@ -510,12 +509,10 @@ export default domAssigned(class Metavariable {
     return metavariable;
   }
 
-  static fromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext) {
+  static fromMetavariableDeclarationNode(metavariableDeclarationNode, context) {
     const { MetaType } = dom,
           metavariableNode = metavariableDeclarationNode.getMetavariableNode(),
-          localContext = LocalContext.fromFileContext(fileContext),
-          context = localContext, ///
-          type = typeFromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext),
+          type = typeFromMetavariableDeclarationNode(metavariableDeclarationNode, context),
           metaType = MetaType.fromMetavariableDeclarationNode(metavariableDeclarationNode, context),
           metavariable = metavariableFromMetavariableNode(metavariableNode, context);
 
@@ -541,7 +538,7 @@ function metavariableFromMetavariableNode(metavariableNode, context) {
   return metavariable;
 }
 
-function typeFromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext) {
+function typeFromMetavariableDeclarationNode(metavariableDeclarationNode, context) {
   let type = null;
 
   const typeNode = metavariableDeclarationNode.getTypeNode();
@@ -549,7 +546,7 @@ function typeFromMetavariableDeclarationNode(metavariableDeclarationNode, fileCo
   if (typeNode !== null) {
     const typeName = typeNode.getTypeName();
 
-    type = fileContext.findTypeByTypeName(typeName);
+    type = context.findTypeByTypeName(typeName);
   }
 
   return type;

package/src/dom/parameter.js

@@ -46,7 +46,7 @@ export default domAssigned(class Parameter {
 
   static name = "Parameter";
 
-  static fromJSON(json, fileContext) {
+  static fromJSON(json, context) {
     const { name } = json,
           parameter = new Parameter(name);