occam-verify-cli 1.0.956 → 1.0.973

package/src/element/proofAssertion/supposition.js

@@ -6,7 +6,7 @@ import { define } from "../../elements";
 import { instantiateSupposition} from "../../process/instantiate";
 import { procedureCallFromSuppositionNode } 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 Supposition extends ProofAssertion {
   constructor(context, string, node, breakPoint, statement, procedureCall) {
@@ -26,6 +26,31 @@ export default define(class Supposition extends ProofAssertion {
     return suppositionNode;
   }
 
+  getStatementNode() {
+    const suppositionNode = this.getSuppositionNode(),
+          statementNode = suppositionNode.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 Supposition 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 '${suppositionString}' supposition because it is nonsense.`);
     }
@@ -58,31 +85,29 @@ export default define(class Supposition extends ProofAssertion {
 
     context.trace(`Validatting the '${suppositionString}' supposition...`);
 
-    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) {
@@ -166,77 +191,60 @@ export default define(class Supposition extends ProofAssertion {
 
     context.trace(`Unifying the '${suppositionString}' supposition independently...`);
 
-    const statement = this.getStatement(),
-          procedureCall = this.getProcedureCall();
-
-    if (statement !== null) {
-      const specificContext = context;  ///
-
-      context = this.getContext();
+    await reconcile(async (context) => {
+      const statement = this.getStatement(),
+            procedureCall = this.getProcedureCall();
 
-      const generalContext = context; ///
+      if (statement !== null) {
+        const suppositionContext = this.getContext(),
+              generalContext = suppositionContext,  ///
+              specificContext = context,  ///
+              statementUnifiesIndependently = statement.unifyIndependently(generalContext, specificContext);
 
-      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 '${suppositionString}' supposition independenly.`);
+      context.debug(`...unified the '${suppositionString}' supposition independently.`);
     }
 
     return unifiesIndependently;
   }
 
-  unifySubproofOrProofAssertion(subproofOrProofAssertion, context) {
-    let subproofOrProofAssertionUnifies;
+  unifySubproof(subproof, context) {
+    let subproofUnifies = false;
 
     const suppositionString = this.getString(), ///
-          subproofOrProofAssertionString = subproofOrProofAssertion.getString();
-
-    context.trace(`Unifying the '${subproofOrProofAssertionString}' subproof or proof assertion with the '${suppositionString}' supposition...`);
+          subproofString = subproof.getString();
 
-    const subproofOrProofAssertionProofAssertion = subproofOrProofAssertion.isProofAssertion(),
-                                                   proofAssertion = subproofOrProofAssertionProofAssertion ?
-                                                                      subproofOrProofAssertion :
-                                                                        null,
-                                                   subproof = subproofOrProofAssertionProofAssertion ?
-                                                                null :
-                                                                  subproofOrProofAssertion;
-
-    if (proofAssertion !== null) {
-      const proofAssertionUnifies = this.unifyProofAssertion(proofAssertion, context);
+    context.trace(`Unifying the '${subproofString}' subproof with the '${suppositionString}' supposition...`);
 
-      if (proofAssertionUnifies) {
-        subproofOrProofAssertionUnifies = true;
-      }
-    }
+    const subproofAssertion = this.findSubproofAssertion();
 
-    if (subproof !== null) {
-      const subproofUnifies = this.unifySubproof(subproof, context);
+    if (subproofAssertion !== null) {
+      const suppositionContext = this.getContext(),
+            generalContext = suppositionContext, ///
+            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 '${suppositionString}' supposition.`);
+    if (subproofUnifies) {
+      context.debug(`...unified the '${subproofString}' subproof with the '${suppositionString}' supposition.`);
     }
 
-    return subproofOrProofAssertionUnifies;
+    return subproofUnifies;
   }
 
   unifyProofAssertion(proofAssertion, context) {
@@ -248,22 +256,20 @@ export default define(class Supposition extends ProofAssertion {
     context.trace(`Unifying the '${proofAssertionString}' proof assertion with the '${suppositionString}' supposition...`);
 
     const proofAssertionContext = proofAssertion.getContext(),
-          suppositionContext = this.getContext(),
+          suppositionContext = this.getContext(), ///
           generalContext = suppositionContext, ///
-          specificContext = proofAssertionContext;
+          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 '${suppositionString}' supposition.`);
@@ -272,39 +278,49 @@ export default define(class Supposition extends ProofAssertion {
     return proofAssertionUnifies;
   }
 
-  unifySubproof(subproof, context) {
-    let subproofUnifies = false;
-
-    const subproofString = subproof.getString(),
-          suppositionString = this.getString();
+  unifySubproofOrProofAssertion(subproofOrProofAssertion, context) {
+    let subproofOrProofAssertionUnifies;
 
-    context.trace(`Unifying the '${subproofString}' subproof with the '${suppositionString}' supposition...`);
+    const suppositionString = this.getString(), ///
+          subproofOrProofAssertionString = subproofOrProofAssertion.getString();
 
-    const statement = this.getStatement();
+    context.trace(`Unifying the '${subproofOrProofAssertionString}' subproof or proof assertion with the '${suppositionString}' supposition...`);
 
-    if (statement !== null) {
-      const statementNode = statement.getNode(),
-            subproofAssertionNode = statementNode.getSubproofAssertionNode();
+    const subproofOrProofAssertionProofAssertion = subproofOrProofAssertion.isProofAssertion(),
+                                                   proofAssertion = subproofOrProofAssertionProofAssertion ?
+                                                                      subproofOrProofAssertion :
+                                                                        null,
+                                                   subproof = subproofOrProofAssertionProofAssertion ?
+                                                               null :
+                                                                 subproofOrProofAssertion;
 
-      if (subproofAssertionNode !== null) {
-        const specificContext = context;  ///
+    reconcile((context) => {
+      if (proofAssertion !== null) {
+        const proofAssertionUnifies = this.unifyProofAssertion(proofAssertion, context);
 
-        context = this.getContext();
+        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 '${suppositionString}' supposition.`);
+    if (subproofOrProofAssertionUnifies) {
+      context.debug(`...unified the '${subproofOrProofAssertionString}' subproof or proof assertion with the '${suppositionString}' supposition.`);
     }
 
-    return subproofUnifies;
+    return subproofOrProofAssertionUnifies;
   }
 
   toJSON() {
@@ -336,8 +352,8 @@ export default define(class Supposition extends ProofAssertion {
   static fromJSON(json, context) {
     let supposition;
 
-    unserialise((json, context) => {
-      instantiate((context) => {
+    instantiate((context) => {
+      unserialise((json, context) => {
         const { string } = json,
               suppositionNode = instantiateSupposition(string, context),
               node = suppositionNode,  ///
@@ -346,8 +362,8 @@ export default define(class Supposition extends ProofAssertion {
               procedureCall = procedureCallFromSuppositionNode(suppositionNode, context);
 
         supposition = new Supposition(context, string, node, breakPoint, statement, procedureCall);
-      }, context);
-    }, json, context);
+      }, json, context);
+    }, context);
 
     return supposition;
   }

package/src/element/proofAssertion.js

@@ -60,12 +60,12 @@ export default class ProofAssertion extends Element {
             statementString = statement.getString(),
             proofAssertionString = this.getString();  ///
 
-      context.trace(`Unifying the '${statementString}' statement with the '${proofAssertionString}' proof assertion...`);
+      context.trace(`Unifying the '${statementString}' statement with the '${proofAssertionString}' proof assertion's statement...`);
 
       statementUnifies = this.statement.unifyStatement(statement, generalContext, specificContext);
 
       if (statementUnifies) {
-        context.debug(`...unified the '${statementString}' statement with the '${proofAssertionString}' proof assertion.`);
+        context.debug(`...unified the '${statementString}' statement with the '${proofAssertionString}' proof assertion's statement.`);
       }
     }
 

package/src/element/reference.js

@@ -6,7 +6,7 @@ import { define } from "../elements";
 import { instantiateReference } from "../process/instantiate";
 import { REFERENCE_META_TYPE_NAME } from "../metaTypeNames";
 import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
-import { join, posit, ablate, attempt, serialise, reconcile, unserialise, instantiate } from "../utilities/context";
+import { ablate, attempt, serialise, reconcile, unserialise, instantiate } from "../utilities/context";
 import { referenceFromReferenceNode, metavariableFromReferenceNode, topLevelMetaAssertionFromReferenceNode } from "../utilities/element";
 
 export default define(class Reference extends Element {
@@ -38,6 +38,8 @@ export default define(class Reference extends Element {
     return metavariableNode;
   }
 
+  getMetaType() { return this.metavariable.getMetaType(); }
+
   isEqualTo(reference) {
     const referenceNode = reference.getNode(),
           referenceNodeMatches = this.matchReferenceNode(referenceNode),
@@ -125,7 +127,7 @@ export default define(class Reference extends Element {
 
       context.debug(`...the '${referenceString}' reference is already valid.`);
     } else {
-      const specificContext = context;  ///
+      const temporaryContext = context; ///
 
       context = this.getContext();
 
@@ -133,21 +135,14 @@ export default define(class Reference extends Element {
         const metavariableValidates = this.validateMetavariable(context);
 
         if (metavariableValidates) {
-          const referenceMetaTypeName = REFERENCE_META_TYPE_NAME,
-                referenceMetaType = context.findMetaTypeByMetaTypeName(referenceMetaTypeName),
-                metaType = this.metavariable.getMetaType();
+          const metaType = this.metavariable.getMetaType();
 
           if (metaType === null) {
-            const reference = this, ///
-                  labelPresent = context.isLabelPresentByReference(reference, context);
-
-            if (labelPresent) {
-              validates = true;
-            } else {
-              context.debug(`There is no label for the '${referenceString}' reference.`);
-            }
+            validates = true;
           } else {
-            const metavariableMetaTypeEqualToReferenceMetaType = this.metavariable.isMetaTypeEqualTo(referenceMetaType);
+            const referenceMetaTypeName = REFERENCE_META_TYPE_NAME,
+                  referenceMetaType = context.findMetaTypeByMetaTypeName(referenceMetaTypeName),
+                  metavariableMetaTypeEqualToReferenceMetaType = this.metavariable.isMetaTypeEqualTo(referenceMetaType);
 
             if (metavariableMetaTypeEqualToReferenceMetaType) {
               validates = true;
@@ -166,7 +161,7 @@ export default define(class Reference extends Element {
         }
       }, context);
 
-      context = specificContext;  ///
+      context = temporaryContext; ///
 
       if (validates) {
         reference = this;  ///
@@ -212,11 +207,9 @@ export default define(class Reference extends Element {
 
     context.trace(`Unifying the '${labelString}' label with the '${referenceString}' reference...`);
 
-    const generalContext = context; ///
-
-    context = label.getContext();
-
-    const specificContext = context;  ///
+    const labelContext = label.getContext(),
+          generalContext = context, ///
+          specificContext = labelContext;  ///
 
     reconcile((specificContext) => {
       const metavariable = label.getMetavariable(),
@@ -260,33 +253,31 @@ export default define(class Reference extends Element {
     let topLevelMetaAssertionUUnifies = false;
 
     const label = topLevelMetaAssertion.getLabel(),
-          labelContext = label.getContext(),
           referenceString = this.getString(), ///
-          referenceContext = this.getContext(), ///
           topLevelMetaAssertionString = topLevelMetaAssertion.getString();
 
-    context.trace(`Unifying the '${topLevelMetaAssertionString}' top level meta-assertion with the '${referenceString}' reference...`);
+    context.trace(`Unifying the '${topLevelMetaAssertionString}' top level meta-assertion's label with the '${referenceString}' reference...`);
 
-    const generalContext = referenceContext, ///
+    const labelContext = label.getContext(),
+          referenceContext = this.getContext(), ///
+          generalContext = referenceContext, ///
           specificContext = labelContext; ///
 
-    join((specificContext) => {
-      reconcile((specificContext) => {
-        const metavariable = label.getMetavariable(),
-              metavariableUnifies = this.unifyMetavariable(metavariable, generalContext, specificContext);
+    reconcile((specificContext) => {
+      const metavariable = label.getMetavariable(),
+            metavariableUnifies = this.unifyMetavariable(metavariable, generalContext, specificContext);
 
-        if (metavariableUnifies) {
-          this.topLevelMetaAssertion = topLevelMetaAssertion;
+      if (metavariableUnifies) {
+        this.topLevelMetaAssertion = topLevelMetaAssertion;
 
-          specificContext.commit(context);
+        specificContext.commit(context);
 
-          topLevelMetaAssertionUUnifies = true;
-        }
-      }, specificContext);
-    }, specificContext, context);
+        topLevelMetaAssertionUUnifies = true;
+      }
+    }, specificContext);
 
     if (topLevelMetaAssertionUUnifies) {
-      context.debug(`...unified the '${topLevelMetaAssertionString}' top level meta-assertion with the '${referenceString}' reference.`);
+      context.debug(`...unified the '${topLevelMetaAssertionString}' top level meta-assertion's label with the '${referenceString}' reference.`);
     }
 
     return topLevelMetaAssertionUUnifies;
@@ -321,8 +312,8 @@ export default define(class Reference extends Element {
   static fromJSON(json, context) {
     let reference;
 
-    unserialise((json, context) => {
-      instantiate((context) => {
+    instantiate((context) => {
+      unserialise((json, context) => {
         const { string } = json,
               referenceNode = instantiateReference(string, context),
               node = referenceNode,  ///
@@ -331,8 +322,8 @@ export default define(class Reference extends Element {
               topLevelMetaAssertion = topLevelMetaAssertionFromReferenceNode(referenceNode, context);
 
         reference = new Reference(context, string, node, breakPoint, metavariable, topLevelMetaAssertion);
-      }, context);
-    }, json, context);
+      }, json, context);
+    }, context);
 
     return reference;
   }
@@ -340,14 +331,12 @@ export default define(class Reference extends Element {
   static fromReferenceString(referenceString, context) {
     let reference;
 
-    posit((context) => {
-      ablate((context) => {
-        instantiate((context) => {
-          const string = referenceString,  ///
-                referenceNode = instantiateReference(string, context);
+    ablate((context) => {
+      instantiate((context) => {
+        const string = referenceString,  ///
+              referenceNode = instantiateReference(string, context);
 
-          reference = referenceFromReferenceNode(referenceNode, context);
-        }, context);
+        reference = referenceFromReferenceNode(referenceNode, context);
       }, context);
     }, context);