occam-verify-cli 1.0.233 → 1.0.234

package/src/dom/axiom.js

@@ -234,34 +234,38 @@ 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 '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture with the '${axiomString}' axiom...`);
+    context.trace(`Unifying the '${axiomLemmaTheoremOrConjectureString}' axiom, lemma, theorem or conjecture with the '${axiomString}' axiom...`);
 
-    const deduction = axiomLemmaTheoremConjecture.getDeduction(),  ///
-          specificContext = context;  ///
+    const hypothesesCorrelate = axiomLemmaTheoremOrConjecture.correlateHypotheses(context);
 
-    context = this.getContext();
+    if (hypothesesCorrelate) {
+      const deduction = axiomLemmaTheoremOrConjecture.getDeduction(),  ///
+            specificContext = context;  ///
 
-    const generalContext = 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";

package/src/dom/declaration.js

@@ -219,9 +219,9 @@ export default domAssigned(class Declaration {
 
     const generalContext = context; ///
 
-    context = metaLemmaMetatheorem.getContext();
+    context = metaLemmaMetatheorem.getContext();  ///
 
-    const specificContext = context,
+    const specificContext = context,  ///
           labelSubstitutions = Substitutions.fromNothing(),
           label = metaLemmaMetatheorem.getLabel(),
           substitutions = labelSubstitutions, ///

package/src/dom/hypothesis.js

@@ -59,137 +59,26 @@ export default domAssigned(class Hypothesis {
     return verifies;
   }
 
-  unifyHypothesis(hypothesis, substitutions, generalContext, specificContext) {
-    let hypothesisUnifies;
+  isEqualToStep(step, context) {
+    let equalToStep = false;
 
-    const context = specificContext,  ///
-          specificHypothesis = hypothesis,  ///
-          generalHypothesisString = this.string, ///
-          specificHypothesisString = specificHypothesis.getString();
+    const stepString = step.getString(),
+          hypothesisString = this.string; ///
 
-    context.trace(`Unifying the '${specificHypothesisString}' hypothesis with the '${generalHypothesisString}' hypothesis...`);
+    context.trace(`Is the '${hypothesisString}' hypothesis equal to the '${stepString}' step...`);
 
-    const statement = specificHypothesis.getStatement(),
-          statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+    const stepStatement = step.getStatement(),
+          statementEqualToStepStatement = this.statement.isEqualTo(stepStatement);
 
-    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 (statementEqualToStepStatement) {
+      equalToStep = true;
     }
 
-    if (statementUnifies) {
-      specificContext.debug(`...unified the '${statementString}' statement with the '${hypothesisString}' hypothesis.`);
+    if (equalToStep) {
+      context.trace(`...the '${hypothesisString}' hypothesis is equal to the '${stepString}' step.`);
     }
 
-    return statementUnifies;
+    return equalToStep;
   }
 
   toJSON() {

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.`);

package/src/dom/rule.js

@@ -3,6 +3,7 @@
 import { arrayUtilities } from "necessary";
 
 import dom from "../dom";
+import LocalContext from "../context/local";
 import Substitutions from "../substitutions";
 
 import { domAssigned } from "../dom";
@@ -13,7 +14,6 @@ import { labelsFromJSON,
          labelsToLabelsJSON,
          premisesToPremisesJSON,
          conclusionToConclusionJSON } from "../utilities/json";
-import LocalContext from "../context/local";
 
 const { reverse, extract, backwardsEvery } = arrayUtilities;
 

package/src/dom/section.js

@@ -1,18 +1,19 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
-
 import dom from "../dom";
+import LocalContext from "../context/local";
 
 import { domAssigned } from "../dom";
 
-const { first } = arrayUtilities;
-
 export default domAssigned(class Section {
-  constructor(context, string, hypotheses) {
+  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() {
@@ -27,28 +28,137 @@ export default domAssigned(class Section {
     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;  ///
 
-    debugger
+    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),
-          string = stringFromHypotheses(hypotheses, context),
-          section = new Section(context, string, hypotheses);
+          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,
@@ -60,11 +170,28 @@ function hypothesesFromHypothesisNodes(hypothesisNodes, context) {
   return hypotheses;
 }
 
-function stringFromHypotheses(hypotheses, context) {
-  const firstHypothesis = first(hypotheses),
-        hypothesis = firstHypothesis, ///
-        hypothesisString = hypothesis.getString(),
-        string = `'${hypothesisString}'...`;
+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; ///

package/src/dom/topLevelAssertion.js

@@ -10,15 +10,17 @@ import { labelsFromJSON,
          deductionFromJSON,
          signatureFromJSON,
          labelsToLabelsJSON,
+         hypothesesFromJSON,
          suppositionsFromJSON,
          deductionToDeductionJSON,
          signatureToSignatureJSON,
+         hypothesesToHypothesesJSON,
          suppositionsToSuppositionsJSON } from "../utilities/json";
 
-const { reverse, extract, backwardsEvery } = arrayUtilities;
+const { extract, reverse, correlate, backwardsEvery } = arrayUtilities;
 
 export default class TopLevelAssertion {
-  constructor(context, string, labels, suppositions, deduction, proof, signature) {
+  constructor(context, string, labels, suppositions, deduction, proof, signature, hypotheses) {
     this.context = context;
     this.string = string;
     this.labels = labels;
@@ -26,6 +28,7 @@ export default class TopLevelAssertion {
     this.deduction = deduction;
     this.proof = proof;
     this.signature = signature;
+    this.hypotheses = hypotheses;
   }
 
   getContext() {
@@ -56,8 +59,35 @@ export default class TopLevelAssertion {
     return this.signature;
   }
 
+  getHypotheses() {
+    return this.hypotheses;
+  }
+
+  setContext(context) { this.context = context; }
+
+  setString(string) { this.string = string; }
+
+  setLabels(labels) { this.labels = labels; }
+
+  setSuppositions(suppositions) { this.suppositions = suppositions; }
+
+  setDeduction(deduction) { this.deduction = deduction; }
+
+  setProof(proof) { this.proof = proof; }
+
+  setSignature(signature) { this.signature = signature; }
+
+  setHypotheses(hypotheses) { this.hypotheses = hypotheses; }
+
   getStatement() { return this.deduction.getStatement(); }
 
+  isHypothetical() {
+    const hypothesesLength = this.hypotheses.length,
+          hypothetical = (hypothesesLength > 0);
+
+    return hypothetical;
+  }
+
   isUnconditional() {
     const suppositionsLength = this.suppositions.length,
           unconditional = (suppositionsLength === 0);
@@ -160,6 +190,36 @@ export default class TopLevelAssertion {
     return proofVerifies;
   }
 
+  correlateHypotheses(context) {
+    let hypothesesCorrelate;
+
+    const hypothetical = this.isHypothetical();
+
+    if (hypothetical) {
+      const steps = context.getSteps(),
+            topLevelAssertionString = this.string;  ///
+
+      context.trace(`Correlating the hypotheses of the '${topLevelAssertionString}' axiom, lemma, theorem or conjecture...`);
+
+      hypothesesCorrelate = correlate(this.hypotheses, steps, (hypothesis, step) => {
+        const hypothesesEqualToStep = hypothesis.isEqualToStep(step, context);
+
+        if (hypothesesEqualToStep) {
+          return true;
+        }
+      });
+
+      if (hypothesesCorrelate) {
+        context.debug(`...correlated the hypotheses of the '${topLevelAssertionString}' axiom, lemma, theorem or conjecture.`);
+      }
+    } else {
+      hypothesesCorrelate = true
+    }
+
+
+    return hypothesesCorrelate;
+  }
+
   unifyStatementWithDeduction(statement, substitutions, generalContext, specificContext) {
     let statementUnifiesWithDeduction = false;
 
@@ -175,20 +235,29 @@ export default class TopLevelAssertion {
   unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, substitutions, context) {
     let statementAndStepsOrSubproofsUnify = false;
 
-    const generalContext = this.context, ///
-          specificContext = context, ///
-          statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, generalContext, specificContext);
+    const hypothetical = this.isHypothetical();
 
-    if (statementUnifiesWithDeduction) {
-      const stepsOrSubproofsUnifyWithSuppositions = this.unifyStepsOrSubproofsWithSuppositions(stepsOrSubproofs, substitutions, generalContext, specificContext);
+    if (!hypothetical) {
+      const generalContext = this.context, ///
+            specificContext = context, ///
+            statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, generalContext, specificContext);
 
-      if (stepsOrSubproofsUnifyWithSuppositions) {
-        const substitutionsResolved = substitutions.areResolved();
+      if (statementUnifiesWithDeduction) {
+        const stepsOrSubproofsUnifyWithSuppositions = this.unifyStepsOrSubproofsWithSuppositions(stepsOrSubproofs, substitutions, generalContext, specificContext);
 
-        if (substitutionsResolved) {
-          statementAndStepsOrSubproofsUnify = true;
+        if (stepsOrSubproofsUnifyWithSuppositions) {
+          const substitutionsResolved = substitutions.areResolved();
+
+          if (substitutionsResolved) {
+            statementAndStepsOrSubproofsUnify = true;
+          }
         }
       }
+    } else {
+      const statementString = statement.getString(),
+            topLevelAssertionString = this.string;  ///
+
+      context.trace(`Cannot unify the '${topLevelAssertionString}' axiom, lemma, theorem or conjecture with the '${statementString}' and steps or subproofs because it is hypothetical.`);
     }
 
     return statementAndStepsOrSubproofsUnify;
@@ -238,15 +307,18 @@ export default class TopLevelAssertion {
           deductionJSON = deductionToDeductionJSON(this.deduction),
           suppositionsJSON = suppositionsToSuppositionsJSON(this.suppositions),
           signatureJSON = signatureToSignatureJSON(this.signature),
+          hypothesesJSON = hypothesesToHypothesesJSON(this.signature),
           labels = labelsJSON,  ///
           deduction = deductionJSON,  ///
           suppositions = suppositionsJSON,  ///
-          signature = signatureJSON,
+          signature = signatureJSON,  ///
+          hypotheses = hypothesesJSON,  ///
           json = {
             labels,
             deduction,
             suppositions,
             signature,
+            hypotheses
           };
 
     return json;
@@ -257,9 +329,10 @@ export default class TopLevelAssertion {
           deduction = deductionFromJSON(json, context),
           suppositions = suppositionsFromJSON(json, context),
           signature = signatureFromJSON(json, context),
+          hypotheses = hypothesesFromJSON(json, context),
           proof = null,
           string = stringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
-          topLevelAssertion = new Class(context, string, labels, suppositions, deduction, proof, signature);
+          topLevelAssertion = new Class(context, string, labels, suppositions, deduction, proof, signature, hypotheses);
 
     return topLevelAssertion;
   }
@@ -276,8 +349,9 @@ export default class TopLevelAssertion {
           deduction = deductionFromDeductionNode(deductionNode, context),
           suppositions = suppositionsFromSuppositionNodes(suppositionNodes, context),
           signature = signatureFromSignatureNode(signatureNode, context),
+          hypotheses = [],
           string = stringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
-          topLevelAssertion = new Class(context, string, labels, suppositions, deduction, proof, signature);
+          topLevelAssertion = new Class(context, string, labels, suppositions, deduction, proof, signature, hypotheses);
 
     return topLevelAssertion;
   }

package/src/dom/topLevelMetaAssertion.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import dom from "../dom";
+import LocalContext from "../context/local";
 import Substitutions from "../substitutions";
 
 import { proofFromProofNode, deductionFromDeductionNode, suppositionsFromSuppositionNodes } from "./topLevelAssertion";
@@ -12,7 +13,6 @@ import { labelFromJSON,
          deductionToDeductionJSON,
          suppositionsToSuppositionsJSON,
          substitutionsToSubstitutionsJSON } from "../utilities/json";
-import LocalContext from "../context/local";
 
 export default class TopLevelMetaAssertion {
   constructor(context, string, label, suppositions, deduction, proof, substitutions) {