occam-verify-cli 1.0.230 → 1.0.234

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "1.0.230",
+  "version": "1.0.234",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",
@@ -15,7 +15,7 @@
     "occam-custom-grammars": "^5.0.1222",
     "occam-entities": "^1.0.366",
     "occam-file-system": "^6.0.384",
-    "occam-furtle": "^2.0.173",
+    "occam-furtle": "^2.0.175",
     "occam-grammars": "^1.3.298",
     "occam-lexers": "^23.0.47",
     "occam-parsers": "^23.0.160",

package/src/assignment/variable.js

@@ -10,11 +10,13 @@ export default class VariableAssignment {
   }
 
   assign(context) {
-    const nested = false,
-          variableAdded = context.addVariable(this.variable, nested),
-          variableType = this.variable.getType(),
+    const nested = false;
+
+    context.addVariable(this.variable, nested);
+
+    const variableType = this.variable.getType(),
           variableString = this.variable.getString(),
-          variableAssigned = variableAdded, ///
+          variableAssigned = true, ///
           variableTypeString = variableType.getString();
 
     variableAssigned ?

package/src/context/file.js

@@ -529,14 +529,14 @@ export default class FileContext {
     return metaLemmaMetatheorems;
   }
 
-  findAxiomLemmaTheoremConjectureByReference(reference) {
+  findAxiomLemmaTheoremOrConjectureByReference(reference) {
     const axiom = this.findAxiomByReference(reference),
           lemma = this.findLemmaByReference(reference),
           theorem = this.findTheoremByReference(reference),
           conjecture = this.findConjectureByReference(reference),
-          axiomLemmaTheoremConjecture = (axiom || lemma || theorem || conjecture);
+          axiomLemmaTheoremOrConjecture = (axiom || lemma || theorem || conjecture);
 
-    return axiomLemmaTheoremConjecture;
+    return axiomLemmaTheoremOrConjecture;
   }
 
   findMetavariable(metavariable, generalContext, specificContext) {

package/src/context/local.js

@@ -116,7 +116,11 @@ class LocalContext {
 
   getConstructors() { return this.context.getConstructors(); }
 
-  getFileContext() { return this.context.getFileContext(); }
+  addAxiom(axiom) { this.context.addAxiom(axiom); }
+
+  addLemma(lemma) { this.context.addLemma(lemma); }
+
+  addTheorem(theorem) { this.context.addTheorem(theorem); }
 
   addEquality(equality, context) {
     let equalityAdded;
@@ -241,7 +245,7 @@ class LocalContext {
 
   isMetaLemmaMetatheoremPresentByReference(reference) { return this.context.isMetaLemmaMetatheoremPresentByReference(reference); }
 
-  findAxiomLemmaTheoremConjectureByReference(reference) { return this.context.findAxiomLemmaTheoremConjectureByReference(reference); }
+  findAxiomLemmaTheoremOrConjectureByReference(reference) { return this.context.findAxiomLemmaTheoremOrConjectureByReference(reference); }
 
   isMetavariablePresent(metavariable, generalContext, specificContext) { return this.context.isMetavariablePresent(metavariable, generalContext, specificContext); }
 
@@ -392,18 +396,6 @@ class LocalContext {
     return localContext;
   }
 
-  static fromFileContext(fileContext) {
-    const context = fileContext,  ///
-          tokens = null,
-          variables = [],
-          judgements = [],
-          equivalences = Equivalences.fromNothing(),
-          stepsOrSubproofs = [],
-          localContext = new LocalContext(context, tokens, variables, judgements, equivalences, stepsOrSubproofs);
-
-    return localContext;
-  }
-
   static fromContextAndTokens(context, tokens) {
     const variables = [],
           judgements = [],

package/src/dom/axiom.js

@@ -1,6 +1,5 @@
 "use strict";
 
-import LocalContext from "../context/local";
 import TopLevelAssertion  from "./topLevelAssertion";
 
 import { domAssigned } from "../dom";
@@ -17,10 +16,10 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
     let verifies;
 
     const axiom = this, ///
-          axiomString = axiom.getString(),
-          fileContext = this.getFileContext();
+          context = this.getContext(),
+          axiomString = axiom.getString();
 
-    fileContext.trace(`Verifying the '${axiomString}' axiom...`);
+    context.trace(`Verifying the '${axiomString}' axiom...`);
 
     const signatureVerifies = this.verifySignature();
 
@@ -31,9 +30,9 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
     if (verifies) {
       const axiom = this; ///
 
-      fileContext.addAxiom(axiom);
+      context.addAxiom(axiom);
 
-      fileContext.debug(`...verified the '${axiomString}' axiom.`);
+      context.debug(`...verified the '${axiomString}' axiom.`);
     }
 
     return verifies;
@@ -45,10 +44,8 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
     const satisfiable = this.isSatisfiable();
 
     if (satisfiable) {
-      const signature = this.getSignature(),
-            fileContext = this.getFileContext(),
-            localContext = LocalContext.fromFileContext(fileContext),
-            context = localContext; ///
+      const context = this.getContext(),
+            signature = this.getSignature();
 
       signatureVerifies = signature.verify(context);
     } else {
@@ -68,13 +65,13 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
 
       signature = this.getSignature()
 
-      const signatureB = signature; ///
-
-      const fileContext = this.getFileContext(),
-            localContext = LocalContext.fromFileContext(fileContext),
-            generalContext = localContext,  ///
+      const signatureB = signature, ///
             specificContext = context;  ///
 
+      context = this.getContext();
+
+      const generalContext = context;  ///
+
       signatureMatches = signatureA.match(signatureB, substitutions, generalContext, specificContext);
     }
 
@@ -95,10 +92,11 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
       context.trace(`Cannot unify the '${stepString}' step with the '${axiomString}' axiom because the axiom is not unconditional.`);
     } else {
       const statement = step.getStatement(),
-            fileContext = this.getFileContext(),
-            localContext = LocalContext.fromFileContext(fileContext),
-            generalContext = localContext,  ///
-            specificContext = context,  ///
+            specificContext = context;  ///
+
+      context = this.getContext();
+
+      const generalContext = context,  ///
             statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, generalContext, specificContext);
 
       if (statementUnifiesWithDeduction) {
@@ -150,10 +148,11 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
       context.trace(`Cannot unify the '${subproofString}' subproof with the '${axiomString}' axiom because the axiom is unconditional.`);
     } else {
       const lastStep = subproof.getLastStep(),
-            fileContext = this.getFileContext(),
-            localContext = LocalContext.fromFileContext(fileContext),
-            generalContext = localContext,  ///
-            specificContext = context,  ///
+            specificContext = context;  ///
+
+      context = this.getContext();
+
+      const generalContext = context,  ///
             lastStepUnifies = this.unifyLastStep(lastStep, substitutions, generalContext, specificContext);
 
       if (lastStepUnifies) {
@@ -235,41 +234,47 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
     return suppositionsUnify;
   }
 
-  unifyAxiomLemmaTheoremConjecture(axiomLemmaTheoremConjecture, substitutions, context) {
-    let axiomLemmaTheoremConjectureUnifies = false;
+  unifyAxiomLemmaTheoremOrConjecture(axiomLemmaTheoremOrConjecture, substitutions, context) {
+    let axiomLemmaTheoremOrConjectureUnifies = false;
 
     const axiomString = this.getString(),
-          axiomLemmaTheoremConjectureString = axiomLemmaTheoremConjecture.getString();
+          axiomLemmaTheoremOrConjectureString = axiomLemmaTheoremOrConjecture.getString();
+
+    context.trace(`Unifying the '${axiomLemmaTheoremOrConjectureString}' axiom, lemma, theorem or conjecture with the '${axiomString}' axiom...`);
 
-    context.trace(`Unifying the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture with the '${axiomString}' axiom...`);
+    const hypothesesCorrelate = axiomLemmaTheoremOrConjecture.correlateHypotheses(context);
+
+    if (hypothesesCorrelate) {
+      const deduction = axiomLemmaTheoremOrConjecture.getDeduction(),  ///
+            specificContext = context;  ///
 
-    const deduction = axiomLemmaTheoremConjecture.getDeduction(),  ///
-          fileContext = this.getFileContext(),
-          generalContext = fileContext, ///
-          specificContext = context,  ///
-          deductionUnifies = this.unifyDeduction(deduction, substitutions, generalContext, specificContext);
+      context = this.getContext();
 
-    if (deductionUnifies) {
-      const suppositions = axiomLemmaTheoremConjecture.getSuppositions(),
-            suppositionsUnify = this.unifySuppositions(suppositions, substitutions, generalContext, specificContext);
+      const generalContext = context, ///
+            deductionUnifies = this.unifyDeduction(deduction, substitutions, generalContext, specificContext);
 
-      axiomLemmaTheoremConjectureUnifies = suppositionsUnify; ///
+      if (deductionUnifies) {
+        const suppositions = axiomLemmaTheoremOrConjecture.getSuppositions(),
+              suppositionsUnify = this.unifySuppositions(suppositions, substitutions, generalContext, specificContext);
+
+        axiomLemmaTheoremOrConjectureUnifies = suppositionsUnify; ///
+      }
     }
 
-    if (axiomLemmaTheoremConjectureUnifies) {
-      context.debug(`...unified the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture with the '${axiomString}' axiom.`);
+    if (axiomLemmaTheoremOrConjectureUnifies) {
+      context.debug(`...unified the '${axiomLemmaTheoremOrConjectureString}' axiom, lemma, theorem or conjecture with the '${axiomString}' axiom.`);
     }
 
-    return axiomLemmaTheoremConjectureUnifies;
+    return axiomLemmaTheoremOrConjectureUnifies;
   }
 
   static name = "Axiom";
 
-  static fromJSON(json, fileContext) { return TopLevelAssertion.fromJSON(Axiom, json, fileContext); }
+  static fromJSON(json, context) { return TopLevelAssertion.fromJSON(Axiom, json, context); }
 
-  static fromAxiomNode(axiomNode, fileContext) {
+  static fromAxiomNode(axiomNode, context) {
     const node = axiomNode, ///
-          axiom = TopLevelAssertion.fromNode(Axiom, node, fileContext);
+          axiom = TopLevelAssertion.fromNode(Axiom, node, context);
 
     return axiom;
   }

package/src/dom/combinator.js

@@ -53,16 +53,16 @@ export default domAssigned(class Combinator {
     return json;
   }
 
-  static fromJSON(json, fileContext) {
-    const statement = statementFromJSON(json, fileContext),
+  static fromJSON(json, context) {
+    const statement = statementFromJSON(json, context),
           combinator = new Combinator(statement);
 
     return combinator;
   }
 
-  static fromCombinatorDeclarationNode(combinatorDeclarationNode, fileContext) {
+  static fromCombinatorDeclarationNode(combinatorDeclarationNode, context) {
     const { Statement } = dom,
-          statement = Statement.fromCombinatorDeclarationNode(combinatorDeclarationNode, fileContext),
+          statement = Statement.fromCombinatorDeclarationNode(combinatorDeclarationNode, context),
           combinator = new Combinator(statement);
 
     return combinator;

package/src/dom/conclusion.js

@@ -74,19 +74,19 @@ export  default domAssigned(class Conclusion {
 
   static name = "Conclusion";
 
-  static fromJSON(json, fileContext) {
-    const statement = statementFromJSON(json, fileContext),
+  static fromJSON(json, context) {
+    const statement = statementFromJSON(json, context),
           string = statement.getString(),
           conclusion = new Conclusion(string, statement);
 
     return conclusion;
   }
 
-  static fromConclusionNode(conclusionNode, fileContext) {
+  static fromConclusionNode(conclusionNode, context) {
     const { Statement } = dom,
           node = conclusionNode,  ///
-          string = fileContext.nodeAsString(node),
-          statement = Statement.fromConclusionNode(conclusionNode, fileContext),
+          string = context.nodeAsString(node),
+          statement = Statement.fromConclusionNode(conclusionNode, context),
           conclusion = new Conclusion(string, statement);
 
     return conclusion;

package/src/dom/conjecture.js

@@ -8,20 +8,20 @@ export default domAssigned(class Conjecture extends TopLevelAssertion {
   verify() {
     let verifies;
 
-    const conjecture = this,  ///
-          fileContext = this.getFileContext(),
+    const context = this.getContext(),
+          conjecture = this,  ///
           conjectureString = conjecture.getString();
 
-    fileContext.trace(`Verifying the '${conjectureString}' conjecture...`);
+    context.trace(`Verifying the '${conjectureString}' conjecture...`);
 
     verifies = super.verify();
 
     if (verifies) {
       const conjecture = this;  ///
 
-      fileContext.addConjecture(conjecture);
+      context.addConjecture(conjecture);
 
-      fileContext.debug(`...verified the '${conjectureString}' conjecture.`);
+      context.debug(`...verified the '${conjectureString}' conjecture.`);
     }
 
     return verifies;
@@ -29,11 +29,11 @@ export default domAssigned(class Conjecture extends TopLevelAssertion {
 
   static name = "Conjecture";
 
-  static fromJSON(json, fileContext) { return TopLevelAssertion.fromJSON(Conjecture, json, fileContext); }
+  static fromJSON(json, context) { return TopLevelAssertion.fromJSON(Conjecture, json, context); }
 
-  static fromConjectureNode(conjectureNode, fileContext) {
+  static fromConjectureNode(conjectureNode, context) {
     const node = conjectureNode,  ///
-          conjecture = TopLevelAssertion.fromNode(Conjecture, node, fileContext);
+          conjecture = TopLevelAssertion.fromNode(Conjecture, node, context);
 
     return conjecture;
   }

package/src/dom/constructor.js

@@ -67,17 +67,17 @@ export default domAssigned(class Constructor {
     return json;
   }
 
-  static fromJSON(json, fileContext) {
-    const term = termFromJSON(json, fileContext),
+  static fromJSON(json, context) {
+    const term = termFromJSON(json, context),
           string = stringFromTerm(term),
           constructor = new Constructor(string, term);
 
     return constructor;
   }
 
-  static fromConstructorDeclarationNode(constructorDeclarationNode, fileContext) {
+  static fromConstructorDeclarationNode(constructorDeclarationNode, context) {
     const { Term } = dom,
-          term = Term.fromConstructorDeclarationNode(constructorDeclarationNode, fileContext),
+          term = Term.fromConstructorDeclarationNode(constructorDeclarationNode, context),
           string = stringFromTerm(term),
           constructor = new Constructor(string, term);
 

package/src/dom/declaration/combinator.js

@@ -7,14 +7,14 @@ import { domAssigned } from "../../dom";
 import combinatorVerifier from "../../verifier/combinator";
 
 export default domAssigned(class CombinatorDeclaration {
-  constructor(fileContext, string, combinator) {
-    this.fileContext = fileContext;
+  constructor(context, string, combinator) {
+    this.context = context;
     this.string = string;
     this.combinator = combinator;
   }
 
-  getFileContext() {
-    return this.fileContext;
+  getContext() {
+    return this.context;
   }
 
   getString() {
@@ -30,18 +30,18 @@ export default domAssigned(class CombinatorDeclaration {
 
     const combinatorDeclarationString = this.getString(); ///
 
-    this.fileContext.trace(`Verifying the '${combinatorDeclarationString}' combinator declaration...`);
+    this.context.trace(`Verifying the '${combinatorDeclarationString}' combinator declaration...`);
 
     const combinatorVerifies = this.verifyCombinator();
 
     if (combinatorVerifies) {
-      this.fileContext.addCombinator(this.combinator);
+      this.context.addCombinator(this.combinator);
 
       verifies = true;
     }
 
     if (verifies) {
-      this.fileContext.debug(`...verified the '${combinatorDeclarationString}' combinator declaration.`);
+      this.context.debug(`...verified the '${combinatorDeclarationString}' combinator declaration.`);
     }
 
     return verifies;
@@ -52,15 +52,15 @@ export default domAssigned(class CombinatorDeclaration {
 
     const combinatorString = this.combinator.getString();
 
-    this.fileContext.trace(`Verifying the '${combinatorString}' combinator...`);
+    this.context.trace(`Verifying the '${combinatorString}' combinator...`);
 
     const statement = this.combinator.getStatement(),
           statementNode = statement.getNode();
 
-    statementVerifies = combinatorVerifier.verifyStatement(statementNode, this.fileContext);
+    statementVerifies = combinatorVerifier.verifyStatement(statementNode, this.context);
 
     if (statementVerifies) {
-      this.fileContext.debug(`...verified the '${combinatorString}' combinator.`);
+      this.context.debug(`...verified the '${combinatorString}' combinator.`);
     }
 
     return statementVerifies;
@@ -68,12 +68,12 @@ export default domAssigned(class CombinatorDeclaration {
 
   static name = "CombinatorDeclaration";
 
-  static fromCombinatorDeclarationNode(combinatorDeclarationNode, fileContext) {
+  static fromCombinatorDeclarationNode(combinatorDeclarationNode, context) {
     const { Combinator } = dom,
           node = combinatorDeclarationNode, ///
-          string = fileContext.nodeAsString(node),
-          combinator = Combinator.fromCombinatorDeclarationNode(combinatorDeclarationNode, fileContext),
-          combinatorDeclaration = new CombinatorDeclaration(fileContext, string, combinator);
+          string = context.nodeAsString(node),
+          combinator = Combinator.fromCombinatorDeclarationNode(combinatorDeclarationNode, context),
+          combinatorDeclaration = new CombinatorDeclaration(context, string, combinator);
 
     return combinatorDeclaration;
   }