occam-verify-cli 1.0.444 → 1.0.457

package/src/element/{premise.js → proofAssertion/premise.js}

@@ -1,25 +1,26 @@
 "use strict";
 
-import Element from "../element";
-import elements from "../elements";
-import TemporaryContext from "../context/temporary";
-import assignAssignments from "../process/assign";
-
-import { define } from "../elements";
-import { termsFromJSON, framesFromJSON, statementFromJSON, procedureCallFromJSON, termsToTermsJSON, framesToFramesJSON, statementToStatementJSON, procedureCallToProcedureCallJSON } from "../utilities/json";
-
-export default define(class Premise extends Element {
+import ProofAssertion from "../proofAssertion";
+import TransientContext from "../../context/transient";
+import assignAssignments from "../../process/assign";
+
+import { define } from "../../elements";
+import { termsFromJSON,
+         framesFromJSON,
+         termsToTermsJSON,
+         statementFromJSON,
+         framesToFramesJSON,
+         procedureCallFromJSON,
+         statementToStatementJSON,
+         procedureCallToProcedureCallJSON } from "../../utilities/json";
+
+export default define(class Premise extends ProofAssertion {
   constructor(context, string, node, statement, procedureCall) {
-    super(context, string, node);
+    super(context, string, node, statement);
 
-    this.statement = statement;
     this.procedureCall = procedureCall;
   }
 
-  getStatement() {
-    return this.statement;
-  }
-
   getProcedureCall() {
     return this.procedureCall;
   }
@@ -27,32 +28,32 @@ export default define(class Premise extends Element {
   verify(context) {
     let verifies = false;
 
-    const temporaryContext = TemporaryContext.fromNothing(context);
+    const transientContext = TransientContext.fromNothing(context);
 
-    context = temporaryContext; ///
+    context = transientContext; ///
 
     const node = this.getNode(),
           premiseString = this.getString(); ///
 
     context.trace(`Verifying the '${premiseString}' premise...`, node);
 
-    if ((this.statement === null) && (this.procedureCall === null)) {
+    const statement = this.getStatement();
+
+    if ((statement === null) && (this.procedureCall === null)) {
       context.debug(`Unable to verify the '${premiseString}' premise because it is nonsense.`, node);
     } else {
-      if (this.statement !== null) {
+      if (statement !== null) {
         const stated = true,
               assignments = [],
-              statementValidates = this.statement.validate(assignments, stated, context);
+              statementValidates = statement.validate(assignments, stated, context);
 
         if (statementValidates) {
           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;
           }
@@ -82,15 +83,22 @@ export default define(class Premise extends Element {
   unifyIndependently(substitutions, context) {
     let unifiesIndependently = false;
 
-    const node = this.getNode(),
-          premiseString = this.getString(),  ///
-          generalContext = this.context,  ///
-          specificContext = context;  ///
+    const premiseString = this.getString(); ///
 
-    context.trace(`Unifying the '${premiseString}' premise independently...`, node);
+    context.trace(`Unifying the '${premiseString}' premise independently...`);
+
+    const specificContext = context; ///
+
+    context = this.getContext();
+
+    const generalContext = context;  ///
+
+    context = specificContext;  ///
 
-    if (this.statement !== null) {
-      const statementUnifiesIndependently = this.statement.unifyIndependently(substitutions, generalContext, specificContext);
+    const statement = this.getStatement();
+
+    if (statement !== null) {
+      const statementUnifiesIndependently = statement.unifyIndependently(substitutions, generalContext, specificContext);
 
       if (statementUnifiesIndependently) {
         unifiesIndependently = true;
@@ -106,84 +114,92 @@ export default define(class Premise extends Element {
     }
 
     if (unifiesIndependently) {
-      context.debug(`...unified the '${premiseString}' premise independenly.`, node);
+      context.debug(`...unified the '${premiseString}' premise independenly.`);
     }
 
     return unifiesIndependently;
   }
 
-  unifyStepOrSubproof(stepOrSubproof, substitutions, context) {
-    let stepOrSubproofUnifies = false;
+  unifySubproofOrProofAssertion(subproofOrProofAssertion, substitutions, context) {
+    let subproofOrProofAssertionUnifies = false;
 
-    const stepOrSubProofStep = stepOrSubproof.isStep(),
-          subproof = stepOrSubProofStep ?
-                       null :
-                         stepOrSubproof,
-          step = stepOrSubProofStep ?
-                        stepOrSubproof :
-                          null;
+    const subproofOrProofAssertionProofAssertion = subproofOrProofAssertion.isProofAssertion(),
+          proofAssertion = subproofOrProofAssertionProofAssertion ?
+                             subproofOrProofAssertion :
+                               null,
+          subproof = subproofOrProofAssertionProofAssertion ?
+                        null :
+                          subproofOrProofAssertion;
 
     substitutions.snapshot();
 
     if (subproof !== null) {
       const subproofUnifies = this.unifySubproof(subproof, substitutions, context);
 
-      stepOrSubproofUnifies = subproofUnifies; ///
+      if (subproofUnifies) {
+        subproofOrProofAssertionUnifies = true;
+      }
     }
 
-    if (step !== null) {
-      const statementUnifies = this.unifyStep(step, substitutions, context);
+    if (proofAssertion !== null) {
+      const proofAssertionUnifies = this.unifyProofAssertion(proofAssertion, substitutions, context);
 
-      stepOrSubproofUnifies = statementUnifies;  ///
+      if (proofAssertionUnifies) {
+        subproofOrProofAssertionUnifies = true;
+      }
     }
 
-    if (stepOrSubproofUnifies) {
+    if (subproofOrProofAssertionUnifies) {
       substitutions.resolve(context);
     }
 
-    stepOrSubproofUnifies ?
+    subproofOrProofAssertionUnifies ?
       substitutions.continue() :
         substitutions.rollback(context);
 
-    return stepOrSubproofUnifies;
+    return subproofOrProofAssertionUnifies;
   }
 
-  unifySubproof(subproof, substitutions, context) {
-    let subproofUnifies = false;
+  unifyProofAssertion(proofAssertion, substitutions, context) {
+    let proofAssertionUnifies = false;
 
-    const premise = this, ///
-          subproofString = subproof.getString(),
-          premiseStatement = premise.getStatement(),
-          premiseStatementString = premiseStatement.getString();
+    const premiseString = this.getString(),
+          proofAssertionString = proofAssertion.getString();
 
-    context.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement...`);
-
-    const specificContext = context;  ///
+    context.trace(`Unifying the '${proofAssertionString}' proof assertion with the '${premiseString}' premise...`);
 
     context = this.getContext();
 
     const generalContext = context; ///
 
+    context = proofAssertion.getContext();
+
+    const specificContext = context;  ///
+
     context = specificContext;  ///
 
-    if (this.statement !== null) {
-      const context = generalContext, ///
-            subproofAssertion = subproofAssertionFromStatement(this.statement, context);
+    const statement = proofAssertion.getStatement(),
+          statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
 
-      if (subproofAssertion !== null) {
-        subproofUnifies = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);
-      }
+    if (statementUnifies) {
+      proofAssertionUnifies = true;
     }
 
-    if (subproofUnifies) {
-      context.debug(`...unified the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement.`);
+    if (proofAssertionUnifies) {
+      context.debug(`...unified the '${proofAssertionString}' proof assertion with the '${premiseString}' premise.`);
     }
 
-    return subproofUnifies;
+    return proofAssertionUnifies;
   }
 
-  unifyStep(step, substitutions, context) {
-    let stepUnifies = false;
+  unifySubproof(subproof, substitutions, context) {
+    let subproofUnifies = false;
+
+    const node = this.getNode(),
+          premiseString = this.getString(),
+          subproofString = subproof.getString();
+
+    context.trace(`Unifying the '${subproofString}' subproof with the '${premiseString}' premise...`, node);
 
     const specificContext = context;  ///
 
@@ -193,14 +209,30 @@ export default define(class Premise extends Element {
 
     context = specificContext;  ///
 
-    const statement = step.getStatement(),
-          statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+    const statement = this.getStatement();
 
-    if (statementUnifies) {
-      stepUnifies = true;
+    if (statement !== null) {
+      const statementNode = statement.getNode(),
+            subproofAssertionNode = statementNode.getSubproofAssertionNode();
+
+      if (subproofAssertionNode !== null) {
+        const context = generalContext, ///
+              assertionNode = subproofAssertionNode,  ///
+              assertion = context.findAssertionByAssertionNode(assertionNode)
+
+        if (assertion !== null) {
+          const subproofAssertion = assertion;  ///
+
+          subproofUnifies = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);
+        }
+      }
     }
 
-    return stepUnifies;
+    if (subproofUnifies) {
+      context.debug(`...unified the '${subproofString}' subproof with the '${premiseString}' premise.`, node);
+    }
+
+    return subproofUnifies;
   }
 
   toJSON() {
@@ -239,7 +271,7 @@ export default define(class Premise extends Element {
           frames = framesFromJSON(json, context),
           statement = statementFromJSON(json, context),
           procedureCall = procedureCallFromJSON(json, context),
-          temporaryContext = TemporaryContext.fromTermsAndFrames(terms, frames, context);
+          transientContext = TransientContext.fromTermsAndFrames(terms, frames, context);
 
     let string;
 
@@ -253,7 +285,7 @@ export default define(class Premise extends Element {
 
     const node = null;
 
-    context = temporaryContext; ///
+    context = transientContext; ///
 
     const premise = new Premise(context, string, node, statement, procedureCall);
 

package/src/element/{step.js → proofAssertion/step.js}

@@ -1,29 +1,21 @@
 "use strict";
 
-import Element from "../element";
-import elements from "../elements";
-import TemporaryContext from "../context/temporary";
-
-import { define } from "../elements";
-import { instantiateStep } from "../process/instantiate";
-import { unifyStatements } from "../utilities/unification";
-import { equateStatements } from "../process/equate";
-import { stepFromStepNode } from "../utilities/element";
-import { propertyAssertionFromStatement } from "../utilities/statement";
-
-export default define(class Step extends Element {
+import elements from "../../elements";
+import ProofAssertion from "../proofAssertion";
+import TransientContext from "../../context/transient";
+
+import { define } from "../../elements";
+import { unifyStatements } from "../../utilities/unification";
+import { propertyAssertionFromStatement } from "../../utilities/statement";
+
+export default define(class Step extends ProofAssertion {
   constructor(context, string, node, statement, reference, satisfiesAssertion) {
-    super(context, string, node);
+    super(context, string, node, statement);
 
-    this.statement = statement;
     this.reference = reference;
     this.satisfiesAssertion = satisfiesAssertion;
   }
 
-  getStatement() {
-    return this.statement;
-  }
-
   getReference() {
     return this.reference;
   }
@@ -51,16 +43,11 @@ export default define(class Step extends Element {
     return stated;
   }
 
-  isStep() {
-    const step = true;
-
-    return step;
-  }
-
   compareTermAndPropertyRelation(term, propertyRelation, context) {
     let comparesToTermAndPropertyRelation = false;
 
-    const propertyAssertion = propertyAssertionFromStatement(this.statement, context);
+    const statement = this.getStatement(),
+          propertyAssertion = propertyAssertionFromStatement(statement, context);
 
     if (propertyAssertion !== null) {
       comparesToTermAndPropertyRelation = propertyAssertion.compareTermAndPropertyRelation(term, propertyRelation, context);
@@ -72,30 +59,32 @@ export default define(class Step extends Element {
   verify(substitutions, assignments, context) {
     let verifies = false;
 
-    const temporaryContext = TemporaryContext.fromNothing(context);
+    const transientContext = TransientContext.fromNothing(context);
 
-    context = temporaryContext; ///
+    context = transientContext; ///
 
     const node = this.getNode(),
           stepString = this.getString(); ///
 
     context.trace(`Verifying the '${stepString}' step...`, node);
 
-    if (this.statement === null) {
+    const statement = this.getStatement();
+
+    if (statement === null) {
       context.debug(`Unable to verify the '${stepString}' step because it is nonsense.`, node);
     } else {
-      const referenceVerifies = this.verifyReference(context);
+      const referenceValidates = this.validateReference(context);
 
-      if (referenceVerifies) {
+      if (referenceValidates) {
         const satisfiesAssertioVeriries = this.verifySatisfiesAssertion(context);
 
         if (satisfiesAssertioVeriries) {
           const stated = this.isStated(),
-                statementValidates = this.statement.validate(assignments, stated, context);
+                statementValidates = statement.validate(assignments, stated, context);
 
           if (statementValidates) {
             const statementUnifies = unifyStatements.some((unifyStatement) => {
-              const statementUnifies = unifyStatement(this.statement, this.reference, this.satisfiesAssertion, substitutions, context);
+              const statementUnifies = unifyStatement(statement, this.reference, this.satisfiesAssertion, substitutions, context);
 
               if (statementUnifies) {
                 return true;
@@ -103,14 +92,6 @@ export default define(class Step extends Element {
             });
 
             if (statementUnifies) {
-              const { Step } = elements,
-                    step = Step.fromStatement(this.statement, context),
-                    stepOrSubproof = step;  ///
-
-              context.addStepOrSubproof(stepOrSubproof);
-
-              this.setContext(context);
-
               verifies = true;
             }
           }
@@ -119,75 +100,59 @@ export default define(class Step extends Element {
     }
 
     if (verifies) {
+      this.setContext(context);
+
       context.debug(`...verified the '${stepString}' step.`, node);
     }
 
     return verifies;
   }
 
-  verifyReference(context) {
-    let referenceVeriries;
+  validateReference(context) {
+    let referenceValidates = true;
 
-    const node = this.getNode(),
-          stepString = this.getString();  ///
+    if (this.reference !== null) {
+      const node = this.getNode(),
+            stepString = this.getString();
 
-    context.trace(`Verifying the '${stepString}' step's reference... `, node);
+      context.trace(`Validating the '${stepString}' step's reference... `, node);
 
-    if (this.reference !== null) {
-      referenceVeriries = this.reference.verify(context);
-    } else {
-      referenceVeriries = true;
-    }
+      referenceValidates = this.reference.validate(context);
 
-    if (referenceVeriries) {
-      context.debug(`...verified the '${stepString}' step's reference. `, node);
+      if (referenceValidates) {
+        context.debug(`...validating the '${stepString}' step's reference. `, node);
+      }
     }
 
-    return referenceVeriries;
+    return referenceValidates;
   }
 
   verifySatisfiesAssertion(context) {
-    let satisfiesAssertionVerifies;
+    let satisfiesAssertionVerifies = true;  ///
 
-    const node = this.getNode(),
-          stepString = this.getString();  ///
+    if (this.satisfiesAssertion !== null) {
+      const node = this.getNode(),
+            stepString = this.getString();  ///
 
-    context.trace(`Verifying the '${stepString}' step's satisfies assertion... `, node);
+      context.trace(`Verifying the '${stepString}' step's satisfies assertion... `, node);
 
-    if (this.satisfiesAssertion !== null) {
       const stated = true,
             assignments = null;
 
       satisfiesAssertionVerifies = this.satisfiesAssertion.validate(assignments, stated, context);
-    } else {
-      satisfiesAssertionVerifies = true;
-    }
 
-    if (satisfiesAssertionVerifies) {
-      context.debug(`...verified the '${stepString}' step's satisfies assertion. `, node);
+      if (satisfiesAssertionVerifies) {
+        context.debug(`...verified the '${stepString}' step's satisfies assertion. `, node);
+      }
     }
 
     return satisfiesAssertionVerifies;
   }
 
-  compareStatment(statement, context) {
-    let comparesToStatement;
-
-    const leftStatement = statement,  ///
-          rightStatement = this.statement,  ///
-          leftStatementNode = leftStatement.getNode(),
-          rightStatementNode = rightStatement.getNode(),
-          statementsEquate = equateStatements(leftStatementNode, rightStatementNode, context);
-
-    comparesToStatement = statementsEquate;  ///
-
-    return comparesToStatement;
-  }
-
   unifyWithSatisfiesAssertion(satisfiesAssertion, context) {
     let unifiesWithSatisfiesAssertion = false;
 
-    const stepString = this.string, ///
+    const stepString = this.getString(), ///
           satisfiesAssertionString = satisfiesAssertion.getString();
 
     context.trace(`Unifying the '${stepString}' step with the '${satisfiesAssertionString}' satisfies assertion...`, this.node);
@@ -218,15 +183,4 @@ export default define(class Step extends Element {
   }
 
   static name = "Step";
-
-  static fromStatement(statement, context) {
-    const statementString = statement.getString(),
-          stepString = statementString, ///
-          string = `${stepString}
-`,
-          stepNode = instantiateStep(string, context),
-          step = stepFromStepNode(stepNode, context);
-
-    return step;;
-  }
 });