occam-verify-cli 1.0.228 → 1.0.233

package/src/dom/hypothesis.js

@@ -0,0 +1,230 @@
+"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;
+  }
+
+  unifyHypothesis(hypothesis, substitutions, generalContext, specificContext) {
+    let hypothesisUnifies;
+
+    const context = specificContext,  ///
+          specificHypothesis = hypothesis,  ///
+          generalHypothesisString = this.string, ///
+          specificHypothesisString = specificHypothesis.getString();
+
+    context.trace(`Unifying the '${specificHypothesisString}' hypothesis with the '${generalHypothesisString}' hypothesis...`);
+
+    const statement = specificHypothesis.getStatement(),
+          statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+
+    hypothesisUnifies = statementUnifies;  ///
+
+    if (hypothesisUnifies) {
+      context.debug(`...unified the '${specificHypothesisString}' hypothesis with the '${generalHypothesisString}' hypothesis.`);
+    }
+
+    return hypothesisUnifies;
+  }
+
+  unifyIndependently(substitutions, context) {
+    let unifiesIndependently;
+
+    if (this.statement !== null) {
+      const statementResolvedIndependently = this.statement.unifyIndependently(substitutions, context);
+
+      unifiesIndependently = statementResolvedIndependently;  ///
+    }
+
+    if (this.procedureCall !== null) {
+      const procedureCallResolvedIndependently = this.procedureCall.unifyIndependently(substitutions, context);
+
+      unifiesIndependently = procedureCallResolvedIndependently;  ///
+    }
+
+    return unifiesIndependently;
+  }
+
+  unifyStepOrSubproof(stepOrSubproof, substitutions, generalContext, specificContext) {
+    let stepOrSubproofUnifies = false;
+
+    const stepOrSubProofStep = stepOrSubproof.isStep(),
+          subproof = stepOrSubProofStep ?
+                        null :
+                          stepOrSubproof,
+          step = stepOrSubProofStep ?
+                   stepOrSubproof :
+                     null;
+
+    substitutions.snapshot();
+
+    if (subproof !== null) {
+      const subproofUnifies = this.unifySubproof(subproof, substitutions, generalContext, specificContext);
+
+      stepOrSubproofUnifies = subproofUnifies; ///
+    }
+
+    if (step !== null) {
+      const statementUnifies = this.unifyStep(step, substitutions, generalContext, specificContext);
+
+      stepOrSubproofUnifies = statementUnifies;  ///
+    }
+
+    if (stepOrSubproofUnifies) {
+      substitutions.resolve(generalContext, specificContext);
+    }
+
+    stepOrSubproofUnifies ?
+      substitutions.continue() :
+        substitutions.rollback(specificContext);
+
+    return stepOrSubproofUnifies;
+  }
+
+  unifyStep(step, substitutions, generalContext, specificContext) {
+    let stepUnifies;
+
+    const statement = step.getStatement(),
+          statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+
+    stepUnifies = statementUnifies;  ///
+
+    return stepUnifies;
+  }
+
+  unifySubproof(subproof, substitutions, generalContext, specificContext) {
+    let subproofUnifies = false;
+
+    const hypothesis = this, ///
+          subproofString = subproof.getString(),
+          hypothesisStatement = hypothesis.getStatement(),
+          hypothesisStatementString = hypothesisStatement.getString();
+
+    specificContext.trace(`Unifying the '${subproofString}' subproof with the hypothesis's '${hypothesisStatementString}' statement...`);
+
+    if (this.statement !== null) {
+      const context = generalContext, ///
+            subproofAssertion = subproofAssertionFromStatement(this.statement, context);
+
+      if (subproofAssertion !== null) {
+        subproofUnifies = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);
+      }
+    }
+
+    if (subproofUnifies) {
+      specificContext.debug(`...unified the '${subproofString}' subproof with the hypothesis's '${hypothesisStatementString}' statement.`);
+    }
+
+    return subproofUnifies;
+  }
+
+  unifyStatement(statement, substitutions, generalContext, specificContext) {
+    let statementUnifies;
+
+    const hypothesis = this, ///
+          statementString = statement.getString(),
+          hypothesisString = hypothesis.getString();
+
+    specificContext.trace(`Unifying the '${statementString}' statement with the '${hypothesisString}' hypothesis...`);
+
+    if (this.statement !== null) {
+      statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
+    }
+
+    if (statementUnifies) {
+      specificContext.debug(`...unified the '${statementString}' statement with the '${hypothesisString}' hypothesis.`);
+    }
+
+    return statementUnifies;
+  }
+
+  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);
 

package/src/dom/premise.js

@@ -200,9 +200,9 @@ export default domAssigned(class Premise {
 
   static name = "Premise";
 
-  static fromJSON(json, fileContext) {
-    const statement = statementFromJSON(json, fileContext),
-          procedureCall = procedureCallFromJSON(json, fileContext);
+  static fromJSON(json, context) {
+    const statement = statementFromJSON(json, context),
+          procedureCall = procedureCallFromJSON(json, context);
 
     let string;
 
@@ -219,12 +219,12 @@ export default domAssigned(class Premise {
     return premise;
   }
 
-  static fromPremiseNode(premiseNode, fileContext) {
+  static fromPremiseNode(premiseNode, context) {
     const { Statement, ProcedureCall } = dom,
-          node = premiseNode,
-          string = fileContext.nodeAsString(node),
-          statement = Statement.fromPremiseNode(premiseNode, fileContext),
-          procedureCall = ProcedureCall.fromPremiseNode(premiseNode, fileContext),
+          node = premiseNode, ///
+          string = context.nodeAsString(node),
+          statement = Statement.fromPremiseNode(premiseNode, context),
+          procedureCall = ProcedureCall.fromPremiseNode(premiseNode, context),
           premise = new Premise(string, statement, procedureCall);
 
     return premise

package/src/dom/procedureCall.js

@@ -76,16 +76,16 @@ export default domAssigned(class ProcedureCall {
           nodes = this.findNodes(substitutions),
           expressions = Expressions.fromNodes(nodes, context);
 
-    try {
+    // try {
       const value = procedure.call(expressions, context),
             boolean = value.getBoolean();
 
       unifiesIndependently = boolean; ///
-    } catch (exception) {
-      const message = exception.getMessage();
-
-      context.info(message);
-    }
+    // } catch (exception) {
+    //   const message = exception.getMessage();
+    //
+    //   context.info(message);
+    // }
 
     if (unifiesIndependently) {
       context.debug(`...unified the '${procedureCallString}' procedure call independently.`);
@@ -109,9 +109,9 @@ export default domAssigned(class ProcedureCall {
 
   static name = "ProcedureCall";
 
-  static fromJSON(json, fileContext) {
-    const reference = referenceFromJSON(json, fileContext),
-          parameters = parametersFromJSON(json, fileContext),
+  static fromJSON(json, context) {
+    const reference = referenceFromJSON(json, context),
+          parameters = parametersFromJSON(json, context),
           string = stringFromReferenceAndParameters(reference, parameters),
           procedureCall = new ProcedureCall(string, reference, parameters);
 

package/src/dom/proof.js

@@ -52,13 +52,13 @@ export default domAssigned(class Proof {
 
   static name = "Proof";
 
-  static fromProofNode(proofNode, fileContext) {
+  static fromProofNode(proofNode, context) {
     let proof = null;
 
     if (proofNode !== null) {
       const { Derivation } = dom,
             derivationNode = proofNode.getDerivationNode(),
-            derivation = Derivation.fromDerivationNode(derivationNode, fileContext);
+            derivation = Derivation.fromDerivationNode(derivationNode, context);
 
       proof = new Proof(derivation);
     }

package/src/dom/property.js

@@ -50,29 +50,29 @@ export default domAssigned(class Property {
 
   static name = "Property";
 
-  static fromJSON(json, fileContext) {
+  static fromJSON(json, context) {
     const { name } = json,
-          type = typeFromJSON(json, fileContext),
+          type = typeFromJSON(json, context),
           string = name, ///
           property = new Property(string, name, type);
 
     return property;
   }
 
-  static fromPropertyNode(propertyNode, fileContext) {
-    const property = propertyFromPropertyNode(propertyNode, fileContext)
+  static fromPropertyNode(propertyNode, context) {
+    const property = propertyFromPropertyNode(propertyNode, context)
 
     return property;
   }
 
-  static fromPropertyRelationNode(propertyRelationNode, fileContext) {
+  static fromPropertyRelationNode(propertyRelationNode, context) {
     const propertyNode = propertyRelationNode.getPropertyNode(),
-          property = propertyFromPropertyNode(propertyNode, fileContext);
+          property = propertyFromPropertyNode(propertyNode, context);
 
     return property;
   }
 
-  static fromPropertyDeclarationNode(propertyDeclarationNode, fileContext) {
+  static fromPropertyDeclarationNode(propertyDeclarationNode, context) {
     const { Type } = dom,
           type = Type.fromPropertyDeclarationNode(propertyDeclarationNode),
           propertyName = propertyDeclarationNode.getPropertyName(),
@@ -84,7 +84,7 @@ export default domAssigned(class Property {
   }
 });
 
-function propertyFromPropertyNode(propertyNode, fileContext) {
+function propertyFromPropertyNode(propertyNode, context) {
   const { Property } = dom,
         propertyName = propertyNode.getPropertyName(),
         name = propertyName,  ///