occam-verify-cli 1.0.230 → 1.0.234

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

@@ -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,  ///

package/src/dom/reference.js

@@ -1,7 +1,6 @@
 "use strict";
 
 import dom from "../dom";
-import LocalContext from "../context/local";
 import Substitutions from "../substitutions";
 
 import { domAssigned } from "../dom";
@@ -90,9 +89,11 @@ export default domAssigned(class Reference {
 
     context.trace(`Unifying the '${labelString}' label with the '${referenceString}' reference...`);
 
-    const fileContext = label.getFileContext(),
-          generalContext = context, ///
-          specificContext = fileContext,  ///
+    const generalContext = context; ///
+
+    context = label.getContext();
+
+    const specificContext = context,  ///
           labelMetavariable = label.getMetavariable(),
           generalMetavariable = this.metavariable,  ///
           specificMetavariable = labelMetavariable, ///
@@ -116,10 +117,9 @@ export default domAssigned(class Reference {
 
     context.trace(`Unifying the '${metavariableString}' metavariable with the '${referenceString}' reference...`);
 
-    const fileContext = context.getFileContext(),
-          substitutions = Substitutions.fromNothing(),
+    const substitutions = Substitutions.fromNothing(),
           generalContext = context, ///
-          specificContext = fileContext,  ///
+          specificContext = context,  ///
           generalMetavariable = this.metavariable,  ///
           specificMetavariable = metavariable, ///
           metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, substitutions, generalContext, specificContext);
@@ -167,78 +167,74 @@ export default domAssigned(class Reference {
 
   static name = "Reference";
 
-  static fromJSON(json, fileContext) {
-    const metavariable = metavariableFromJSON(json, fileContext),
+  static fromJSON(json, context) {
+    const metavariable = metavariableFromJSON(json, context),
           reference = new Reference(metavariable);
 
     return reference;
   }
 
-  static fromStepNode(stepNode, fileContext) {
+  static fromStepNode(stepNode, context) {
     let reference = null;
 
     const referenceNode = stepNode.getReferenceNode();
 
     if (referenceNode !== null) {
-      reference = referenceFromReferenceNode(referenceNode, fileContext);
+      reference = referenceFromReferenceNode(referenceNode, context);
     }
 
     return reference;
   }
 
-  static fromReferenceNode(referenceNode, fileContext) {
-    const reference = referenceFromReferenceNode(referenceNode, fileContext);
+  static fromReferenceNode(referenceNode, context) {
+    const reference = referenceFromReferenceNode(referenceNode, context);
 
     return reference;
   }
 
-  static fromDeclarationNode(declarationNode, fileContext) {
+  static fromDeclarationNode(declarationNode, context) {
     const metavariableNode = declarationNode.getMetavariableNode(),
-          reference = referenceFromMetavariableNode(metavariableNode, fileContext);
+          reference = referenceFromMetavariableNode(metavariableNode, context);
 
     return reference;
   }
 
-  static fromMetavariableNode(metavariableNode, fileContext) {
-    const reference = referenceFromMetavariableNode(metavariableNode, fileContext);
+  static fromMetavariableNode(metavariableNode, context) {
+    const reference = referenceFromMetavariableNode(metavariableNode, context);
 
     return reference;
   }
 
-  static fromProcedureCallNode(procedureCallNode, fileContext) {
+  static fromProcedureCallNode(procedureCallNode, context) {
     let reference = null;
 
     const referenceNode = procedureCallNode.getReferenceNode();
 
     if (referenceNode !== null) {
-      reference = referenceFromReferenceNode(referenceNode, fileContext);
+      reference = referenceFromReferenceNode(referenceNode, context);
     }
 
     return reference;
   }
 
-  static fromSatisfiesAssertionNode(satisfiesAssertionNode, fileContext) {
+  static fromSatisfiesAssertionNode(satisfiesAssertionNode, context) {
     const metavariableNode = satisfiesAssertionNode.getMetavariableNode(),
-          reference = referenceFromMetavariableNode(metavariableNode, fileContext);
+          reference = referenceFromMetavariableNode(metavariableNode, context);
 
     return reference;
   }
 });
 
-function referenceFromReferenceNode(referenceNode, fileContext) {
+function referenceFromReferenceNode(referenceNode, context) {
   const { Reference, Metavariable } = dom,
-        localContext = LocalContext.fromFileContext(fileContext),
-        context = localContext, ///
         metavariable = Metavariable.fromReferenceNode(referenceNode, context),
         reference = new Reference(metavariable);
 
   return reference;
 }
 
-function referenceFromMetavariableNode(metavariableNode, fileContext) {
+function referenceFromMetavariableNode(metavariableNode, context) {
   const { Reference, Metavariable } = dom,
-        localContext = LocalContext.fromFileContext(fileContext),
-        context = localContext, ///
         metavariable = Metavariable.fromMetavariableNode(metavariableNode, context),
         reference = new Reference(metavariable);
 

package/src/dom/rule.js

@@ -18,8 +18,8 @@ import { labelsFromJSON,
 const { reverse, extract, backwardsEvery } = arrayUtilities;
 
 export default domAssigned(class Rule {
-  constructor(fileContext, string, labels, premises, conclusion, proof) {
-    this.fileContext = fileContext;
+  constructor(context, string, labels, premises, conclusion, proof) {
+    this.context = context;
     this.string = string;
     this.labels = labels;
     this.premises = premises;
@@ -27,8 +27,8 @@ export default domAssigned(class Rule {
     this.proof = proof;
   }
 
-  getFileContext() {
-    return this.fileContext;
+  getContext() {
+    return this.context;
   }
 
   getString() {
@@ -66,8 +66,7 @@ export default domAssigned(class Rule {
   unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, context) {
     let statementAndStepsOrSubproofsUnify = false;
 
-    const localContext = LocalContext.fromFileContext(this.fileContext),
-          generalContext = localContext, ///
+    const generalContext = this.context, ///
           specificContext = context; ///
 
     const substitutions = Substitutions.fromNothing(),
@@ -148,12 +147,13 @@ export default domAssigned(class Rule {
 
     const ruleString = this.string; ///
 
-    this.fileContext.trace(`Verifying the '${ruleString}' rule...`);
+    this.context.trace(`Verifying the '${ruleString}' rule...`);
 
     const labelsVerify = this.verifyLabels();
 
     if (labelsVerify) {
-      const context = LocalContext.fromFileContext(this.fileContext),
+      const localContext = LocalContext.fromContext(this.context),
+            context = localContext, ///
             premisesVerify = this.verifyPremises(context);
 
       if (premisesVerify) {
@@ -165,7 +165,7 @@ export default domAssigned(class Rule {
           if (proofVerifies) {
             const rule = this;  ///
 
-            this.fileContext.addRule(rule);
+            this.context.addRule(rule);
 
             verifies = true;
           }
@@ -174,7 +174,7 @@ export default domAssigned(class Rule {
     }
 
     if (verifies) {
-      this.fileContext.debug(`...verified the '${ruleString}' rule.`);
+      this.context.debug(`...verified the '${ruleString}' rule.`);
     }
 
     return verifies;
@@ -249,45 +249,45 @@ export default domAssigned(class Rule {
 
   static name = "Rule";
 
-  static fromJSON(json, fileContext) {
+  static fromJSON(json, context) {
     let rule;
 
     const proof = null,
-          labels = labelsFromJSON(json, fileContext),
-          premises = premisesFromJSON(json, fileContext),
-          conclusion = conclusionFromJSON(json, fileContext),
+          labels = labelsFromJSON(json, context),
+          premises = premisesFromJSON(json, context),
+          conclusion = conclusionFromJSON(json, context),
           string = stringFromLabelsPremisesAndConclusion(labels, premises, conclusion);
 
-    rule = new Rule(fileContext, string, labels, premises, conclusion, proof);
+    rule = new Rule(context, string, labels, premises, conclusion, proof);
 
     return rule;
   }
 
-  static fromRuleNode(ruleNode, fileContext) {
-    const proof = proofFromRuleNode(ruleNode, fileContext),
-          labels = labelsFromRuleNode(ruleNode, fileContext),
-          premises = premisesFromRuleNode(ruleNode, fileContext),
-          conclusion = conclusionFromRuleNode(ruleNode, fileContext),
+  static fromRuleNode(ruleNode, context) {
+    const proof = proofFromRuleNode(ruleNode, context),
+          labels = labelsFromRuleNode(ruleNode, context),
+          premises = premisesFromRuleNode(ruleNode, context),
+          conclusion = conclusionFromRuleNode(ruleNode, context),
           string = stringFromLabelsPremisesAndConclusion(labels, premises, conclusion),
-          rule = new Rule(fileContext, string, labels, premises, conclusion, proof);
+          rule = new Rule(context, string, labels, premises, conclusion, proof);
 
     return rule;
   }
 });
 
-function proofFromRuleNode(ruleNode, fileContext) {
+function proofFromRuleNode(ruleNode, context) {
   const { Proof } = dom,
         proofNode = ruleNode.getProofNode(),
-        proof = Proof.fromProofNode(proofNode, fileContext);
+        proof = Proof.fromProofNode(proofNode, context);
 
   return proof;
 }
 
-function labelsFromRuleNode(ruleNode, fileContext) {
+function labelsFromRuleNode(ruleNode, context) {
   const { Label } = dom,
         labelNodes = ruleNode.getLabelNodes(),
         labels = labelNodes.map((labelNode) => {
-          const label = Label.fromLabelNode(labelNode, fileContext);
+          const label = Label.fromLabelNode(labelNode, context);
 
           return label;
         });
@@ -295,11 +295,11 @@ function labelsFromRuleNode(ruleNode, fileContext) {
   return labels;
 }
 
-function premisesFromRuleNode(ruleNode, fileContext) {
+function premisesFromRuleNode(ruleNode, context) {
   const { Premise } = dom,
         premiseNodes = ruleNode.getPremiseNodes(),
         premises = premiseNodes.map((premiseNode) => {
-          const premise = Premise.fromPremiseNode(premiseNode, fileContext);
+          const premise = Premise.fromPremiseNode(premiseNode, context);
 
           return premise;
         });
@@ -307,10 +307,10 @@ function premisesFromRuleNode(ruleNode, fileContext) {
   return premises;
 }
 
-function conclusionFromRuleNode(ruleNode, fileContext) {
+function conclusionFromRuleNode(ruleNode, context) {
   const { Conclusion } = dom,
         conclusionNode = ruleNode.getConclusionNode(),
-        conclusion = Conclusion.fromConclusionNode(conclusionNode, fileContext);
+        conclusion = Conclusion.fromConclusionNode(conclusionNode, context);
 
   return conclusion;
 }

package/src/dom/section.js

@@ -0,0 +1,197 @@
+"use strict";
+
+import dom from "../dom";
+import LocalContext from "../context/local";
+
+import { domAssigned } from "../dom";
+
+export default domAssigned(class Section {
+  constructor(context, string, hypotheses, axiom, lemma, theorem, conjecture) {
+    this.context = context;
+    this.string = string;
+    this.hypotheses = hypotheses;
+    this.axiom = axiom;
+    this.lemma = lemma;
+    this.theorem = theorem;
+    this.conjecture = conjecture;
+  }
+
+  getContext() {
+    return this.context;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getHypotheses() {
+    return this.hypotheses;
+  }
+
+  getAxiom() {
+    return this.axiom;
+  }
+
+  getLemma() {
+    return this.lemma;
+  }
+
+  getTheorem() {
+    return this.theorem;
+  }
+
+  getConjecture() {
+    return this.conjecture;
+  }
+
+  verify() {
+    let verifies = false;
+
+    const sectionString = this.string;  ///
+
+    this.context.trace(`Verifying the '${sectionString}' section...`);
+
+    const hypothesesVerify = this.verifyHypotheses();
+
+    if (hypothesesVerify) {
+      const axiomLemmaTheoremOrConjecture = (this.axiom || this.lemma || this.theorem || this.conjecture),
+            axiomLemmaTheoremOrConjectureVerifies = axiomLemmaTheoremOrConjecture.verify(this.context);
+
+      if (axiomLemmaTheoremOrConjectureVerifies) {
+        axiomLemmaTheoremOrConjecture.setHypotheses(this.hypotheses);
+
+        verifies = true;
+      }
+    }
+
+    if (verifies) {
+      this.context.debug(`...verified the '${sectionString}' section.`);
+    }
+
+    return verifies;
+  }
+
+  verifyHypotheses() {
+    const hypothesesVerify = this.hypotheses.every((hypothesis) => {
+      const hypothesisVerifies = hypothesis.verify(this.context);
+
+      if (hypothesisVerifies) {
+        return true;
+      }
+    });
+
+    return hypothesesVerify;
+  }
+
+  static name = "Section";
+
+  static fromSectionNode(sectionNode, context) {
+    const localContext = LocalContext.fromContext(context);
+
+    context = localContext; ///
+
+    const hypothesisNodes = sectionNode.getHypothesisNodes(),
+          hypotheses = hypothesesFromHypothesisNodes(hypothesisNodes, context),
+          axiom = axiomFroSectionNode(sectionNode, context),
+          lemma = lemmaFroSectionNode(sectionNode, context),
+          theorem = theoremFroSectionNode(sectionNode, context),
+          conjecture = conjectureFroSectionNode(sectionNode, context),
+          string = stringFromHypothesesAxiomLemmaTheoremAndConjecture(hypotheses, axiom, lemma, theorem, conjecture, context),
+          section = new Section(context, string, hypotheses, axiom, lemma, theorem, conjecture);
+
+    return section;
+  }
+});
+
+function axiomFroSectionNode(sectionNode, context) {
+  let axiom = null;
+
+  const axiomNode = sectionNode.getAxiomNode();
+
+  if (axiomNode !== null) {
+    const { Axiom } = dom;
+
+    axiom = Axiom.fromAxiomNode(axiomNode, context);
+  }
+
+  return axiom;
+}
+
+function lemmaFroSectionNode(sectionNode, context) {
+  let lemma = null;
+
+  const lemmaNode = sectionNode.getLemmaNode();
+
+  if (lemmaNode !== null) {
+    const { Lemma } = dom;
+
+    lemma = Lemma.fromLemmaNode(lemmaNode, context);
+  }
+
+  return lemma;
+}
+
+function theoremFroSectionNode(sectionNode, context) {
+  let theorem = null;
+
+  const theoremNode = sectionNode.getTheoremNode();
+
+  if (theoremNode !== null) {
+    const { Theorem } = dom;
+
+    theorem = Theorem.fromTheoremNode(theoremNode, context);
+  }
+
+  return theorem;
+}
+
+function conjectureFroSectionNode(sectionNode, context) {
+  let conjecture = null;
+
+  const conjectureNode = sectionNode.getConjectureNode();
+
+  if (conjectureNode !== null) {
+    const { Conjecture } = dom;
+
+    conjecture = Conjecture.fromConjectureNode(conjectureNode, context);
+  }
+
+  return conjecture;
+}
+
+function hypothesesFromHypothesisNodes(hypothesisNodes, context) {
+  const hypotheses = hypothesisNodes.map((hypothesisNode) => {
+    const { Hypothesis } = dom,
+          hypothesis = Hypothesis.fromHypothesisNode(hypothesisNode, context);
+
+    return hypothesis;
+  });
+
+  return hypotheses;
+}
+
+function hypothesesStringFromHypotheses(hypotheses, context) {
+  const hypothesesString = hypotheses.reduce((hypothesesString, hypothesis) => {
+    const hypothesisString = hypothesis.getString();
+
+    hypothesesString = (hypothesesString !== null) ?
+                         `${hypothesesString}, ${hypothesisString}` :
+                           hypothesisString;  ///
+
+    return hypothesesString;
+  }, null);
+
+  return hypothesesString;
+}
+
+function stringFromHypothesesAxiomLemmaTheoremAndConjecture(hypotheses, axiom, lemma, theorem, conjecture, context) {
+  const axiomLemmaTheoremOrConjecture = (axiom || lemma || theorem || conjecture),
+        axiomLemmaTheoremOrConjectureString = axiomLemmaTheoremOrConjecture.getString(),
+        hypothesesString = hypothesesStringFromHypotheses(hypotheses, context),
+        string = (axiomLemmaTheoremOrConjectureString !== null) ?
+                   `[${hypothesesString}]::: ${axiomLemmaTheoremOrConjectureString}` :
+                     `[${hypothesesString}]::: `;
+
+
+  return string;
+}

package/src/dom/signature.js

@@ -63,7 +63,6 @@ export default domAssigned(class Signature {
               let context,
                   term;
 
-
               context = generalContext; ///
 
               term = termB; ///
@@ -157,17 +156,17 @@ export default domAssigned(class Signature {
 
   static name = "Signature";
 
-  static fromJSON(json, fileContext) {
-    const terms = termsFromJSON(json, fileContext),
+  static fromJSON(json, context) {
+    const terms = termsFromJSON(json, context),
           string = stringFromTerms(terms),
           signature = new Signature(string, terms);
 
     return signature;
   }
 
-  static fromSignatureNode(signatureNode, fileContext) {
+  static fromSignatureNode(signatureNode, context) {
     const termNodes = signatureNode.getTermNodes(),
-          terms = termsFromTermNodes(termNodes, fileContext),
+          terms = termsFromTermNodes(termNodes, context),
           string = stringFromTerms(terms),
           signature = new Signature(string, terms);