occam-verify-cli 1.0.448 → 1.0.472

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

@@ -1,10 +1,10 @@
 "use strict";
 
-import ProofAssertion from "./proofAssertion";
-import TemporaryContext from "../context/temporary";
-import assignAssignments from "../process/assign";
+import ProofAssertion from "../proofAssertion";
+import assignAssignments from "../../process/assign";
 
-import { define } from "../elements";
+import { define } from "../../elements";
+import { attempt, synthetically } from "../../utilities/context";
 import { termsFromJSON,
          framesFromJSON,
          termsToTermsJSON,
@@ -12,7 +12,7 @@ import { termsFromJSON,
          framesToFramesJSON,
          procedureCallFromJSON,
          statementToStatementJSON,
-         procedureCallToProcedureCallJSON } from "../utilities/json";
+         procedureCallToProcedureCallJSON } from "../../utilities/json";
 
 export default define(class Premise extends ProofAssertion {
   constructor(context, string, node, statement, procedureCall) {
@@ -25,55 +25,59 @@ export default define(class Premise extends ProofAssertion {
     return this.procedureCall;
   }
 
-  verify(context) {
-    let verifies = false;
+  isStated() {
+    const stated = true; ///
 
-    const temporaryContext = TemporaryContext.fromNothing(context);
+    return stated;
+  }
 
-    context = temporaryContext; ///
+  verify(context) {
+    let verifies = false;
 
     const node = this.getNode(),
           premiseString = this.getString(); ///
 
     context.trace(`Verifying the '${premiseString}' premise...`, node);
 
-    const statement = this.getStatement();
+    const statement = this.getStatement(),
+          procedureCall = this.getProcedureCall();
 
-    if ((statement === null) && (this.procedureCall === null)) {
-      context.debug(`Unable to verify the '${premiseString}' premise because it is nonsense.`, node);
-    } else {
-      if (statement !== null) {
-        const stated = true,
-              assignments = [],
-              statementValidates = statement.validate(assignments, stated, context);
+    if ((statement !== null) || (procedureCall !== null)) {
+      attempt((context) => {
+        if (statement !== null) {
+          const assignments = [],
+                statementValidates = this.validateStatement(assignments, context);
 
-        if (statementValidates) {
-          const assignmentsAssigned = assignAssignments(assignments, context);
+          if (statementValidates) {
+            const assignmentsAssigned = assignAssignments(assignments, context);
 
-          if (assignmentsAssigned) {
-            const subproofOrProofAssertion = this;  ///
+            if (assignmentsAssigned) {
+              const subproofOrProofAssertion = this;  ///
 
-            context.addSubproofOrProofAssertion(subproofOrProofAssertion);
+              context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
-            verifies = true;
+              this.setContext(context);
+
+              verifies = true;
+            }
           }
         }
-      }
 
-      if (this.procedureCall !== null) {
-        const stated = true,
-              assignments = null,
-              procedureCallVerifies = this.procedureCall.verify(assignments, stated, context);
+        if (procedureCall !== null) {
+          const procedureCallValidates = procedureCall.validate(context);
+
+          if (procedureCallValidates) {
+            this.setContext(context);
 
-        if (procedureCallVerifies) {
-          verifies = true;
+            verifies = true;
+          }
         }
-      }
+      }, context);
+    } else {
+      context.debug(`Unable to verify the '${premiseString}' premise because it is nonsense.`, node);
     }
 
     if (verifies) {
-      this.setContext(context);
-
       context.debug(`...verified the '${premiseString}' premise.`, node);
     }
 
@@ -83,16 +87,15 @@ export default define(class Premise extends ProofAssertion {
   unifyIndependently(substitutions, context) {
     let unifiesIndependently = false;
 
-    const node = this.getNode(),
-          premiseString = this.getString(); ///
+    const premiseString = this.getString(); ///
 
-    context.trace(`Unifying the '${premiseString}' premise independently...`, node);
+    context.trace(`Unifying the '${premiseString}' premise independently...`);
 
-    const generalContext = context; ///
+    const specificContext = context; ///
 
     context = this.getContext();
 
-    const specificContext = context;  ///
+    const generalContext = context;  ///
 
     context = specificContext;  ///
 
@@ -115,7 +118,7 @@ export default define(class Premise extends ProofAssertion {
     }
 
     if (unifiesIndependently) {
-      context.debug(`...unified the '${premiseString}' premise independenly.`, node);
+      context.debug(`...unified the '${premiseString}' premise independenly.`);
     }
 
     return unifiesIndependently;
@@ -126,13 +129,13 @@ export default define(class Premise extends ProofAssertion {
 
     const subproofOrProofAssertionProofAssertion = subproofOrProofAssertion.isProofAssertion(),
           proofAssertion = subproofOrProofAssertionProofAssertion ?
-                        subproofOrProofAssertion :
-                          null,
+                             subproofOrProofAssertion :
+                               null,
           subproof = subproofOrProofAssertionProofAssertion ?
                         null :
                           subproofOrProofAssertion;
 
-    substitutions.snapshot();
+    substitutions.snapshot(context);
 
     if (subproof !== null) {
       const subproofUnifies = this.unifySubproof(subproof, substitutions, context);
@@ -155,7 +158,7 @@ export default define(class Premise extends ProofAssertion {
     }
 
     subproofOrProofAssertionUnifies ?
-      substitutions.continue() :
+      substitutions.continue(context) :
         substitutions.rollback(context);
 
     return subproofOrProofAssertionUnifies;
@@ -164,11 +167,10 @@ export default define(class Premise extends ProofAssertion {
   unifyProofAssertion(proofAssertion, substitutions, context) {
     let proofAssertionUnifies = false;
 
-    const node = this.getNode(),
-          premiseString = this.getString(),
+    const premiseString = this.getString(), ///
           proofAssertionString = proofAssertion.getString();
 
-    context.trace(`Unifying the '${proofAssertionString}' proof assertion with the '${premiseString}' premise...`, node);
+    context.trace(`Unifying the '${proofAssertionString}' proof assertion with the '${premiseString}' premise...`);
 
     const specificContext = context;  ///
 
@@ -178,15 +180,20 @@ export default define(class Premise extends ProofAssertion {
 
     context = specificContext;  ///
 
-    const statement = proofAssertion.getStatement(),
-          statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+    const proofAssertionContext = proofAssertion.getContext(),
+          statementUnifies = synthetically((specificContext) => {
+            const statement = proofAssertion.getStatement(),
+                  statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+
+            return statementUnifies;
+          }, specificContext, proofAssertionContext);
 
     if (statementUnifies) {
       proofAssertionUnifies = true;
     }
 
     if (proofAssertionUnifies) {
-      context.debug(`...unified the '${proofAssertionString}' proof assertion with the '${premiseString}' premise.`, node);
+      context.debug(`...unified the '${proofAssertionString}' proof assertion with the '${premiseString}' premise.`);
     }
 
     return proofAssertionUnifies;
@@ -270,8 +277,7 @@ export default define(class Premise extends ProofAssertion {
     const terms = termsFromJSON(json, context),
           frames = framesFromJSON(json, context),
           statement = statementFromJSON(json, context),
-          procedureCall = procedureCallFromJSON(json, context),
-          temporaryContext = TemporaryContext.fromTermsAndFrames(terms, frames, context);
+          procedureCall = procedureCallFromJSON(json, context);
 
     let string;
 
@@ -285,8 +291,6 @@ export default define(class Premise extends ProofAssertion {
 
     const node = null;
 
-    context = temporaryContext; ///
-
     const premise = new Premise(context, string, node, statement, procedureCall);
 
     return premise;

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

@@ -1,12 +1,12 @@
 "use strict";
 
-import elements from "../elements";
-import ProofAssertion from "./proofAssertion";
-import TemporaryContext from "../context/temporary";
+import elements from "../../elements";
+import ProofAssertion from "../proofAssertion";
 
-import { define } from "../elements";
-import { unifyStatements } from "../utilities/unification";
-import { propertyAssertionFromStatement } from "../utilities/statement";
+import { define } from "../../elements";
+import { unifyStatements } from "../../utilities/unification";
+import { attempt, liminally } from "../../utilities/context";
+import { propertyAssertionFromStatement } from "../../utilities/statement";
 
 export default define(class Step extends ProofAssertion {
   constructor(context, string, node, statement, reference, satisfiesAssertion) {
@@ -56,13 +56,9 @@ export default define(class Step extends ProofAssertion {
     return comparesToTermAndPropertyRelation;
   }
 
-  verify(substitutions, assignments, context) {
+  verify(assignments, context) {
     let verifies = false;
 
-    const temporaryContext = TemporaryContext.fromNothing(context);
-
-    context = temporaryContext; ///
-
     const node = this.getNode(),
           stepString = this.getString(); ///
 
@@ -70,39 +66,44 @@ export default define(class Step extends ProofAssertion {
 
     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);
+    if (statement !== null) {
+      attempt((context) => {
+        const referenceValidates = this.validateReference(context);
 
-      if (referenceVerifies) {
-        const satisfiesAssertioVeriries = this.verifySatisfiesAssertion(context);
+        if (referenceValidates) {
+          const satisfiesAssertioValidates = this.validateSatisfiesAssertion(context);
 
-        if (satisfiesAssertioVeriries) {
-          const stated = this.isStated(),
-                statementValidates = statement.validate(assignments, stated, context);
+          if (satisfiesAssertioValidates) {
+            const statementValidates = this.validateStatement(assignments, context);
 
-          if (statementValidates) {
-            const statementUnifies = unifyStatements.some((unifyStatement) => {
-              const statementUnifies = unifyStatement(statement, this.reference, this.satisfiesAssertion, substitutions, context);
-
-              if (statementUnifies) {
-                return true;
-              }
-            });
+            if (statementValidates) {
+              const reference = this.getReference(),
+                    satisfiesAssertion = this.getSatisfiesAssertion(),
+                    statementUnifies = liminally((context) => {
+                      const statementUnifies = unifyStatements.some((unifyStatement) => {
+                        const statementUnifies = unifyStatement(statement, reference, satisfiesAssertion, context);
 
-            if (statementUnifies) {
-              const subproofOrProofAssertion = this;  ///
+                        if (statementUnifies) {
+                          this.setContext(context);
 
-              context.addSubproofOrProofAssertion(subproofOrProofAssertion);
+                          return true;
+                        }
+                      });
 
-              this.setContext(context);
+                      return statementUnifies;
+                    }, context);
 
-              verifies = true;
+              if (statementUnifies) {
+                verifies = true;
+              }
             }
           }
         }
-      }
+
+        return verifies;
+      }, context);
+    } else {
+      context.debug(`Unable to verify the '${stepString}' step because it is nonsense.`, node);
     }
 
     if (verifies) {
@@ -112,55 +113,51 @@ export default define(class Step extends ProofAssertion {
     return verifies;
   }
 
-  verifyReference(context) {
-    let referenceVeriries;
+  validateReference(context) {
+    let referenceValidates = true;
 
-    const node = this.getNode(),
-          stepString = this.getString();  ///
+    if (this.reference !== null) {
+      const stepString = this.getString(),  ///
+            referenceString = this.reference.getString();
 
-    context.trace(`Verifying the '${stepString}' step's reference... `, node);
+      context.trace(`Validating the '${stepString}' step's '${referenceString}' reference... `);
 
-    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(`...validated the '${stepString}' step's '${referenceString}' reference. `);
+      }
     }
 
-    return referenceVeriries;
+    return referenceValidates;
   }
 
-  verifySatisfiesAssertion(context) {
-    let satisfiesAssertionVerifies;
+  validateSatisfiesAssertion(context) {
+    let satisfiesAssertionValidates = true;  ///
 
-    const node = this.getNode(),
-          stepString = this.getString();  ///
+    if (this.satisfiesAssertion !== null) {
+      const stepString = this.getString(),  ///
+            satisfiesAssertion = this.satisfiesAssertion.getString();
 
-    context.trace(`Verifying the '${stepString}' step's satisfies assertion... `, node);
+      context.trace(`Validating the '${stepString}' step's '${satisfiesAssertion}' satisfies assertion... `);
 
-    if (this.satisfiesAssertion !== null) {
       const stated = true,
             assignments = null;
 
-      satisfiesAssertionVerifies = this.satisfiesAssertion.validate(assignments, stated, context);
-    } else {
-      satisfiesAssertionVerifies = true;
-    }
+      satisfiesAssertionValidates = this.satisfiesAssertion.validate(assignments, stated, context);
 
-    if (satisfiesAssertionVerifies) {
-      context.debug(`...verified the '${stepString}' step's satisfies assertion. `, node);
+      if (satisfiesAssertionValidates) {
+        context.debug(`...validating the '${stepString}' step's '${satisfiesAssertion}' satisfies assertion. `);
+      }
     }
 
-    return satisfiesAssertionVerifies;
+    return satisfiesAssertionValidates;
   }
 
   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);
@@ -171,7 +168,7 @@ export default define(class Step extends ProofAssertion {
     if (axiom !== null) {
       const { Substitutions } = elements,
             step = this,  ///
-            substitutions = Substitutions.fromNothing(),
+            substitutions = Substitutions.fromNothing(context),
             stepUnifies = axiom.unifyStep(step, substitutions, context);
 
       if (stepUnifies) {

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

@@ -1,15 +1,22 @@
 "use strict";
 
-import ProofAssertion from "./proofAssertion";
-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";
+import ProofAssertion from "../proofAssertion";
+import assignAssignments from "../../process/assign";
+
+import { define } from "../../elements";
+import { attempt, synthetically } from "../../utilities/context";
+import { termsFromJSON,
+         framesFromJSON,
+         termsToTermsJSON,
+         statementFromJSON,
+         framesToFramesJSON,
+         procedureCallFromJSON,
+         statementToStatementJSON,
+         procedureCallToProcedureCallJSON } from "../../utilities/json";
 
 export default define(class Supposition extends ProofAssertion {
   constructor(context, string, node, statement, procedureCall) {
-    super(context, string, node);
+    super(context, string, node, statement);
 
     this.procedureCall = procedureCall;
   }
@@ -18,55 +25,59 @@ export default define(class Supposition extends ProofAssertion {
     return this.procedureCall;
   }
 
-  verify(context) {
-    let verifies = false;
+  isStated() {
+    const stated = true; ///
 
-    const temporaryContext = TemporaryContext.fromNothing(context);
+    return stated;
+  }
 
-    context = temporaryContext; ///
+  verify(context) {
+    let verifies = false;
 
     const node = this.getNode(),
           suppositionString = this.getString(); ///
 
     context.trace(`Verifying the '${suppositionString}' supposition...`, node);
 
-    const statement = this.getStatement();
+    const statement = this.getStatement(),
+          procedureCall = this.getProcedureCall();
 
-    if ((statement === null) && (this.procedureCall === null)) {
-      context.debug(`Unable to verify the '${suppositionString}' supposition because it is nonsense.`, node);
-    } else {
-      if (statement !== null) {
-        const stated = true,
-              assignments = [],
-              statementValidates = statement.validate(assignments, stated, context);
+    if ((statement !== null) || (procedureCall !== null)) {
+      attempt((context) => {
+        if (statement !== null) {
+          const assignments = [],
+                statementValidates = this.validateStatement(assignments, context);
 
-        if (statementValidates) {
-          const assignmentsAssigned = assignAssignments(assignments, context);
+          if (statementValidates) {
+            const assignmentsAssigned = assignAssignments(assignments, context);
 
-          if (assignmentsAssigned) {
-            const subproofOrProofAssertion = this;  ///
+            if (assignmentsAssigned) {
+              const subproofOrProofAssertion = this;  ///
 
-            context.addSubproofOrProofAssertion(subproofOrProofAssertion);
+              context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
-            verifies = true;
+              this.setContext(context);
+
+              verifies = true;
+            }
           }
         }
-      }
 
-      if (this.procedureCall !== null) {
-        const stated = true,
-              assignments = null,
-              procedureCallVerifies = this.procedureCall.verify(assignments, stated, context);
+        if (procedureCall !== null) {
+          const procedureCallValidates = procedureCall.validate(context);
+
+          if (procedureCallValidates) {
+            this.setContext(context);
 
-        if (procedureCallVerifies) {
-          verifies = true;
+            verifies = true;
+          }
         }
-      }
+      }, context);
+    } else {
+      context.debug(`Unable to verify the '${suppositionString}' supposition because it is nonsense.`, node);
     }
 
     if (verifies) {
-      this.setContext(context);
-
       context.debug(`...verified the '${suppositionString}' supposition.`, node);
     }
 
@@ -76,10 +87,9 @@ export default define(class Supposition extends ProofAssertion {
   unifyIndependently(substitutions, context) {
     let unifiesIndependently = false;
 
-    const node = this.getNode(),
-          suppositionString = this.getString();
+    const suppositionString = this.getString(); ///
 
-    context.trace(`Unifying the '${suppositionString}' supposition independently...`, node);
+    context.trace(`Unifying the '${suppositionString}' supposition independently...`);
 
     const specificContext = context;  ///
 
@@ -108,7 +118,7 @@ export default define(class Supposition extends ProofAssertion {
     }
 
     if (unifiesIndependently) {
-      context.debug(`...unified the '${suppositionString}' supposition independenly.`, node);
+      context.debug(`...unified the '${suppositionString}' supposition independenly.`);
     }
 
     return unifiesIndependently;
@@ -125,7 +135,7 @@ export default define(class Supposition extends ProofAssertion {
                              subproofOrProofAssertion :
                                null;
 
-    substitutions.snapshot();
+    substitutions.snapshot(context);
 
     if (subproof !== null) {
       const subproofUnifies = this.unifySubproof(subproof, substitutions, context);
@@ -148,20 +158,19 @@ export default define(class Supposition extends ProofAssertion {
     }
 
     subproofOrProofAssertionUnifies ?
-      substitutions.continue() :
+      substitutions.continue(context) :
         substitutions.rollback(context);
 
     return subproofOrProofAssertionUnifies;
   }
 
   unifyProofAssertion(proofAssertion, substitutions, context) {
-    let stepUnifies = false;
+    let proofAssertionUnifies = false;
 
-    const node = this.getNode(),
-          suppositionString = this.getString(),
+    const suppositionString = this.getString(), ///
           proofAssertionString = proofAssertion.getString();
 
-    context.trace(`Unifying the '${proofAssertionString}' proof assertion with the '${suppositionString}' supposition...`, node);
+    context.trace(`Unifying the '${proofAssertionString}' proof assertion with the '${suppositionString}' supposition...`);
 
     const specificContext = context;  ///
 
@@ -171,18 +180,23 @@ export default define(class Supposition extends ProofAssertion {
 
     context = specificContext;  ///
 
-    const statement = proofAssertion.getStatement(),
-          statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+    const proofAssertionContext = proofAssertion.getContext(),
+          statementUnifies = synthetically((specificContext) => {
+            const statement = proofAssertion.getStatement(),
+                  statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+
+            return statementUnifies;
+          }, specificContext, proofAssertionContext);
 
     if (statementUnifies) {
-      stepUnifies = true;
+      proofAssertionUnifies = true;
     }
 
-    if (stepUnifies) {
-      context.debug(`...unified the '${proofAssertionString}' proof assertion with the '${suppositionString}' supposition.`, node);
+    if (proofAssertionUnifies) {
+      context.debug(`...unified the '${proofAssertionString}' proof assertion with the '${suppositionString}' supposition.`);
     }
 
-    return stepUnifies;
+    return proofAssertionUnifies;
   }
 
   unifySubproof(subproof, substitutions, context) {
@@ -190,7 +204,7 @@ export default define(class Supposition extends ProofAssertion {
 
     const node = this.getNode(),
           subproofString = subproof.getString(),
-          suppositionString = this.getString();
+          suppositionString = this.getString(); ///
 
     context.trace(`Unifying the '${subproofString}' subproof with the '${suppositionString}' supposition...`, node);
 
@@ -286,8 +300,7 @@ export default define(class Supposition extends ProofAssertion {
     const terms = termsFromJSON(json, context),
           frames = framesFromJSON(json, context),
           statement = statementFromJSON(json, context),
-          procedureCall = procedureCallFromJSON(json, context),
-          temporaryContext = TemporaryContext.fromTermsAndFrames(terms, frames, context);
+          procedureCall = procedureCallFromJSON(json, context);
 
     let string;
 
@@ -301,8 +314,6 @@ export default define(class Supposition extends ProofAssertion {
 
     const node = null;
 
-    context = temporaryContext; ///
-
     const supposition = new Supposition(context, string, node, statement, procedureCall);
 
     return supposition;