occam-verify-cli 0.0.1111 → 0.0.1114

package/src/context/file.js

@@ -2,10 +2,11 @@
 
 import { arrayUtilities } from "necessary";
 
-import shim from "../shim";
+import Equivalences from "../equivalences";
+import Substitutions from "../substitutions";
 
-import { objectType } from "../type";
-import { frameMetaType, referenceMetaType, statementMetaType } from "../metaType";
+import { objectType } from "../dom/type";
+import { frameMetaType, referenceMetaType, statementMetaType } from "../dom/metaType";
 import { nodeAsTokens, nodeAsString, nodesAsString, tokensAsString } from "../utilities/string";
 import { typesFromJSON,
          rulesFromJSON,
@@ -87,7 +88,7 @@ export default class FileContext {
   }
 
   getEquivalences() {
-    const equivalences = []; ///
+    const equivalences = Equivalences.fromNothing();
 
     return equivalences;
   }
@@ -511,8 +512,7 @@ export default class FileContext {
     const metaLemmas = this.getMetaLemmas();
 
     filter(metaLemmas, (metaLemma) => {
-      const { Substitutions } = shim,
-            context = this, ///
+      const context = this, ///
             substitutions = Substitutions.fromNothing(),
             referenceUnified = metaLemma.unifyReference(reference, substitutions, context);
 
@@ -528,8 +528,7 @@ export default class FileContext {
     const metatheorems = this.getMetatheorems();
 
     filter(metatheorems, (metatheorem) => {
-      const { Substitutions } = shim,
-            context = this, ///
+      const context = this, ///
             substitutions = Substitutions.fromNothing(),
             referenceUnified = metatheorem.unifyReference(reference, substitutions, context);
 
@@ -541,6 +540,16 @@ export default class FileContext {
     return metatheorems;
   }
 
+  findAxiomLemmaTheoremConjectureByReference(reference) {
+    const axiom = this.findAxiomByReference(reference),
+          lemma = this.findLemmaByReference(reference),
+          theorem = this.findTheoremByReference(reference),
+          conjecture = this.findConjectureByReference(reference),
+          axiomLemmaTheoremConjecture = (axiom || lemma || theorem || conjecture);
+
+    return axiomLemmaTheoremConjecture;
+  }
+
   findVariable(variable) {
     const specificVariable = variable,  ///
           variables = this.getVariables();
@@ -606,6 +615,13 @@ export default class FileContext {
     return metavariable;
   }
 
+  isRulePresentByReference(reference) {
+    const rule = this.findRuleByReference(reference),
+          rulePresent = (rule !== null);
+
+    return rulePresent;
+  }
+
   isAxiomPresentByReference(reference) {
     const axiom = this.findAxiomByReference(reference),
           axiomPresent = (axiom !== null);
@@ -634,7 +650,14 @@ export default class FileContext {
     return conjecturePresent;
   }
 
-  areMetaLemmaPresentByReference(reference) {
+  isAxiomLemmaTheoremConjecturePresentByReference(reference) {
+    const axiomLemmaTheoremConjecture = this.findAxiomLemmaTheoremConjectureByReference(reference),
+          axiomLemmaTheoremConjecturePresent = (axiomLemmaTheoremConjecture !== null);
+
+    return axiomLemmaTheoremConjecturePresent;
+  }
+
+  areMetaLemmasPresentByReference(reference) {
     const metaLemmas = this.findMetaLemmasByReference(reference),
           metaLemmasLength = metaLemmas.length,
           metaLemmasPresent = (metaLemmasLength > 0);
@@ -642,7 +665,7 @@ export default class FileContext {
     return metaLemmasPresent;
   }
 
-  areMetatheoremPresentByReference(reference) {
+  areMetatheoremsPresentByReference(reference) {
     const metatheorems = this.findMetatheoremsByReference(reference),
           metatheoremsLength = metatheorems.length, ///
           metatheoremsPresent = (metatheoremsLength > 0);
@@ -650,6 +673,14 @@ export default class FileContext {
     return metatheoremsPresent;
   }
 
+  areMetaLemmasMetaTheoremsPresentByReference(reference) {
+    const metaLemmasPresent = this.areMetaLemmasPresentByReference(reference),
+          metatheoremsPresent = this.areMetatheoremsPresentByReference(reference),
+          metaLemmasMetaTheoremsPresent = (metaLemmasPresent || metatheoremsPresent);
+
+    return metaLemmasMetaTheoremsPresent;
+  }
+
   nodeAsString(node, tokens = null) {
     if (tokens === null) {
       tokens = this.tokens;
@@ -751,7 +782,7 @@ export default class FileContext {
   error(message) { this.releaseContext.error(message, this.filePath); }
 
   initialise(json) {
-    const fileContext = this;
+    const fileContext = this; ///
 
     this.types = [];
 

package/src/context/local.js

@@ -3,8 +3,7 @@
 import { arrayUtilities } from "necessary";
 
 import Equivalence from "../equivalence";
-
-import { mergeEquivalences, findEquivalenceByTerm, groundedTermsAndDefinedVariablesFromFromEquivalences } from "../utilities/equivalences";
+import Equivalences from "../equivalences";
 
 const { last } = arrayUtilities;
 
@@ -68,10 +67,7 @@ class LocalContext {
   getEquivalences() {
     let equivalences = this.context.getEquivalences();
 
-    const equivalencesA = this.equivalences, ///
-          equivalencesB = equivalences;
-
-    equivalences = mergeEquivalences(equivalencesA, equivalencesB); ///
+    equivalences = this.equivalences.mergedWith(equivalences);  ///
 
     return equivalences;
   }
@@ -116,8 +112,8 @@ class LocalContext {
     } else {
       const leftTerm = equality.getLeftTerm(),
             rightTerm = equality.getRightTerm(),
-            leftEquivalence = findEquivalenceByTerm(this.equivalences, leftTerm),
-            rightEquivalence = findEquivalenceByTerm(this.equivalences, rightTerm);
+            leftEquivalence = this.equivalences.findEquivalenceByTerm(leftTerm),
+            rightEquivalence = this.equivalences.findEquivalenceByTerm(rightTerm);
 
       if (false) {
         ///
@@ -143,9 +139,9 @@ class LocalContext {
         } else {
           equivalence = Equivalence.merge(leftEquivalence, rightEquivalence);
 
-          this.removeEquivalence(leftEquivalence);
+          this.removeEquivalence(leftEquivalence, context);
 
-          this.removeEquivalence(rightEquivalence);
+          this.removeEquivalence(rightEquivalence, context);
 
           this.addEquivalence(equivalence);
         }
@@ -180,21 +176,9 @@ class LocalContext {
     this.proofSteps.push(proofStep);
   }
 
-  addEquivalence(equivalence, context) {
-    const equivalenceString = equivalence.asString();
-
-    context.trace(`Added the '${equivalenceString}' equivalence.`);
+  addEquivalence(equivalence, context) { return this.equivalences.addEquivalence(equivalence, context); }
 
-    this.equivalences.push(equivalence);
-  }
-
-  removeEquivalence(equivalence) {
-    const index = this.equivalences.indexOf(equivalence),
-          start = index,  ///
-          deleteCount = 1;
-
-    this.equivalences.splice(start, deleteCount);
-  }
+  removeEquivalence(equivalence, context) { return this.equivalences.removeEquivalence(equivalence, context); }
 
   addJudgement(judgement) {
     let judgementAdded = false;
@@ -215,7 +199,7 @@ class LocalContext {
     let termType;
 
     const equivalences = this.getEquivalences(),
-          equivalence = findEquivalenceByTerm(equivalences, term);
+          equivalence = equivalences.findEquivalenceByTerm(term);
 
     if (equivalence !== null) {
       const LocalContext = this,  ///
@@ -230,12 +214,12 @@ class LocalContext {
   }
 
   isTermGrounded(term) {
-    const context = this,
+    const context = this, ///
           equivalences = this.getEquivalences(),
           groundedTerms = [],
           definedVariables = [];
 
-    groundedTermsAndDefinedVariablesFromFromEquivalences(equivalences, groundedTerms, definedVariables, context);
+    equivalences.separateGroundedTermsAndDefinedVariables(groundedTerms, definedVariables, context);
 
     const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
             const groundedTermNode = groundedTerm.getNode(),
@@ -251,12 +235,12 @@ class LocalContext {
   }
 
   isVariableDefined(variable) {
-    const context = this,
+    const context = this, ///
           equivalences = this.getEquivalences(),
           groundedTerms = [],
           definedVariables = [];
 
-    groundedTermsAndDefinedVariablesFromFromEquivalences(equivalences, groundedTerms, definedVariables, context);
+    equivalences.separateGroundedTermsAndDefinedVariables(groundedTerms, definedVariables, context);
 
     const variableMatchesDefinedVariable = definedVariables.some((definedVariable) => {
             const definedVariableEqualToVariable = definedVariable.isEqualTo(variable);
@@ -353,6 +337,10 @@ class LocalContext {
 
   findMetatheoremsByReference(reference) { return this.context.findMetatheoremsByReference(reference); }
 
+  findAxiomLemmaTheoremConjectureByReference(reference) { return this.context.findAxiomLemmaTheoremConjectureByReference(reference); }
+
+  isRulePresentByReference(reference) { return this.context.isRulePresentByReference(reference); }
+
   isAxiomPresentByReference(reference) { return this.context.isAxiomPresentByReference(reference); }
 
   isLemmaPresentByReference(reference) { return this.context.isLemmaPresentByReference(reference); }
@@ -361,9 +349,13 @@ class LocalContext {
 
   isConjecturePresentByReference(reference) { return this.context.isConjecturePresentByReference(reference); }
 
-  areMetaLemmaPresentByReference(reference) { return this.context.areMetaLemmaPresentByReference(reference); }
+  areMetaLemmasPresentByReference(reference) { return this.context.areMetaLemmasPresentByReference(reference); }
+
+  areMetatheoremsPresentByReference(reference) { return this.context.areMetatheoremsPresentByReference(reference); }
+
+  areMetaLemmasMetaTheoremsPresentByReference(reference) { return this.context.areMetaLemmasMetaTheoremsPresentByReference(reference); }
 
-  areMetatheoremPresentByReference(reference) { return this.context.areMetatheoremPresentByReference(reference); }
+  isAxiomLemmaTheoremConjecturePresentByReference(reference) { return this.context.isAxiomLemmaTheoremConjecturePresentByReference(reference) }
 
   nodeAsString(node, tokens = null) {
     if (tokens === null) {
@@ -422,7 +414,7 @@ class LocalContext {
           variables = [],
           proofSteps = [],
           judgements = [],
-          equivalences = [],
+          equivalences = Equivalences.fromNothing(),
           localContext = new LocalContext(context, tokens, variables, proofSteps, judgements, equivalences);
 
     return localContext;
@@ -434,7 +426,7 @@ class LocalContext {
           variables = [],
           proofSteps = [],
           judgements = [],
-          equivalences = [],
+          equivalences = Equivalences.fromNothing(),
           localContext = new LocalContext(context, tokens, variables, proofSteps, judgements, equivalences);
 
     return localContext;
@@ -444,7 +436,7 @@ class LocalContext {
     const variables = [],
           proofSteps = [],
           judgements = [],
-          equivalences = [],
+          equivalences = Equivalences.fromNothing(),
           localContext = new LocalContext(context, tokens, variables, proofSteps, judgements, equivalences);
 
     return localContext;

package/src/context/release.js

@@ -8,7 +8,7 @@ import topLevelVerifier from "../verifier/topLevel";
 import { filePathUtilities } from "occam-entities";
 import { lexersUtilities, parsersUtilities } from "occam-custom-grammars";
 
-import { objectType } from "../type";
+import { objectType } from "../dom/type";
 import { customGrammarFromNameAndEntries, combinedCustomGrammarFromReleaseContexts } from "../utilities/customGrammar";
 
 const { isFilePathNominalFilePath } = filePathUtilities,

package/src/{assertion → dom/assertion}/contained.js

@@ -1,15 +1,16 @@
 "use strict";
 
-import shim from "../shim";
-import LocalContext from "../context/local";
+import dom from "../../dom";
+import LocalContext from "../../context/local";
 
-import { nodeQuery } from "../utilities/query";
-import { isAssertionNegated } from "../utilities/assertion";
-import { termFromTermAndSubstitutions, frameFromFrameAndSubstitutions, statementFromStatementAndSubstitutions } from "../utilities/substitutions";
+import { nodeQuery } from "../../utilities/query";
+import { domAssigned } from "../../dom";
+import { isAssertionNegated } from "../../utilities/assertion";
+import { termFromTermAndSubstitutions, frameFromFrameAndSubstitutions, statementFromStatementAndSubstitutions } from "../../utilities/substitutions";
 
 const containedAssertionNodeQuery = nodeQuery("/statement/containedAssertion");
 
-export default class ContainedAssertion {
+export default domAssigned(class ContainedAssertion {
   constructor(string, node, tokens, term, frame, negated, statement) {
     this.string = string;
     this.node = node;
@@ -174,13 +175,15 @@ export default class ContainedAssertion {
     return verifiedWhenDerived;
   }
 
+  static name = "ContainedAssertion";
+
   static fromStatementNode(statementNode, context) {
     let containedAssertion = null;
 
     const containedAssertionNode = containedAssertionNodeQuery(statementNode);
 
     if (containedAssertionNode !== null) {
-      const { Term, Frame, Statement } = shim,
+      const { Term, Frame, Statement } = dom,
             node = containedAssertionNode,  ///
             string = context.nodeAsString(node),
             tokens = context.nodeAsTokens(node),
@@ -195,7 +198,7 @@ export default class ContainedAssertion {
 
     return containedAssertion;
   }
-}
+});
 
 function verifyWhenDerived(term, frame, statement, negated, context) {
   let verifiedWhenDerived = false;

package/src/{assertion → dom/assertion}/defined.js

@@ -1,15 +1,16 @@
 "use strict";
 
-import shim from "../shim";
-import LocalContext from "../context/local";
+import dom from "../../dom";
+import LocalContext from "../../context/local";
 
-import { nodeQuery } from "../utilities/query";
-import { isAssertionNegated } from "../utilities/assertion";
-import { termFromTermAndSubstitutions, frameFromFrameAndSubstitutions } from "../utilities/substitutions";
+import { nodeQuery } from "../../utilities/query";
+import { domAssigned } from "../../dom";
+import { isAssertionNegated } from "../../utilities/assertion";
+import { termFromTermAndSubstitutions, frameFromFrameAndSubstitutions } from "../../utilities/substitutions";
 
 const definedAssertionNodeQuery = nodeQuery("/statement/definedAssertion");
 
-export default class DefinedAssertion {
+export default domAssigned(class DefinedAssertion {
   constructor(string, node, tokens, term, frame, negated) {
     this.string = string;
     this.node = node;
@@ -153,13 +154,15 @@ export default class DefinedAssertion {
     return verifiedWhenDerived;
   }
 
+  static name = "DefinedAssertion";
+
   static fromStatementNode(statementNode, context) {
     let definedAssertion = null;
 
     const definedAssertionNode = definedAssertionNodeQuery(statementNode);
 
     if (definedAssertionNode !== null) {
-      const { Term, Frame } = shim,
+      const { Term, Frame } = dom,
             node = definedAssertionNode,  ///
             string = context.nodeAsString(node),
             tokens = context.nodeAsTokens(node),
@@ -173,13 +176,13 @@ export default class DefinedAssertion {
 
     return definedAssertion;
   }
-}
+});
 
 function verifyWhenDerived(term, frame, negated, context) {
   let verifiedWhenDerived = false;
 
   if (term !== null) {
-    const { Variable } = shim,
+    const { Variable } = dom,
           termNode = term.getNode(),
           variable = Variable.fromTermNode(termNode, context),
           generalContext = context, ///
@@ -195,7 +198,7 @@ function verifyWhenDerived(term, frame, negated, context) {
   }
 
   if (frame!== null) {
-    const { Metavariable } = shim,
+    const { Metavariable } = dom,
           frameNode = frame.getNode(),
           metavariable = Metavariable.fromFrameNode(frameNode, context),
           metavariableDefined = context.isMetavariableDefined(metavariable);
@@ -210,4 +213,4 @@ function verifyWhenDerived(term, frame, negated, context) {
   }
 
   return verifiedWhenDerived;
-}
+}

package/src/{assertion → dom/assertion}/subproof.js

@@ -2,17 +2,18 @@
 
 import { arrayUtilities } from "necessary";
 
-import shim from "../shim";
+import dom from "../../dom";
 
-import { unifyStatement } from "../utilities/unification";
-import { nodeQuery, nodesQuery } from "../utilities/query";
+import { domAssigned } from "../../dom";
+import { unifyStatement } from "../../utilities/unification";
+import { nodeQuery, nodesQuery } from "../../utilities/query";
 
 const { front, last, match } = arrayUtilities;
 
 const statementNodesQuery = nodesQuery("/subproofAssertion/statement"),
       subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion");
 
-export default class SubproofAssertion {
+export default domAssigned(class SubproofAssertion {
   constructor(string, node, statements) {
     this.string = string;
     this.node = node;
@@ -68,20 +69,7 @@ export default class SubproofAssertion {
 
     const statementsVerified = this.verifyStatements(assignments, stated, context);
 
-    if (statementsVerified) {
-      let verifiedWhenStated = false,
-          verifiedWhenDerived = false;
-
-      if (stated) {
-        verifiedWhenStated = this.verifyWhenStated(context);
-      } else {
-        verifiedWhenDerived = this.verifyWhenDerived(context);
-      }
-
-      if (verifiedWhenStated || verifiedWhenDerived) {
-        verified = true; ///
-      }
-    }
+    verified = statementsVerified;  ///
 
     if (verified) {
       context.debug(`...verified the '${subproofAssertionString}' subproof assertion.`);
@@ -106,46 +94,7 @@ export default class SubproofAssertion {
     return statementsVerified;
   }
 
-  verifyWhenStated(context) {
-    let verifiedWhenStated;
-
-    const subproofAssertionString = this.string;  ///
-
-    context.trace(`Verifying the '${subproofAssertionString}' stated subproof assertion...`);
-
-    verifiedWhenStated = true;
-
-    if (verifiedWhenStated) {
-      context.debug(`...verified the '${subproofAssertionString}' stated subproof assertion.`);
-    }
-
-    return verifiedWhenStated;
-  }
-
-  verifyWhenDerived(context) {
-    let derivedSubproofAssertionVerified;
-
-    const subproofAssertionString = this.string;  ///
-
-    context.trace(`Verifying the '${subproofAssertionString}' derived subproof assertion...`);
-
-    const proofSteps = context.getProofSteps();
-
-    derivedSubproofAssertionVerified = proofSteps.some((proofStep) => {
-      const subproofAssertion = this,
-            subproofAssertionUnified = proofStep.unifySubproofAssertion(subproofAssertion, context);
-
-      if (subproofAssertionUnified) {
-        return true;
-      }
-    });
-
-    if (derivedSubproofAssertionVerified) {
-      context.debug(`...verified the '${subproofAssertionString}' derived subproof assertion.`);
-    }
-
-    return derivedSubproofAssertionVerified;
-  }
+  static name = "SubproofAssertion";
 
   static fromStatementNode(statementNode, context) {
     let subproofAssertion = null;
@@ -153,7 +102,7 @@ export default class SubproofAssertion {
     const subproofAssertionNode = subproofAssertionNodeQuery(statementNode);
 
     if (subproofAssertionNode !== null) {
-      const { Statement } = shim,
+      const { Statement } = dom,
             statementNodes = statementNodesQuery(subproofAssertionNode),
             statement = Statement.fromStatementNode(statementNode, context),
             statementString = statement.getString(),
@@ -175,7 +124,7 @@ export default class SubproofAssertion {
     let subproofAssertion = null;
 
     if (subproofAssertionNode !== null) {
-      const { Statement } = shim,
+      const { Statement } = dom,
             statementNodes = statementNodesQuery(subproofAssertionNode),
             statements = statementNodes.map((statementNode) => {
               const statement = Statement.fromStatementNode(statementNode, context);
@@ -190,7 +139,7 @@ export default class SubproofAssertion {
 
     return subproofAssertion;
   }
-}
+});
 
 function stringFromStatements(statements) {
   const frontStatements = front(statements),
@@ -214,4 +163,4 @@ function statementsStringFromStatements(statements) {
   }, null);
 
   return statementsString
-}
+}

package/src/{assertion → dom/assertion}/type.js

@@ -1,17 +1,18 @@
 "use strict";
 
-import shim from "../shim";
-import VariableAssignment from "../assignment/variable";
+import dom from "../../dom";
+import VariableAssignment from "../../assignment/variable";
 
-import { nodeQuery } from "../utilities/query";
-import { objectType } from "../type";
+import { nodeQuery } from "../../utilities/query";
+import { objectType } from "../../dom/type";
+import { domAssigned } from "../../dom";
 
 const termNodeQuery = nodeQuery("/typeAssertion/term"),
       typeNodeQuery = nodeQuery("/typeAssertion/type"),
       variableNodeQuery = nodeQuery("/term/variable!"),
       typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion");
 
-export default class TypeAssertion {
+export default domAssigned(class TypeAssertion {
   constructor(string, term, type) {
     this.string = string;
     this.term = term;
@@ -111,7 +112,7 @@ export default class TypeAssertion {
 
     if (termVerified) {
       if (assignments !== null) {
-        const { Variable } = shim,
+        const { Variable } = dom,
               termNode = this.term.getNode(),
               variableNode = variableNodeQuery(termNode),
               variable = Variable.fromVariableNodeAndType(variableNode, this.type, context);
@@ -161,13 +162,15 @@ export default class TypeAssertion {
     return verifiedWhenDerived;
   }
 
+  static name = "TypeAssertion";
+
   static fromStatementNode(statementNode, context) {
     let typeAssertion = null;
 
     const typeAssertionNode = typeAssertionNodeQuery(statementNode);
 
     if (typeAssertionNode !== null) {
-      const { Term, Type } = shim,
+      const { Term, Type } = dom,
             termNode = termNodeQuery(typeAssertionNode),
             typeNode = typeNodeQuery(typeAssertionNode),
             term = Term.fromTermNode(termNode, context),
@@ -179,7 +182,7 @@ export default class TypeAssertion {
 
     return typeAssertion;
   }
-}
+});
 
 function stringFromTermAndType(term, type) {
   const termString = term.getString(),

package/src/{axiom.js → dom/axiom.js}

@@ -1,9 +1,10 @@
 "use strict";
 
-import shim from "./shim";
 import TopLevelAssertion from "./topLevelAssertion";
 
-class Axiom extends TopLevelAssertion {
+import { domAssigned } from "../dom";
+
+export default domAssigned(class Axiom extends TopLevelAssertion {
   verify() {
     let verified;
 
@@ -26,13 +27,9 @@ class Axiom extends TopLevelAssertion {
     return verified;
   }
 
+  static name = "TopLevelAssertion";
+
   static fromJSON(json, fileContext) { return TopLevelAssertion.fromJSON(Axiom, json, fileContext); }
 
   static fromAxiomNode(axiomNode, fileContext) { return TopLevelAssertion.fromNode(Axiom, axiomNode, fileContext); }
-}
-
-Object.assign(shim, {
-  Axiom
-});
-
-export default Axiom;
+});