occam-verify-cli 1.0.444 → 1.0.457

package/src/element/subDerivation.js

@@ -10,35 +10,35 @@ import { define } from "../elements";
 const { last } = arrayUtilities;
 
 export default define(class SubDerivation 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 = [],
-            stepOrSubproofVarifies = stepOrSubproof.verify(substitutions, assignments, context);
+            subproofOrProofAssertionVarifies = subproofOrProofAssertion.verify(substitutions, assignments, context);
 
-      if (stepOrSubproofVarifies) {
+      if (subproofOrProofAssertionVarifies) {
         const assignmentsAssigned = assignAssignments(assignments, context);
 
         if (assignmentsAssigned) {
-          context.addStepOrSubproof(stepOrSubproof);
+          context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
           return true;
         }

package/src/element/subproof.js

@@ -2,7 +2,7 @@
 
 import Element from "../element";
 import elements from "../elements";
-import LocalContext from "../context/local";
+import ScopedContext from "../context/scoped";
 
 import { define } from "../elements";
 
@@ -22,36 +22,36 @@ export default define(class Subproof extends Element {
     return this.subDerivation;
   }
 
-  getLastStep() { return this.subDerivation.getLastStep(); }
+  getLastProofAssertion() { return this.subDerivation.getLastProofAssertion(); }
 
   getStatements() {
-    const lastStep = this.getLastStep(),
+    const lastProofAssertion = this.getLastProofAssertion(),
           suppositionStatements = this.suppositions.map((supposition) => {
             const suppositionStatement = supposition.getStatement();
 
             return suppositionStatement;
           }),
-          lastStepStatement = lastStep.getStatement(),
+          lastProofAssertionStatement = lastProofAssertion.getStatement(),
           statements = [
             ...suppositionStatements,
-            lastStepStatement
+            lastProofAssertionStatement
           ];
 
     return statements;
   }
 
-  isStep() {
-    const sStep = false;
+  isProofAssertion() {
+    const proofAssertion = false;
 
-    return sStep;
+    return proofAssertion;
   }
 
   verify(substitutions, assignments, context) {
     let verifies = false;
 
-    const localContext = LocalContext.fromNothing(context);  ///
+    const scopedContext = ScopedContext.fromNothing(context);  ///
 
-    context = localContext; ///
+    context = scopedContext; ///
 
     const suppositionsVerify = this.suppositions.every((supposition) => {
       const suppositionVerifies = supposition.verify(context);

package/src/element/substitution/frame.js

@@ -3,7 +3,9 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
+import { withinFragment } from "../../utilities/fragment";
 import { instantiateFrameSubstitution } from "../../process/instantiate";
+import { frameSubstitutionStringFromFrameAndMetavariable } from "../../utilities/string";
 import { frameSubstitutionFromFrameSubstitutionNode, frameSubstitutionFromStatementNode } from "../../utilities/element";
 
 export default define(class FrameSubstitution extends Substitution {
@@ -86,18 +88,13 @@ export default define(class FrameSubstitution extends Substitution {
   }
 
   static fromFrameAndMetavariable(frame, metavariable, context) {
-    const string = stringFromFrameAndMetavariable(frame, metavariable),
-          frameSubstitutionNode = instantiateFrameSubstitution(string, context),
-          frameSubstitution = frameSubstitutionFromFrameSubstitutionNode(frameSubstitutionNode, context);
-
-    return frameSubstitution;
+    return withinFragment((context) => {
+      const frameAndMetavariableString = frameSubstitutionStringFromFrameAndMetavariable(frame, metavariable),
+            string = frameAndMetavariableString,  ///
+            frameSubstitutionNode = instantiateFrameSubstitution(string, context),
+            frameSubstitution = frameSubstitutionFromFrameSubstitutionNode(frameSubstitutionNode, context);
+
+      return frameSubstitution;
+    }, context);
   }
 });
-
-function stringFromFrameAndMetavariable(frame, metavariable) {
-  const frameString = frame.getString(),
-        metavariableString = metavariable.getString(),
-        string = `[${frameString} for [${metavariableString}]]`;
-
-  return string;
-}

package/src/element/substitution/statement.js

@@ -4,11 +4,13 @@ import elements from "../../elements";
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
+import { withinFragment } from "../../utilities/fragment";
 import { unifySubstitution } from "../../process/unify";
 import { stripBracketsFromStatement } from "../../utilities/brackets";
 import { instantiateStatementSubstitution } from "../../process/instantiate";
 import { statementSubstitutionFromStatementSubstitutionNode } from "../../utilities/element";
 import { statementFromJSON, statementToStatementJSON, metavariableFromJSON, metavariableToMetavariableJSON } from "../../utilities/json";
+import { statementSubstitutionStringFromStatementAndMetavariable, statementSubstitutionStringFromStatementMetavariableAndSubstitution } from "../../utilities/string";
 
 export default define(class StatementSubstitution extends Substitution {
   constructor(context, string, node, resolved, statement, metavariable, substitution) {
@@ -73,12 +75,13 @@ export default define(class StatementSubstitution extends Substitution {
     return substitutionEqualToSubstitution;
   }
 
-  isStatementEqualToStatement(statement, context) {
+  compareStatesment(statement, context) {
     statement = stripBracketsFromStatement(statement, context); ///
 
-    const statementEqualToStatement = this.statement.isEqualTo(statement);
+    const statementEqualToStatement = this.statement.isEqualTo(statement),
+          comparesToStatement = statementEqualToStatement;  ///
 
-    return statementEqualToStatement;
+    return comparesToStatement;
   }
 
   isSimple() {
@@ -214,18 +217,14 @@ export default define(class StatementSubstitution extends Substitution {
   static fromStatementAndMetavariable(statement, metavariable, context) {
     statement = stripBracketsFromStatement(statement, context); ///
 
-    const string = stringFromStatementAndMetavariable(statement, metavariable),
-          statementSubstitutionNode = instantiateStatementSubstitution(string, context);
+    const statementSubstitution = withinFragment((context) => {
+      const statementSubstitutionString = statementSubstitutionStringFromStatementAndMetavariable(statement, metavariable, context),
+            string = statementSubstitutionString, ///
+            statementSubstitutionNode = instantiateStatementSubstitution(string, context),
+            statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context)
 
-    context = {
-      nodeAsString: () => string
-    };
-
-    const statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context);
-
-    statementSubstitution.setStatement(statement);
-
-    statementSubstitution.setMetavariable(metavariable);
+      return statementSubstitution;
+    }, context);
 
     return statementSubstitution;
   }
@@ -233,46 +232,15 @@ export default define(class StatementSubstitution extends Substitution {
   static fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context) {
     statement = stripBracketsFromStatement(statement, context); ///
 
-    const string = stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context),
-          statementSubstitutionNode = instantiateStatementSubstitution(string, context);
-
-    context = {
-      nodeAsString: () => string
-    };
+    const statementSubstitution = withinFragment((context) => {
+      const statementSubstitutionString = statementSubstitutionStringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution),
+            string = statementSubstitutionString, ///
+            statementSubstitutionNode = instantiateStatementSubstitution(string, context),
+            statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context)
 
-    const statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context);
-
-    statementSubstitution.setStatement(statement);
-
-    statementSubstitution.setMetavariable(metavariable);
-
-    statementSubstitution.setSubstitution(substitution);
+      return statementSubstitution;
+    }, context);
 
     return statementSubstitution;
   }
 });
-
-function stringFromStatementAndMetavariable(statement, metavariable) {
-  const statementString = statement.getString(),
-        metavariableString = metavariable.getString(),
-        string = `[${statementString} for ${metavariableString}]`;
-
-  return string;
-}
-
-function stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution) {
-  let string;
-
-  const statementString = statement.getString(),
-        metavariableString = metavariable.getString();
-
-  if (substitution === null) {
-    string = `[${statementString} for ${metavariableString}]`;
-  } else {
-    const substitutionString = substitution.getString();
-
-    string = `[${statementString} for ${metavariableString}${substitutionString}]`;
-  }
-
-  return string;
-}

package/src/element/substitution.js

@@ -92,10 +92,10 @@ export default class Substitution extends Element {
     return referenceEqualToReference;
   }
 
-  isStatementEqualToStatement(statement, context) {
-    const statementEqualToStatement = false;
+  compareStatement(statement, context) {
+    const comparesToStatement = false;
 
-    return statementEqualToStatement;
+    return comparesToStatement;
   }
 
   isMetavariableEqualToMetavariable(metavariable) {

package/src/element/term.js

@@ -112,16 +112,15 @@ export default define(class Term extends Element {
     return validates;
   }
 
-  verifyGivenType(type, generalContext, specificContext) {
-    let verifiesGivenType;
+  validateGivenType(type, context) {
+    let validatesGivenType = false;
 
     const typeString = type.getString(),
           termString = this.getString();  ///
 
-    specificContext.trace(`Validating the '${termString}' term given the '${typeString}' type...`);
+    context.trace(`Validating the '${termString}' term given the '${typeString}' type...`);
 
-    const context = specificContext, ///
-          validates = this.validate(context, () => {
+    const validates = this.validate(context, () => {
             let verifiesAhead;
 
             const typeEqualToOrSubTypeOfGivenTypeType = this.type.isEqualToOrSubTypeOf(type);
@@ -133,13 +132,15 @@ export default define(class Term extends Element {
             return verifiesAhead;
           });
 
-    verifiesGivenType = validates; ///
+    if (validates) {
+      validatesGivenType = true;
+    }
 
-    if (verifiesGivenType) {
-      specificContext.debug(`...validated the '${termString}' term given the '${typeString}' type.`);
+    if (validatesGivenType) {
+      context.debug(`...validated the '${termString}' term given the '${typeString}' type.`);
     }
 
-    return verifiesGivenType;
+    return validatesGivenType;
   }
 
   toJSON() {

package/src/element/{axiom.js → topLevelAssertion/axiom.js}

@@ -1,10 +1,10 @@
 "use strict";
 
-import AxiomLemmaTheoremConjecture  from "./axiomLemmaTheoremConjecture";
+import TopLevelAssertion  from "../../node/topLevelAssertion";
 
-import { define } from "../elements";
+import { define } from "../../elements";
 
-export default define(class Axiom extends AxiomLemmaTheoremConjecture {
+export default define(class Axiom extends TopLevelAssertion {
   isSatisfiable() {
     const signature = this.getSignature(),
           satisfiable = (signature !== null);
@@ -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,19 +202,42 @@ export default define(class Axiom extends AxiomLemmaTheoremConjecture {
     return suppositionsUnify;
   }
 
-  unifyAxiomLemmaTheoremOrConjecture(axiomLemmaTheoremOrConjecture, substitutions, context) {
-    let axiomLemmaTheoremOrConjectureUnifies = false;
+  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;
+  }
+
+  unifyTopLevelAssertion(topLevelAssertion, substitutions, context) {
+    let topLevelAssertionUnifies = false;
 
     const node = this.getNode(),
           axiomString = this.getString(),
-          axiomLemmaTheoremOrConjectureString = axiomLemmaTheoremOrConjecture.getString();
+          topLevelAssertionString = topLevelAssertion.getString();
 
-    context.trace(`Unifying the '${axiomLemmaTheoremOrConjectureString}' axiom, lemma, theorem or conjecture with the '${axiomString}' axiom...`, node);
+    context.trace(`Unifying the '${topLevelAssertionString}' top level assertion with the '${axiomString}' axiom...`, node);
 
-    const hypothesesCorrelate = axiomLemmaTheoremOrConjecture.correlateHypotheses(context);
+    const hypothesesCorrelate = topLevelAssertion.correlateHypotheses(context);
 
     if (hypothesesCorrelate) {
-      const deduction = axiomLemmaTheoremOrConjecture.getDeduction(),  ///
+      const deduction = topLevelAssertion.getDeduction(),  ///
             specificContext = context;  ///
 
       context = this.getContext();
@@ -246,21 +246,21 @@ export default define(class Axiom extends AxiomLemmaTheoremConjecture {
             deductionUnifies = this.unifyDeduction(deduction, substitutions, generalContext, specificContext);
 
       if (deductionUnifies) {
-        const suppositions = axiomLemmaTheoremOrConjecture.getSuppositions(),
+        const suppositions = topLevelAssertion.getSuppositions(),
               suppositionsUnify = this.unifySuppositions(suppositions, substitutions, generalContext, specificContext);
 
-        axiomLemmaTheoremOrConjectureUnifies = suppositionsUnify; ///
+        topLevelAssertionUnifies = suppositionsUnify; ///
       }
     }
 
-    if (axiomLemmaTheoremOrConjectureUnifies) {
-      context.debug(`...unified the '${axiomLemmaTheoremOrConjectureString}' axiom, lemma, theorem or conjecture with the '${axiomString}' axiom.`, node);
+    if (topLevelAssertionUnifies) {
+      context.debug(`...unified the '${topLevelAssertionString}' top level assertion with the '${axiomString}' axiom.`, node);
     }
 
-    return axiomLemmaTheoremOrConjectureUnifies;
+    return topLevelAssertionUnifies;
   }
 
   static name = "Axiom";
 
-  static fromJSON(json, context) { return AxiomLemmaTheoremConjecture.fromJSON(Axiom, json, context); }
+  static fromJSON(json, context) { return TopLevelAssertion.fromJSON(Axiom, json, context); }
 });

package/src/element/{conjecture.js → topLevelAssertion/conjecture.js}

@@ -1,10 +1,10 @@
 "use strict";
 
-import AxiomLemmaTheoremConjecture from "./axiomLemmaTheoremConjecture";
+import TopLevelAssertion from "../topLevelAssertion";
 
-import { define } from "../elements";
+import { define } from "../../elements";
 
-export default define(class Conjecture extends AxiomLemmaTheoremConjecture {
+export default define(class Conjecture extends TopLevelAssertion {
   verify() {
     let verifies;
 
@@ -30,5 +30,5 @@ export default define(class Conjecture extends AxiomLemmaTheoremConjecture {
 
   static name = "Conjecture";
 
-  static fromJSON(json, context) { return AxiomLemmaTheoremConjecture.fromJSON(Conjecture, json, context); }
+  static fromJSON(json, context) { return TopLevelAssertion.fromJSON(Conjecture, json, context); }
 });

package/src/element/{lemma.js → topLevelAssertion/lemma.js}

@@ -1,10 +1,10 @@
 "use strict";
 
-import AxiomLemmaTheoremConjecture from "./axiomLemmaTheoremConjecture";
+import TopLevelAssertion from "../topLevelAssertion";
 
-import { define } from "../elements";
+import { define } from "../../elements";
 
-export default define(class Lemma extends AxiomLemmaTheoremConjecture {
+export default define(class Lemma extends TopLevelAssertion {
   verify() {
     let verifies;
 

package/src/element/{theorem.js → topLevelAssertion/theorem.js}

@@ -1,10 +1,10 @@
 "use strict";
 
-import AxiomLemmaTheoremConjecture from "./axiomLemmaTheoremConjecture";
+import TopLevelAssertion from "../topLevelAssertion";
 
-import { define } from "../elements";
+import { define } from "../../elements";
 
-export default define(class Theorem extends AxiomLemmaTheoremConjecture {
+export default define(class Theorem extends TopLevelAssertion {
   verify() {
     let verifies;
 
@@ -29,5 +29,5 @@ export default define(class Theorem extends AxiomLemmaTheoremConjecture {
 
   static name = "Theorem";
 
-  static fromJSON(json, context) { return AxiomLemmaTheoremConjecture.fromJSON(Theorem, json, context); }
+  static fromJSON(json, context) { return TopLevelAssertion.fromJSON(Theorem, json, context); }
 });