occam-verify-cli 1.0.956 → 1.0.973

package/src/element/label.js

@@ -6,7 +6,7 @@ import { define } from "../elements";
 import { instantiateLabel } from "../process/instantiate";
 import { labelFromLabelNode, metavariableFromLabelNode } from "../utilities/element";
 import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
-import { posit, ablate, attempt, serialise, unserialise, instantiate } from "../utilities/context";
+import { attempt, ablate, serialise, unserialise, instantiate } from "../utilities/context";
 
 export default define(class Label extends Element {
   constructor(context, string, node, breakPoint, metavariable) {
@@ -154,8 +154,8 @@ export default define(class Label extends Element {
   static fromJSON(json, context) {
     let label;
 
-    unserialise((json, context) => {
-      instantiate((context) => {
+    instantiate((context) => {
+      unserialise((json, context) => {
         const { string } = json,
               labelNode = instantiateLabel(string, context),
               node = labelNode, ///
@@ -163,8 +163,8 @@ export default define(class Label extends Element {
               metavariable = metavariableFromLabelNode(labelNode, context);
 
         label = new Label(context, string, node, breakPoint, metavariable);
-      }, context);
-    }, json, context);
+      }, json, context);
+    }, context);
 
     return label;
   }
@@ -172,14 +172,12 @@ export default define(class Label extends Element {
   static fromLabelString(labelString, context) {
     let label;
 
-    posit((context) => {
-      ablate((context) => {
-        instantiate((context) => {
-          const string = labelString,  ///
-                labelNode = instantiateLabel(string, context);
+    ablate((context) => {
+      instantiate((context) => {
+        const string = labelString,  ///
+              labelNode = instantiateLabel(string, context);
 
-          label = labelFromLabelNode(labelNode, context);
-        }, context);
+        label = labelFromLabelNode(labelNode, context);
       }, context);
     }, context);
 

package/src/element/proofAssertion/premise.js

@@ -6,7 +6,7 @@ import { define } from "../../elements";
 import { instantiatePremise } from "../../process/instantiate";
 import { procedureCallFromPremiseNode } from "../../utilities/element";
 import { breakPointFromJSON, breakPointToBreakPointJSON } from "../../utilities/breakPoint";
-import { join, declare, attempt, reconcile, serialise, unserialise, instantiate } from "../../utilities/context";
+import { declare, attempt, reconcile, serialise, unserialise, instantiate } from "../../utilities/context";
 
 export default define(class Premise extends ProofAssertion {
   constructor(context, string, node, breakPoint, statement, procedureCall) {
@@ -26,6 +26,31 @@ export default define(class Premise extends ProofAssertion {
     return premiseNode;
   }
 
+  getStatementNode() {
+    const premiseNode = this.getPremiseNode(),
+          statementNode = premiseNode.getStatementNode();
+
+    return statementNode;
+  }
+
+  findSubproofAssertion() {
+    let subproofAssertion = null;
+
+    const statementNode = this.getStatementNode();
+
+    if (statementNode !== null) {
+      const subproofAssertionNode = statementNode.getSubproofAssertionNode();
+
+      if (subproofAssertionNode !== null) {
+        const context = this.getContext();
+
+        subproofAssertion = context.findAssertionByAssertionNode(subproofAssertionNode);
+      }
+    }
+
+    return subproofAssertion;
+  }
+
   async verify(context) {
     let verifies = false;
 
@@ -39,11 +64,13 @@ export default define(class Premise extends ProofAssertion {
           procedureCall = this.getProcedureCall();
 
     if ((statement !== null) || (procedureCall !== null)) {
-      const validates = this.validate(context);
+      declare((context) => {
+        const validates = this.validate(context);
 
-      if (validates) {
-        verifies = true;
-      }
+        if (validates) {
+          verifies = true;
+        }
+      }, context);
     } else {
       context.debug(`Unable to validate the '${premiseString}' premise because it is nonsense.`);
     }
@@ -58,31 +85,29 @@ export default define(class Premise extends ProofAssertion {
 
     context.trace(`Validatting the '${premiseString}' premise...`);
 
-    declare((context) => {
-      attempt((context) => {
-        const statement = this.getStatement(),
-              procedureCall = this.getProcedureCall();
+    attempt((context) => {
+      const statement = this.getStatement(),
+            procedureCall = this.getProcedureCall();
 
-        if (statement !== null) {
-          const statementValidates = this.validateStatement(context);
+      if (statement !== null) {
+        const statementValidates = this.validateStatement(context);
 
-          if (statementValidates) {
-            validates = true;
-          }
+        if (statementValidates) {
+          validates = true;
         }
+      }
 
-        if (procedureCall !== null) {
-          const procedureCallValidates = this.validateProcedureCall(context);
+      if (procedureCall !== null) {
+        const procedureCallValidates = this.validateProcedureCall(context);
 
-          if (procedureCallValidates) {
-            validates = true;
-          }
+        if (procedureCallValidates) {
+          validates = true;
         }
+      }
 
-        if (validates) {
-          this.commit(context);
-        }
-      }, context);
+      if (validates) {
+        this.commit(context);
+      }
     }, context);
 
     if (validates) {
@@ -143,77 +168,60 @@ export default define(class Premise extends ProofAssertion {
 
     context.trace(`Unifying the '${premiseString}' premise independently...`);
 
-    const statement = this.getStatement(),
-          procedureCall = this.getProcedureCall();
+    await reconcile(async (context) => {
+      const statement = this.getStatement(),
+            procedureCall = this.getProcedureCall();
 
-    if (statement !== null) {
-      const specificContext = context;  ///
+      if (statement !== null) {
+        const premiseContext = this.getContext(),
+              generalContext = premiseContext,  ///
+              specificContext = context,  ///
+              statementUnifiesIndependently = statement.unifyIndependently(generalContext, specificContext);
 
-      context = this.getContext();
-
-      const generalContext = context; ///
-
-      context = specificContext;  ///
-
-      const statementUnifiesIndependently = statement.unifyIndependently(generalContext, specificContext);
-
-      if (statementUnifiesIndependently) {
-        unifiesIndependently = true;
+        if (statementUnifiesIndependently) {
+          unifiesIndependently = true;
+        }
       }
-    }
 
-    if (procedureCall !== null) {
-      const procedureCallResolvedIndependently = await procedureCall.unifyIndependently(context);
+      if (procedureCall !== null) {
+        const procedureCallResolvedIndependently = await procedureCall.unifyIndependently(context);
 
-      if (procedureCallResolvedIndependently) {
-        unifiesIndependently = true;
+        if (procedureCallResolvedIndependently) {
+          unifiesIndependently = true;
+        }
       }
-    }
+    }, context);
 
     if (unifiesIndependently) {
-      context.debug(`...unified the '${premiseString}' premise independenly.`);
+      context.debug(`...unified the '${premiseString}' premise independently.`);
     }
 
     return unifiesIndependently;
   }
 
-  unifySubproofOrProofAssertion(subproofOrProofAssertion, context) {
-    let subproofOrProofAssertionUnifies;
+  unifySubproof(subproof, context) {
+    let subproofUnifies = false;
 
     const premiseString = this.getString(), ///
-          subproofOrProofAssertionString = subproofOrProofAssertion.getString();
+          subproofString = subproof.getString();
 
-    context.trace(`Unifying the '${subproofOrProofAssertionString}' subproof or proof assertion with the '${premiseString}' premise...`);
+    context.trace(`Unifying the '${subproofString}' subproof with the '${premiseString}' premise...`);
 
-    const subproofOrProofAssertionProofAssertion = subproofOrProofAssertion.isProofAssertion(),
-                                                   proofAssertion = subproofOrProofAssertionProofAssertion ?
-                                                                      subproofOrProofAssertion :
-                                                                        null,
-                                                   subproof = subproofOrProofAssertionProofAssertion ?
-                                                                 null :
-                                                                   subproofOrProofAssertion;
-
-    if (proofAssertion !== null) {
-      const proofAssertionUnifies = this.unifyProofAssertion(proofAssertion, context);
-
-      if (proofAssertionUnifies) {
-        subproofOrProofAssertionUnifies = true;
-      }
-    }
+    const subproofAssertion = this.findSubproofAssertion();
 
-    if (subproof !== null) {
-      const subproofUnifies = this.unifySubproof(subproof, context);
+    if (subproofAssertion !== null) {
+      const premiseContext = this.getContext(),
+            generalContext = premiseContext, ///
+            spsecfiicContext = context; ///
 
-      if (subproofUnifies) {
-        subproofOrProofAssertionUnifies = true;
-      }
+      subproofUnifies = subproofAssertion.unifySubproof(subproof, generalContext, spsecfiicContext);
     }
 
-    if (subproofOrProofAssertionUnifies) {
-      context.debug(`...unified the '${subproofOrProofAssertionString}' subproof or proof assertion with the '${premiseString}' premise.`);
+    if (subproofUnifies) {
+      context.debug(`...unified the '${subproofString}' subproof with the '${premiseString}' premise.`);
     }
 
-    return subproofOrProofAssertionUnifies;
+    return subproofUnifies;
   }
 
   unifyProofAssertion(proofAssertion, context) {
@@ -229,18 +237,16 @@ export default define(class Premise extends ProofAssertion {
           generalContext = premiseContext, ///
           specificContext = proofAssertionContext;  ///
 
-    join((specificContext) => {
-      reconcile((specificContext) => {
-        const statement = proofAssertion.getStatement(),
-              statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
+    reconcile((specificContext) => {
+      const statement = proofAssertion.getStatement(),
+            statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
 
-        if (statementUnifies) {
-          specificContext.commit(context);
+      if (statementUnifies) {
+        specificContext.commit(context);
 
-          proofAssertionUnifies = true;
-        }
-      }, specificContext);
-    }, specificContext, context);
+        proofAssertionUnifies = true;
+      }
+    }, specificContext);
 
     if (proofAssertionUnifies) {
       context.debug(`...unified the '${proofAssertionString}' proof assertion with the '${premiseString}' premise.`);
@@ -249,39 +255,49 @@ export default define(class Premise extends ProofAssertion {
     return proofAssertionUnifies;
   }
 
-  unifySubproof(subproof, context) {
-    let subproofUnifies = false;
+  unifySubproofOrProofAssertion(subproofOrProofAssertion, context) {
+    let subproofOrProofAssertionUnifies;
 
     const premiseString = this.getString(), ///
-          subproofString = subproof.getString();
-
-    context.trace(`Unifying the '${subproofString}' subproof with the '${premiseString}' premise...`);
-
-    const statement = this.getStatement();
-
-    if (statement !== null) {
-      const statementNode = statement.getNode(),
-            subproofAssertionNode = statementNode.getSubproofAssertionNode();
+          subproofOrProofAssertionString = subproofOrProofAssertion.getString();
 
-      if (subproofAssertionNode !== null) {
-        const specificContext = context;  ///
+    context.trace(`Unifying the '${subproofOrProofAssertionString}' subproof or proof assertion with the '${premiseString}' premise...`);
 
-        context = this.getContext();
+    const subproofOrProofAssertionProofAssertion = subproofOrProofAssertion.isProofAssertion(),
+          proofAssertion = subproofOrProofAssertionProofAssertion ?
+                             subproofOrProofAssertion :
+                               null,
+          subproof = subproofOrProofAssertionProofAssertion ?
+                       null :
+                         subproofOrProofAssertion;
+
+    reconcile((context) => {
+      if (proofAssertion !== null) {
+        const proofAssertionUnifies = this.unifyProofAssertion(proofAssertion, context);
+
+        if (proofAssertionUnifies) {
+          subproofOrProofAssertionUnifies = true;
+        }
+      }
 
-        const generalContext = context, ///
-              subproofAssertion = context.findAssertionByAssertionNode(subproofAssertionNode);
+      if (subproof !== null) {
+        const subproofUnifies = this.unifySubproof(subproof, context);
 
-        context = specificContext;  ///
+        if (subproofUnifies) {
+          subproofOrProofAssertionUnifies = true;
+        }
+      }
 
-        subproofUnifies = subproofAssertion.unifySubproof(subproof, generalContext, specificContext);
+      if (subproofOrProofAssertionUnifies) {
+        context.commit();
       }
-    }
+    }, context);
 
-    if (subproofUnifies) {
-      context.debug(`...unified the '${subproofString}' subproof with the '${premiseString}' premise.`);
+    if (subproofOrProofAssertionUnifies) {
+      context.debug(`...unified the '${subproofOrProofAssertionString}' subproof or proof assertion with the '${premiseString}' premise.`);
     }
 
-    return subproofUnifies;
+    return subproofOrProofAssertionUnifies;
   }
 
   toJSON() {
@@ -313,8 +329,8 @@ export default define(class Premise extends ProofAssertion {
   static fromJSON(json, context) {
     let premise;
 
-    unserialise((json, context) => {
-      instantiate((context) => {
+    instantiate((context) => {
+      unserialise((json, context) => {
         const { string } = json,
               premiseNode = instantiatePremise(string, context),
               node = premiseNode,  ///
@@ -323,8 +339,8 @@ export default define(class Premise extends ProofAssertion {
               procedureCall = procedureCallFromPremiseNode(premiseNode, context);
 
         premise = new Premise(context, string, node, breakPoint, statement, procedureCall);
-      }, context);
-    }, json, context);
+      }, json, context);
+    }, context);
 
     return premise;
   }

package/src/element/proofAssertion/step.js

@@ -7,7 +7,7 @@ import elements from "../../elements";
 import ProofAssertion from "../proofAssertion";
 
 import { define } from "../../elements";
-import { unifySteps } from "../../utilities/unification";
+import { unifySteps } from "../../process/unification";
 import { derive, declare, attempt, reconcile } from "../../utilities/context";
 
 const { asyncSome } = asynchronousUtilities,
@@ -98,17 +98,22 @@ export default define(class Step extends ProofAssertion {
     const statement = this.getStatement();
 
     if (statement !== null) {
-      const validates = this.validate(context);
+      const qualified = this.isQualified(),
+            stated = qualified; ///
 
-      if (validates) {
-        context = this.getContext();
+      await (stated ? declare : derive)(async (context) => {
+        const validates = this.validate(context);
+
+        if (validates) {
+          context = this.getContext();
 
-        const unifiies = await this.unify(context);
+          const unifiies = await this.unify(context);
 
-        if (unifiies) {
-          verifies = true;
+          if (unifiies) {
+            verifies = true;
+          }
         }
-      }
+      }, context)
     } else {
       context.debug(`Unable to verify the '${stepString}' step because it is nonsense.`);
     }
@@ -127,30 +132,25 @@ export default define(class Step extends ProofAssertion {
 
     context.trace(`Validating the '${stepString}' step...`);
 
-    const qualified = this.isQualified(),
-          stated = qualified; ///
-
-    (stated ? declare : derive)((context) => {
-      attempt((context) => {
-        const statementValidates = this.validateStatement(context);
+    attempt((context) => {
+      const statementValidates = this.validateStatement(context);
 
-        if (statementValidates) {
-          const referenceValidates = this.validateReference(context);
+      if (statementValidates) {
+        const referenceValidates = this.validateReference(context);
 
-          if (referenceValidates) {
-            const signatureAssertionValidates = this.validateSignatureAssertion(context);
+        if (referenceValidates) {
+          const signatureAssertionValidates = this.validateSignatureAssertion(context);
 
-            if (signatureAssertionValidates) {
-              validates = true;
-            }
+          if (signatureAssertionValidates) {
+            validates = true;
           }
         }
+      }
 
-        if (validates) {
-          this.commit(context);
-        }
-      }, context);
-    }, context)
+      if (validates) {
+        this.commit(context);
+      }
+    }, context);
 
     if (validates) {
       context.debug(`...validated the '${stepString}' step.`);
@@ -247,13 +247,13 @@ export default define(class Step extends ProofAssertion {
     const step = this;  ///
 
     await asyncSome(unifySteps, async (unifyStep) => {
-      let statementUnifies;
+      let stepUnifies;
 
       await reconcile(async (context) => {
-        statementUnifies = await unifyStep(step, context);
+        stepUnifies = await unifyStep(step, context);
       }, context);
 
-      if (statementUnifies) {
+      if (stepUnifies) {
         unifies = true;
 
         return true;