occam-verify-cli 1.0.457 → 1.0.472

package/src/element/proofAssertion/premise.js

@@ -1,10 +1,10 @@
 "use strict";
 
 import ProofAssertion from "../proofAssertion";
-import TransientContext from "../../context/transient";
 import assignAssignments from "../../process/assign";
 
 import { define } from "../../elements";
+import { attempt, synthetically } from "../../utilities/context";
 import { termsFromJSON,
          framesFromJSON,
          termsToTermsJSON,
@@ -25,55 +25,59 @@ export default define(class Premise extends ProofAssertion {
     return this.procedureCall;
   }
 
-  verify(context) {
-    let verifies = false;
+  isStated() {
+    const stated = true; ///
 
-    const transientContext = TransientContext.fromNothing(context);
+    return stated;
+  }
 
-    context = transientContext; ///
+  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);
     }
 
@@ -131,7 +135,7 @@ export default define(class Premise extends ProofAssertion {
                         null :
                           subproofOrProofAssertion;
 
-    substitutions.snapshot();
+    substitutions.snapshot(context);
 
     if (subproof !== null) {
       const subproofUnifies = this.unifySubproof(subproof, substitutions, context);
@@ -154,7 +158,7 @@ export default define(class Premise extends ProofAssertion {
     }
 
     subproofOrProofAssertionUnifies ?
-      substitutions.continue() :
+      substitutions.continue(context) :
         substitutions.rollback(context);
 
     return subproofOrProofAssertionUnifies;
@@ -163,23 +167,26 @@ export default define(class Premise extends ProofAssertion {
   unifyProofAssertion(proofAssertion, substitutions, context) {
     let proofAssertionUnifies = false;
 
-    const premiseString = this.getString(),
+    const premiseString = this.getString(), ///
           proofAssertionString = proofAssertion.getString();
 
     context.trace(`Unifying the '${proofAssertionString}' proof assertion with the '${premiseString}' premise...`);
 
+    const specificContext = context;  ///
+
     context = this.getContext();
 
     const generalContext = context; ///
 
-    context = proofAssertion.getContext();
-
-    const specificContext = context;  ///
-
     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;
@@ -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),
-          transientContext = TransientContext.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 = transientContext; ///
-
     const premise = new Premise(context, string, node, statement, procedureCall);
 
     return premise;

package/src/element/proofAssertion/step.js

@@ -2,10 +2,10 @@
 
 import elements from "../../elements";
 import ProofAssertion from "../proofAssertion";
-import TransientContext from "../../context/transient";
 
 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 {
@@ -56,13 +56,9 @@ export default define(class Step extends ProofAssertion {
     return comparesToTermAndPropertyRelation;
   }
 
-  verify(substitutions, assignments, context) {
+  verify(assignments, context) {
     let verifies = false;
 
-    const transientContext = TransientContext.fromNothing(context);
-
-    context = transientContext; ///
-
     const node = this.getNode(),
           stepString = this.getString(); ///
 
@@ -70,38 +66,47 @@ 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 referenceValidates = this.validateReference(context);
+    if (statement !== null) {
+      attempt((context) => {
+        const referenceValidates = this.validateReference(context);
 
-      if (referenceValidates) {
-        const satisfiesAssertioVeriries = this.verifySatisfiesAssertion(context);
+        if (referenceValidates) {
+          const satisfiesAssertioValidates = this.validateSatisfiesAssertion(context);
+
+          if (satisfiesAssertioValidates) {
+            const statementValidates = this.validateStatement(assignments, context);
+
+            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 (satisfiesAssertioVeriries) {
-          const stated = this.isStated(),
-                statementValidates = statement.validate(assignments, stated, context);
+                        if (statementUnifies) {
+                          this.setContext(context);
 
-          if (statementValidates) {
-            const statementUnifies = unifyStatements.some((unifyStatement) => {
-              const statementUnifies = unifyStatement(statement, this.reference, this.satisfiesAssertion, substitutions, context);
+                          return true;
+                        }
+                      });
+
+                      return statementUnifies;
+                    }, context);
 
               if (statementUnifies) {
-                return true;
+                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) {
-      this.setContext(context);
-
       context.debug(`...verified the '${stepString}' step.`, node);
     }
 
@@ -112,41 +117,41 @@ export default define(class Step extends ProofAssertion {
     let referenceValidates = true;
 
     if (this.reference !== null) {
-      const node = this.getNode(),
-            stepString = this.getString();
+      const stepString = this.getString(),  ///
+            referenceString = this.reference.getString();
 
-      context.trace(`Validating the '${stepString}' step's reference... `, node);
+      context.trace(`Validating the '${stepString}' step's '${referenceString}' reference... `);
 
       referenceValidates = this.reference.validate(context);
 
       if (referenceValidates) {
-        context.debug(`...validating the '${stepString}' step's reference. `, node);
+        context.debug(`...validated the '${stepString}' step's '${referenceString}' reference. `);
       }
     }
 
     return referenceValidates;
   }
 
-  verifySatisfiesAssertion(context) {
-    let satisfiesAssertionVerifies = true;  ///
+  validateSatisfiesAssertion(context) {
+    let satisfiesAssertionValidates = true;  ///
 
     if (this.satisfiesAssertion !== null) {
-      const node = this.getNode(),
-            stepString = this.getString();  ///
+      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... `);
 
       const stated = true,
             assignments = null;
 
-      satisfiesAssertionVerifies = this.satisfiesAssertion.validate(assignments, stated, context);
+      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) {
@@ -163,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/proofAssertion/supposition.js

@@ -1,11 +1,18 @@
 "use strict";
 
 import ProofAssertion from "../proofAssertion";
-import TransientContext from "../../context/transient";
 import assignAssignments from "../../process/assign";
 
 import { define } from "../../elements";
-import { termsFromJSON, framesFromJSON, statementFromJSON, procedureCallFromJSON, termsToTermsJSON, framesToFramesJSON, statementToStatementJSON, procedureCallToProcedureCallJSON } from "../../utilities/json";
+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) {
@@ -18,55 +25,59 @@ export default define(class Supposition extends ProofAssertion {
     return this.procedureCall;
   }
 
-  verify(context) {
-    let verifies = false;
+  isStated() {
+    const stated = true; ///
 
-    const transientContext = TransientContext.fromNothing(context);
+    return stated;
+  }
 
-    context = transientContext; ///
+  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 (procedureCallVerifies) {
-          verifies = true;
+          if (procedureCallValidates) {
+            this.setContext(context);
+
+            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,7 +87,7 @@ export default define(class Supposition extends ProofAssertion {
   unifyIndependently(substitutions, context) {
     let unifiesIndependently = false;
 
-    const suppositionString = this.getString();
+    const suppositionString = this.getString(); ///
 
     context.trace(`Unifying the '${suppositionString}' supposition independently...`);
 
@@ -124,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);
@@ -147,7 +158,7 @@ export default define(class Supposition extends ProofAssertion {
     }
 
     subproofOrProofAssertionUnifies ?
-      substitutions.continue() :
+      substitutions.continue(context) :
         substitutions.rollback(context);
 
     return subproofOrProofAssertionUnifies;
@@ -156,23 +167,26 @@ export default define(class Supposition extends ProofAssertion {
   unifyProofAssertion(proofAssertion, substitutions, context) {
     let proofAssertionUnifies = false;
 
-    const suppositionString = this.getString(),
+    const suppositionString = this.getString(), ///
           proofAssertionString = proofAssertion.getString();
 
     context.trace(`Unifying the '${proofAssertionString}' proof assertion with the '${suppositionString}' supposition...`);
 
+    const specificContext = context;  ///
+
     context = this.getContext();
 
     const generalContext = context; ///
 
-    context = proofAssertion.getContext();
-
-    const specificContext = context;  ///
-
     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;
@@ -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),
-          transientContext = TransientContext.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 = transientContext; ///
-
     const supposition = new Supposition(context, string, node, statement, procedureCall);
 
     return supposition;

package/src/element/proofAssertion.js

@@ -25,7 +25,7 @@ export default class ProofAssertion extends Element {
     let comparesToStatement = false;
 
     const statementString = statement.getString(),
-          proofAssertionString = this.getString();
+          proofAssertionString = this.getString();  ///
 
     context.trace(`Comparing the '${statementString}' statement to the '${proofAssertionString}' proof assertion...`);
 
@@ -46,21 +46,39 @@ export default class ProofAssertion extends Element {
     return comparesToStatement;
   }
 
+  validateStatement(assignments, context) {
+    let statementValidates;
+
+    const statementString = this.statement.getString(),
+          proofAssertionString = this.getString();  ///
+
+    context.trace(`Validating the '${proofAssertionString}' proof assertion's '${statementString}' statement... `);
+
+    const stated = this.isStated();
+
+    statementValidates = this.statement.validate(assignments, stated, context);
+
+    if (statementValidates) {
+      context.debug(`...validated the '${proofAssertionString}' proof assertion's '${statementString}' reference. `);
+    }
+
+    return statementValidates;
+  }
+
   unifyStatement(statement, substitutions, generalContext, specificContext) {
     let statementUnifies = false;
 
     if (this.statement !== null) {
-      const node = this.getNode(),
-            context = specificContext, ///
+      const context = specificContext, ///
             statementString = statement.getString(),
             proorAssertionString = this.getString();  ///
 
-      context.trace(`Unifying the '${statementString}' statement with the '${proorAssertionString}' proof assertion...`, node);
+      context.trace(`Unifying the '${statementString}' statement with the '${proorAssertionString}' proof assertion...`);
 
       statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
 
       if (statementUnifies) {
-        context.debug(`...unified the '${statementString}' statement with the '${proorAssertionString}' proof assertion.`, node);
+        context.debug(`...unified the '${statementString}' statement with the '${proorAssertionString}' proof assertion.`);
       }
     }
 

package/src/element/propertyRelation.js

@@ -23,7 +23,7 @@ export default define(class PropertyRelation extends Element {
   verify(context) {
     let verifies = false;
 
-    const propertyRelationString = this.string; ///
+    const propertyRelationString = this.getString(); ///
 
     context.trace(`Verifying the '${propertyRelationString}' property relation...`);