occam-verify-cli 1.0.444 → 1.0.448

package/src/context/temporary.js

@@ -235,11 +235,11 @@ export default class TemporaryContext {
 
   getEquivalences() { return this.context.getEquivalences(); }
 
-  getSteps() { return this.context.getSteps(); }
+  getProofAssertions() { return this.context.getProofAssertions(); }
 
-  getLastStep() { return this.context.getLastStep(); }
+  getLastProofAssertion() { return this.context.getLastProofAssertion(); }
 
-  getStepsOrSubproofs() { return this.context.getStepsOrSubproofs(); }
+  getSubproofOrProofAssertions() { return this.context.getSubproofOrProofAssertions(); }
 
   getFilePath() { return this.context.getFilePath(); }
 
@@ -273,7 +273,7 @@ export default class TemporaryContext {
 
   addJudgement(judgement) { return this.context.addJudgement(judgement); }
 
-  addStepOrSubproof(stepOrSubproof) { this.context.addStepOrSubproof(stepOrSubproof); }
+  addSubproofOrProofAssertion(subproofOrProofAssertion) { this.context.addSubproofOrProofAssertion(subproofOrProofAssertion); }
 
   findProcedureByName(name) { return this.context.findProcedureByName(name); }
 

package/src/element/axiom.js

@@ -110,29 +110,6 @@ export default define(class Axiom extends AxiomLemmaTheoremConjecture {
     return stepUnifies;
   }
 
-  unifyLastStep(lastStep, substitutions, context) {
-    let lastStepUnifies = false;
-
-    const node = this.getNode(),
-          axiomString = this.getString(),
-          lastStepString = lastStep.getString();
-
-    context.trace(`Unifying the '${lastStepString}' last step with the '${axiomString}' axiom...`, node)
-
-    const statement = lastStep.getStatement(),
-          statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, context);
-
-    if (statementUnifiesWithDeduction) {
-      lastStepUnifies = true;
-    }
-
-    if (lastStepUnifies) {
-      context.debug(`...unified the '${lastStepString}' last step with the '${axiomString}' axiom.`, node)
-    }
-
-    return lastStepUnifies;
-  }
-
   unifySubproof(subproof, substitutions, context) {
     let subproofUnifies = false;
 
@@ -147,10 +124,10 @@ export default define(class Axiom extends AxiomLemmaTheoremConjecture {
     if (unconditional) {
       context.trace(`Unable to unify the '${subproofString}' subproof with the '${axiomString}' axiom because the axiom is unconditional.`, node);
     } else {
-      const lastStep = subproof.getLastStep(),
-            lastStepUnifies = this.unifyLastStep(lastStep, substitutions, context);
+      const lastProofAssertion = subproof.getLastProofAssertion(),
+            lastProofAssertionUnifies = this.unifyLastProofAssertion(lastProofAssertion, substitutions, context);
 
-      if (lastStepUnifies) {
+      if (lastProofAssertionUnifies) {
         const suppositions = subproof.getSuppositions(),
               suppositionsUnify = this.unifySuppositions(suppositions, substitutions, context);
 
@@ -225,6 +202,29 @@ export default define(class Axiom extends AxiomLemmaTheoremConjecture {
     return suppositionsUnify;
   }
 
+  unifyLastProofAssertion(lastProofAssertion, substitutions, context) {
+    let lastProofAssertionUnifies = false;
+
+    const node = this.getNode(),
+          axiomString = this.getString(),
+          lastProofAssertionString = lastProofAssertion.getString();
+
+    context.trace(`Unifying the '${lastProofAssertionString}' last proof assertion with the '${axiomString}' axiom...`, node)
+
+    const statement = lastProofAssertion.getStatement(),
+          statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, context);
+
+    if (statementUnifiesWithDeduction) {
+      lastProofAssertionUnifies = true;
+    }
+
+    if (lastProofAssertionUnifies) {
+      context.debug(`...unified the '${lastProofAssertionString}' last proof assertion with the '${axiomString}' axiom.`, node)
+    }
+
+    return lastProofAssertionUnifies;
+  }
+
   unifyAxiomLemmaTheoremOrConjecture(axiomLemmaTheoremOrConjecture, substitutions, context) {
     let axiomLemmaTheoremOrConjectureUnifies = false;
 

package/src/element/axiomLemmaTheoremConjecture.js

@@ -99,21 +99,21 @@ export default class AxiomLemmaTheoremConjecture extends Element {
     const hypothetical = this.isHypothetical();
 
     if (hypothetical) {
-      const steps = context.getSteps(),
-            topLevelAssertionString = this.getString();  ///
+      const proofAssertions = context.getProofAssertions(),
+            axiomLemmaTheoremConjectureString = this.getString();  ///
 
-      context.trace(`Correlating the hypotheses of the '${topLevelAssertionString}' axiom, lemma, theorem or conjecture...`, this.node);
+      context.trace(`Correlating the hypotheses of the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture...`, this.node);
 
-      correlatesToHypotheses = correlate(this.hypotheses, steps, (hypothesis, step) => {
-        const hypothesesEqualToStep = hypothesis.isEqualToStep(step, context);
+      correlatesToHypotheses = correlate(this.hypotheses, proofAssertions, (hypothesis, proofAssertion) => {
+        const hypothesesComparesToStep = hypothesis.compareProofAssertion(proofAssertion, context);
 
-        if (hypothesesEqualToStep) {
+        if (hypothesesComparesToStep) {
           return true;
         }
       });
 
       if (correlatesToHypotheses) {
-        context.debug(`...correlated the hypotheses of the '${topLevelAssertionString}' axiom, lemma, theorem or conjecture.`, this.node);
+        context.debug(`...correlated the hypotheses of the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture.`, this.node);
       }
     } else {
       correlatesToHypotheses = true
@@ -212,7 +212,7 @@ export default class AxiomLemmaTheoremConjecture extends Element {
     return statementUnifiesWithDeduction;
   }
 
-  unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, substitutions, context) {
+  unifyStatementAndStepsOrSubproofs(statement, subproofOrProofAssertions, substitutions, context) {
     let statementAndStepsOrSubproofsUnifies = false;
 
     const correlatesToHypotheses = this.correlateHypotheses(context);
@@ -221,9 +221,9 @@ export default class AxiomLemmaTheoremConjecture extends Element {
       const statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, context);
 
       if (statementUnifiesWithDeduction) {
-        const stepsOrSubproofsUnifyWithSuppositions = this.unifyStepsOrSubproofsWithSuppositions(stepsOrSubproofs, substitutions, context);
+        const subproofOrProofAssertionsUnifyWithSuppositions = this.unifyStepsOrSubproofsWithSuppositions(subproofOrProofAssertions, substitutions, context);
 
-        if (stepsOrSubproofsUnifyWithSuppositions) {
+        if (subproofOrProofAssertionsUnifyWithSuppositions) {
           const substitutionsResolved = substitutions.areResolved();
 
           if (substitutionsResolved) {
@@ -236,43 +236,43 @@ export default class AxiomLemmaTheoremConjecture extends Element {
     return statementAndStepsOrSubproofsUnifies;
   }
 
-  unifyStepsOrSubproofsWithSupposition(stepsOrSubproofs, supposition, substitutions, generalContext, specificContext) {
-    let stepsOrSubproofsUnifiesWithSupposition = false;
+  unifyStepsOrSubproofsWithSupposition(subproofOrProofAssertions, supposition, substitutions, generalContext, specificContext) {
+    let subproofOrProofAssertionsUnifiesWithSupposition = false;
 
     const context = specificContext,  ///
           suppositionUnifiesIndependently = supposition.unifyIndependently(substitutions, context);
 
     if (suppositionUnifiesIndependently) {
-      stepsOrSubproofsUnifiesWithSupposition = true;
+      subproofOrProofAssertionsUnifiesWithSupposition = true;
     } else {
-      const stepOrSubproof = extract(stepsOrSubproofs, (stepOrSubproof) => {
-        const stepOrSubproofUnifies = supposition.unifyStepOrSubproof(stepOrSubproof, substitutions, generalContext, specificContext);
+      const subproofOrProofAssertion = extract(subproofOrProofAssertions, (subproofOrProofAssertion) => {
+        const subproofOrProofAssertionUnifies = supposition.unifySubproofOrProofAssertion(subproofOrProofAssertion, substitutions, generalContext, specificContext);
 
-        if (stepOrSubproofUnifies) {
+        if (subproofOrProofAssertionUnifies) {
           return true;
         }
       }) || null;
 
-      if (stepOrSubproof !== null) {
-        stepsOrSubproofsUnifiesWithSupposition = true;
+      if (subproofOrProofAssertion !== null) {
+        subproofOrProofAssertionsUnifiesWithSupposition = true;
       }
     }
 
-    return stepsOrSubproofsUnifiesWithSupposition;
+    return subproofOrProofAssertionsUnifiesWithSupposition;
   }
 
-  unifyStepsOrSubproofsWithSuppositions(stepsOrSubproofs, substitutions, generalContext, specificContext) {
-    stepsOrSubproofs = reverse(stepsOrSubproofs); ///
+  unifyStepsOrSubproofsWithSuppositions(subproofOrProofAssertions, substitutions, generalContext, specificContext) {
+    subproofOrProofAssertions = reverse(subproofOrProofAssertions); ///
 
-    const stepsOrSubproofsUnifyWithSuppositions = backwardsEvery(this.suppositions, (supposition) => {
-      const stepsOrSubproofsUnifiesWithSupposition = this.unifyStepsOrSubproofsWithSupposition(stepsOrSubproofs, supposition, substitutions, generalContext, specificContext);
+    const subproofOrProofAssertionsUnifyWithSuppositions = backwardsEvery(this.suppositions, (supposition) => {
+      const subproofOrProofAssertionsUnifiesWithSupposition = this.unifyStepsOrSubproofsWithSupposition(subproofOrProofAssertions, supposition, substitutions, generalContext, specificContext);
 
-      if (stepsOrSubproofsUnifiesWithSupposition) {
+      if (subproofOrProofAssertionsUnifiesWithSupposition) {
         return true;
       }
     });
 
-    return stepsOrSubproofsUnifyWithSuppositions;
+    return subproofOrProofAssertionsUnifyWithSuppositions;
   }
 
   toJSON() {
@@ -310,23 +310,4 @@ export default class AxiomLemmaTheoremConjecture extends Element {
 
     return axiomLemmaTheoremConjecture;
   }
-
-  static fromNode(Class, node, context) {
-    const topLevelAssertionNode = node, ///
-          proofNode = topLevelAssertionNode.getProofNode(),
-          labelNodes = topLevelAssertionNode.getLabelNodes(),
-          deductionNode = topLevelAssertionNode.getDeductionNode(),
-          suppositionNodes = topLevelAssertionNode.getSuppositionNodes(),
-          signatureNode = topLevelAssertionNode.getSignatureNode(),
-          proof = proofFromProofNode(proofNode, context),
-          labels = labelsFromLabelNodes(labelNodes, context),
-          deduction = deductionFromDeductionNode(deductionNode, context),
-          suppositions = suppositionsFromSuppositionNodes(suppositionNodes, context),
-          signature = signatureFromSignatureNode(signatureNode, context),
-          hypotheses = [],
-          string = stringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
-          axiomLemmaTheoremConjecture = new Class(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses);
-
-    return axiomLemmaTheoremConjecture;
-  }
 }

package/src/element/derivation.js

@@ -10,35 +10,35 @@ import { define } from "../elements";
 const { last } = arrayUtilities;
 
 export default define(class Derivation extends Element {
-  constructor(context, string, node, stepsOrSubproofs) {
+  constructor(context, string, node, subproofOrProofAssertions) {
     super(context, string, node);
 
-    this.stepsOrSubproofs = stepsOrSubproofs;
+    this.subproofOrProofAssertions = subproofOrProofAssertions;
   }
 
-  getStepsOrSubproofs() {
-    return this.stepsOrSubproofs;
+  getSubproofOrProofAssertions() {
+    return this.subproofOrProofAssertions;
   }
 
-  getLastStep() {
-    const lastStepOrSubproof = last(this.stepsOrSubproofs),
-          lastStep = lastStepOrSubproof;  ///
+  getLastProofAssertion() {
+    const lastSubproofOrProofAssertion = last(this.subproofOrProofAssertions),
+          lastProofAssertion = lastSubproofOrProofAssertion;  ///
 
-    return lastStep;
+    return lastProofAssertion;
   }
 
   verify(substitutions, context) {
     let verifies;
 
-    verifies = this.stepsOrSubproofs.every((stepOrSubproof) => { ///
+    verifies = this.subproofOrProofAssertions.every((subproofOrProofAssertion) => { ///
       const assignments = [],
-            stepOrSubproofVerifies = stepOrSubproof.verify(substitutions, assignments, context);
+            subproofOrProofAssertionVerifies = subproofOrProofAssertion.verify(substitutions, assignments, context);
 
-      if (stepOrSubproofVerifies) {
+      if (subproofOrProofAssertionVerifies) {
         const assignmentsAssigned = assignAssignments(assignments, context);
 
         if (assignmentsAssigned) {
-          context.addStepOrSubproof(stepOrSubproof);
+          context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
           return true;
         }

package/src/element/hypothesis.js

@@ -1,7 +1,6 @@
 "use strict";
 
 import Element from "../element";
-import elements from "../elements";
 import assignAssignments from "../process/assign";
 
 import { define } from "../elements";
@@ -36,11 +35,9 @@ export default define(class Hypothesis extends Element {
         const assignmentsAssigned = assignAssignments(assignments, context);
 
         if (assignmentsAssigned) {
-          const { Step } = elements,
-                step = Step.fromStatement(this.statement, context),
-                stepOrSubproof = step;  ///
+          const subproofOrProofAssertion = this;  ///
 
-          context.addStepOrSubproof(stepOrSubproof);
+          context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
           verifies = true;
         }
@@ -56,26 +53,27 @@ export default define(class Hypothesis extends Element {
     return verifies;
   }
 
-  isEqualToStep(step, context) {
-    let equalToStep = false;
+  compareProofAssertion(proofAssertion, context) {
+    let comparesToProofAssertion = false;
 
-    const stepString = step.getString(),
-          hypothesisString = this.string; ///
+    const node = this.getNode(),
+          hypothesisString = this.getString(), ///
+          proofAssertionString = proofAssertion.getString();
 
-    context.trace(`Is the '${hypothesisString}' hypothesis equal to the '${stepString}' step...`, this.node);
+    context.trace(`Is the '${hypothesisString}' hypothesis equal to the '${proofAssertionString}' proof assertion...`, node);
 
-    const stepStatement = step.getStatement(),
-          statementEqualToStepStatement = this.statement.isEqualTo(stepStatement);
+    const proofAssertionStatement = proofAssertion.getStatement(),
+          statementEqualToStepStatement = this.statement.isEqualTo(proofAssertionStatement);
 
     if (statementEqualToStepStatement) {
-      equalToStep = true;
+      comparesToProofAssertion = true;
     }
 
-    if (equalToStep) {
-      context.trace(`...the '${hypothesisString}' hypothesis is equal to the '${stepString}' step.`, this.node);
+    if (comparesToProofAssertion) {
+      context.trace(`...the '${hypothesisString}' hypothesis is equal to the '${proofAssertionString}' proof assertion.`, node);
     }
 
-    return equalToStep;
+    return comparesToProofAssertion;
   }
 
   toJSON() {

package/src/element/metaLemmaMetatheorem.js

@@ -1,10 +1,8 @@
 "use strict";
 
 import Element from "../element";
-import elements from "../elements";
 import LocalContext from "../context/local";
 
-import { proofFromProofNode, deductionFromDeductionNode, suppositionsFromSuppositionNodes } from "./axiomLemmaTheoremConjecture";
 import { labelFromJSON,
          labelToLabelJSON,
          deductionFromJSON,
@@ -150,72 +148,9 @@ export default class MetaLemmaMetatheorem extends Element {
           substitutions = substitutionsFromJSON(json, context),
           node = null,
           proof = null,
-          string = stringFromLabelASuppositionsAndDeduction(label, suppositions, deduction),
+          string = metaLemmaMetatheoremStringFromLabelASuppositionsAndDeduction(label, suppositions, deduction),
           metaLemmaMetatheorem = new Class(context, string, node, label, suppositions, deduction, proof, substitutions);
 
     return metaLemmaMetatheorem;
   }
-
-  static fromNode(Class, node, context) {
-    const { Substitutions } = elements,
-          topLevelAssertionNode = node, ///
-          proofNode = topLevelAssertionNode.getProofNode(),
-          labelNode = topLevelAssertionNode.getLabelNode(),
-          deductionNode = topLevelAssertionNode.getDeductionNode(),
-          suppositionNodes = topLevelAssertionNode.getSuppositionNodes(),
-          proof = proofFromProofNode(proofNode, context),
-          label = labelFromLabelNode(labelNode, context),
-          deduction = deductionFromDeductionNode(deductionNode, context),
-          suppositions = suppositionsFromSuppositionNodes(suppositionNodes, context),
-          substitutions = Substitutions.fromNothing(),
-          string = stringFromLabelASuppositionsAndDeduction(label, suppositions, deduction),
-          metaLemmaMetatheorem = new Class(context, string, node, label, suppositions, deduction, proof, substitutions);
-
-    return metaLemmaMetatheorem;
-  }
-}
-
-function labelFromLabelNode(labelNode, context) {
-  let label = null;
-
-  const { Label } = elements;
-
-  if (labelNode !== null) {
-    label = Label.fromLabelNode(labelNode, context);
-  }
-
-  return label;
-}
-
-function labelStringFromLabel(label) {
-  const labelsString = (label !== null) ?
-                          label.getString() :
-                            null;
-
-  return labelsString;
-}
-
-function suppositionsStringFromSuppositions(suppositions) {
-  const suppositionsString = suppositions.reduce((suppositionsString, supposition) => {
-    const suppositionString = supposition.getString();
-
-    suppositionsString = (suppositionsString !== null) ?
-                          `${suppositionsString}, ${suppositionString}` :
-                            suppositionString;  ///
-
-    return suppositionsString;
-  }, null);
-
-  return suppositionsString;
-}
-
-function stringFromLabelASuppositionsAndDeduction(label, suppositions, deduction) {
-  const suppositionsString = suppositionsStringFromSuppositions(suppositions),
-        deductionString = deduction.getString(),
-        labelString = labelStringFromLabel(label),
-        string = (labelString === null) ?
-                    deductionString : ///
-                     `${labelString} :: [${suppositionsString}] ... ${deductionString}`;
-
-  return string;
 }

package/src/element/metavariable.js

@@ -46,7 +46,8 @@ export default define(class Metavariable extends Element {
   }
 
   compareMetavariableName(metavariableName) {
-    const comparesToMetavariableName = (metavariableName === this.name);
+    const nameMetavariableName = (this.name === metavariableName),
+          comparesToMetavariableName = nameMetavariableName;  ///
 
     return comparesToMetavariableName;
   }
@@ -54,7 +55,7 @@ export default define(class Metavariable extends Element {
   isMetaTypeEqualTo(metaType) { return this.metaType.isEqualTo(metaType); }
 
   validate(context) {
-    let validates;
+    let validates = false;
 
     const metavariableString = this.getString(); ///
 
@@ -63,7 +64,9 @@ export default define(class Metavariable extends Element {
     const metavariable = this, ///
           metavariablePresent = context.isMetavariablePresent(metavariable);
 
-    validates = metavariablePresent; ///
+    if (metavariablePresent) {
+      validates = true;
+    }
 
     if (validates) {
       context.debug(`...va;idated the '${metavariableString}' metavariable.`);
@@ -87,7 +90,9 @@ export default define(class Metavariable extends Element {
     if (metavariable !== null) {
       const metavariableMetaTypeEqualToMetaType = metavariable.isMetaTypeEqualTo(metaType);
 
-      validatesGivenMetaType = metavariableMetaTypeEqualToMetaType;  ///
+      if (metavariableMetaTypeEqualToMetaType) {
+        validatesGivenMetaType = true;
+      }
     }
 
     if (validatesGivenMetaType) {