occam-verify-cli 1.0.768 → 1.0.781

package/src/element/proofAssertion/step.js

@@ -2,12 +2,12 @@
 
 import { asynchronousUtilities } from "occam-languages";
 
+import elements from "../../elements";
 import ProofAssertion from "../proofAssertion";
 
 import { define } from "../../elements";
 import { unifyStatements } from "../../utilities/unification";
-import { attempt, asyncReconcile } from "../../utilities/context";
-import { propertyAssertionFromStatement } from "../../utilities/statement";
+import { derive, attempt, descend, asyncReconcile } from "../../utilities/context";
 
 const { asyncSome } = asynchronousUtilities;
 
@@ -46,18 +46,12 @@ export default define(class Step extends ProofAssertion {
     return qualified;
   }
 
-  isStated() {
-    const qualified = this.isQualified(),
-          stated = qualified; ///
-
-    return stated;
-  }
-
   compareTermAndPropertyRelation(term, propertyRelation, context) {
     let comparesToTermAndPropertyRelation = false;
 
-    const statement = this.getStatement(),
-          propertyAssertion = propertyAssertionFromStatement(statement, context);
+    const { PropertyAssertion } = elements,
+          statement = this.getStatement(),
+          propertyAssertion = PropertyAssertion.fromStatement(statement, context);
 
     if (propertyAssertion !== null) {
       comparesToTermAndPropertyRelation = propertyAssertion.compareTermAndPropertyRelation(term, propertyRelation, context);
@@ -107,22 +101,24 @@ export default define(class Step extends ProofAssertion {
 
     context.trace(`Validating the '${stepString}' step...`);
 
-    attempt((context) => {
-      const statementValidates = this.validateStatement(context);
+    derive((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 satisfiesAssertioValidates = this.validateSatisfiesAssertion(context);
+          if (referenceValidates) {
+            const satisfiesAssertioValidates = this.validateSatisfiesAssertion(context);
 
-          if (satisfiesAssertioValidates) {
-            context.commit(this);
+            if (satisfiesAssertioValidates) {
+              context.commit(this);
 
-            validates = true;
+              validates = true;
+            }
           }
         }
-      }
+      }, context);
     }, context);
 
     if (validates) {
@@ -155,6 +151,30 @@ export default define(class Step extends ProofAssertion {
     return referenceValidates;
   }
 
+  validateStatement(context) {
+    let statementValidates = false;
+
+    const stepString = this.getString();
+
+    context.trace(`Validating the '${stepString}' step's statement... `);
+
+    let statement;
+
+    statement = this.getStatement();
+
+    statement = statement.validate(context);  ///
+
+    if (statement !== null) {
+      statementValidates = true;
+    }
+
+    if (statementValidates) {
+      context.debug(`...validated the '${stepString}' step statement. `);
+    }
+
+    return statementValidates;
+  }
+
   validateSatisfiesAssertion(context) {
     let satisfiesAssertionValidates = true;  ///
 
@@ -164,12 +184,13 @@ export default define(class Step extends ProofAssertion {
 
       context.trace(`Validating the '${stepString}' step's '${satisfiesAssertionString}' satisfies assertion... `);
 
-      const stated = true,
-            satisfiesAssertion = this.satisfiesAssertion.validate(stated, context);
+      descend((context) => {
+        const satisfiesAssertion = this.satisfiesAssertion.validate(context);
 
-      if (satisfiesAssertion === null) {
-        satisfiesAssertionValidates = false;
-      }
+        if (satisfiesAssertion === null) {
+          satisfiesAssertionValidates = false;
+        }
+      }, context);
 
       if (satisfiesAssertionValidates) {
         context.debug(`...validating the '${stepString}' step's '${satisfiesAssertionString}' satisfies assertion. `);

package/src/element/proofAssertion/supposition.js

@@ -5,8 +5,7 @@ import ProofAssertion from "../proofAssertion";
 import { define } from "../../elements";
 import { instantiateSupposition} from "../../process/instantiate";
 import { procedureCallFromSuppositionNode } from "../../utilities/element";
-import { join, attempt, reconcile, instantiate } from "../../utilities/context";
-import { ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../../utilities/json";
+import { join, declare, attempt, reconcile, serialise, unserialise, instantiate } from "../../utilities/context";
 
 export default define(class Supposition extends ProofAssertion {
   constructor(context, string, node, statement, procedureCall) {
@@ -26,12 +25,6 @@ export default define(class Supposition extends ProofAssertion {
     return suppositionNode;
   }
 
-  isStated() {
-    const stated = true; ///
-
-    return stated;
-  }
-
   async verify(context) {
     let verifies = false;
 
@@ -64,29 +57,31 @@ export default define(class Supposition extends ProofAssertion {
 
     context.trace(`Validatting the '${suppositionString}' supposition...`);
 
-    attempt((context) => {
-      const statement = this.getStatement(),
-            procedureCall = this.getProcedureCall();
-
-      if (statement !== null) {
-        const statementValidates = this.validateStatement(context);
+    declare((context) => {
+      attempt((context) => {
+        const statement = this.getStatement(),
+              procedureCall = this.getProcedureCall();
 
-        if (statementValidates) {
-          context.commit(this);
+        if (statement !== null) {
+          const statementValidates = this.validateStatement(context);
 
-          validates = true;
+          if (statementValidates) {
+            validates = true;
+          }
         }
-      }
 
-      if (procedureCall !== null) {
-        const procedureCallValidates = this.validateProcedureCall(context);
+        if (procedureCall !== null) {
+          const procedureCallValidates = this.validateProcedureCall(context);
 
-        if (procedureCallValidates) {
-          context.commit(this);
+          if (procedureCallValidates) {
+            validates = true;
+          }
+        }
 
-          validates = true;
+        if (validates) {
+          context.commit(this);
         }
-      }
+      }, context);
     }, context);
 
     if (validates) {
@@ -96,6 +91,30 @@ export default define(class Supposition extends ProofAssertion {
     return validates;
   }
 
+  validateStatement(context) {
+    let statementValidates = false;
+
+    const suppositionString = this.getString();
+
+    context.trace(`Validating the '${suppositionString}' supposition's statement... `);
+
+    let statement;
+
+    statement = this.getStatement();
+
+    statement = statement.validate(context);  ///
+
+    if (statement !== null) {
+      statementValidates = true;
+    }
+
+    if (statementValidates) {
+      context.debug(`...validated the '${suppositionString}' supposition statement. `);
+    }
+
+    return statementValidates;
+  }
+
   validateProcedureCall(context) {
     let procedureCallValidates = false;
 
@@ -288,42 +307,37 @@ export default define(class Supposition extends ProofAssertion {
   }
 
   toJSON() {
-    let context;
-
-    context = this.getContext();
-
-    const ephemeralContext = context, ///
-          ephemeralContextJSON = ephemeralContextToEphemeralContextJSON(ephemeralContext),
-          contextJSON = ephemeralContextJSON; ///
+    const context = this.getContext();
 
-    context = contextJSON;  ///
+    return serialise((context) => {
+      const string = this.getString(),
+            json = {
+              context,
+              string
+            };
 
-    const string = this.getString(),
-          json = {
-            context,
-            string
-          };
-
-    return json;
+      return json;
+    }, context);
   }
 
   static name = "Supposition";
 
   static fromJSON(json, context) {
-    const ephemeralContext = ephemeralContextFromJSON(json, context);
+    let supposition;
 
-    context = ephemeralContext; ///
+    unserialise((json, context) => {
+      instantiate((context) => {
+        const { string } = json,
+              suppositionNode = instantiateSupposition(string, context),
+              node = suppositionNode,  ///
+              statement = statementFromSuppositionNode(suppositionNode, context),
+              procedureCall = procedureCallFromSuppositionNode(suppositionNode, context);
 
-    return instantiate((context) => {
-      const { string } = json,
-            suppositionNode = instantiateSupposition(string, context),
-            node = suppositionNode,  ///
-            statement = statementFromSuppositionNode(suppositionNode, context),
-            procedureCall = procedureCallFromSuppositionNode(suppositionNode, context),
-            supposition = new Supposition(context, string, node, statement, procedureCall);
+        supposition = new Supposition(context, string, node, statement, procedureCall);
+      }, context);
+    }, json, context);
 
-      return supposition;
-    }, context);
+    return supposition;
   }
 });
 

package/src/element/proofAssertion.js

@@ -51,28 +51,6 @@ export default class ProofAssertion extends Element {
     return comparesToStatement;
   }
 
-  validateStatement(context) {
-    let statementValidates = false;
-
-    const statementString = this.statement.getString(),
-          proofAssertionString = this.getString();  ///
-
-    context.trace(`Validating the '${proofAssertionString}' proof assertion's '${statementString}' statement... `);
-
-    const stated = this.isStated(),
-          statement = this.statement.validate(stated, context);
-
-    if (statement !== null) {
-      statementValidates = true;
-    }
-
-    if (statementValidates) {
-      context.debug(`...validated the '${proofAssertionString}' proof assertion's '${statementString}' statement. `);
-    }
-
-    return statementValidates;
-  }
-
   unifyStatement(statement, generalContext, specificContext) {
     let statementUnifies = false;
 

package/src/element/reference.js

@@ -3,23 +3,27 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { instantiate } from "../utilities/context";
 import { instantiateReference } from "../process/instantiate";
 import { REFERENCE_META_TYPE_NAME } from "../metaTypeNames";
-import { metavariableFromReferenceNode } from "../utilities/element";
-import { unifyMetavariableIntrinsically } from "../process/unify";
+import { serialise, reconcile, unserialise, instantiate } from "../utilities/context";
+import { metavariableFromReferenceNode, topLevelMetaAssertionFromReferenceNode } from "../utilities/element";
 
 export default define(class Reference extends Element {
-  constructor(context, string, node, metavariable) {
+  constructor(context, string, node, metavariable, topLevelMetaAssertion) {
     super(context, string, node);
 
     this.metavariable = metavariable;
+    this.topLevelMetaAssertion = topLevelMetaAssertion;
   }
 
   getMetavariable() {
     return this.metavariable;
   }
 
+  getTopLevelMetaAssertion() {
+    return this.topLevelMetaAssertion;
+  }
+
   getReferenceNode() {
     const node = this.getNode(),
           referenceNode = node; ///
@@ -27,8 +31,6 @@ export default define(class Reference extends Element {
     return referenceNode;
   }
 
-  getName() { return this.metavariable.getName(); }
-
   getMetavariableName() {
     const metavariableName = this.metavariable.getName();
 
@@ -41,6 +43,14 @@ export default define(class Reference extends Element {
     return metavariableNode;
   }
 
+  isEqualTo(reference) {
+    const referenceNode = reference.getNode(),
+          referenceNodeMatches = this.matchReferenceNode(referenceNode),
+          equalTo = referenceNodeMatches;  ///
+
+    return equalTo;
+  }
+
   matchReferenceNode(referenceNode) {
     const node = referenceNode, ///
           nodeMatches = this.matchNode(node),
@@ -49,21 +59,7 @@ export default define(class Reference extends Element {
     return referenceNodeMatches;
   }
 
-  findValidRefernece(context) {
-    const metavariableNode = this.getMetavariableNode(),
-          reference = context.findReferenceByMetavariableNode(metavariableNode),
-          validReference = reference;  ///
-
-    return validReference;
-  }
-
-  isEqualTo(reference) {
-    const referenceNode = reference.getNode(),
-          referenceNodeMatches = this.matchReferenceNode(referenceNode),
-          equalTo = referenceNodeMatches;  ///
-
-    return equalTo;
-  }
+  matchMetavariableNode(metavariableNode) { return this.metavariable.matchMetavariableNode(metavariableNode); }
 
   compareParameter(parameter) {
     let comparesToParamter = false;
@@ -103,7 +99,36 @@ export default define(class Reference extends Element {
 
   compareMetavariableName(metavariableName) { return this.metavariable.compareMetavariableName(metavariableName); }
 
-  matchMetavariableNode(metavariableNode) { return this.metavariable.matchMetavariableNode(metavariableNode); }
+  compareTopLevelMetaAssertion(topLevelMetaAssertion) {
+    let topLevelMetaAssertionCompares = false;
+
+    const context = this.getContext(),
+          referenceString = this.getString(), ///
+          topLevelMetaAssertionString = topLevelMetaAssertion.getString();
+
+    context.trace(`Comparing the '${topLevelMetaAssertionString}' top level meta-assertion to the '${referenceString}' reference...`);
+
+    const label = topLevelMetaAssertion.getLabel(),
+          labelUnifies = this.unifyLabel(label);
+
+    if (labelUnifies) {
+      topLevelMetaAssertionCompares = true;
+    }
+
+    if (topLevelMetaAssertionCompares) {
+      context.trace(`...compared the '${topLevelMetaAssertionString}' top level meta-assertion to the '${referenceString}' reference.`);
+    }
+
+    return topLevelMetaAssertionCompares;
+  }
+
+  findValidRefernece(context) {
+    const metavariableNode = this.getMetavariableNode(),
+          reference = context.findReferenceByMetavariableNode(metavariableNode),
+          validReference = reference;  ///
+
+    return validReference;
+  }
 
   validate(context) {
     let reference = null;
@@ -112,10 +137,10 @@ export default define(class Reference extends Element {
 
     context.trace(`Validating the '${referenceString}' reference...`);
 
-    const validRefernece = this.findValidRefernece(context);
+    const validReference = this.findValidRefernece(context);
 
-    if (validRefernece !== null) {
-      reference = validRefernece; ///
+    if (validReference !== null) {
+      reference = validReference; ///
 
       context.debug(`...the '${referenceString}' reference is already valid.`);
     } else {
@@ -130,7 +155,7 @@ export default define(class Reference extends Element {
 
         if (metaType === null) {
           const reference = this, ///
-                labelPresent = context.isLabelPresentByReference(reference, context);
+                labelPresent = context.isLabelPresentByReference(reference);
 
           if (labelPresent) {
             validates = true;
@@ -170,6 +195,8 @@ export default define(class Reference extends Element {
     const referenceString = this.getString(), ///
           metavariableString = this.metavariable.getString();
 
+    context = this.getContext();
+
     context.trace(`Validating the '${referenceString}' reference's '${metavariableString}' metavariable...'`);
 
     const metavariable = this.metavariable.validate(context);
@@ -187,29 +214,23 @@ export default define(class Reference extends Element {
     return metavariableValidates;
   }
 
-  unifyLabel(label, context) {
-    let labelUnifies;
-
-    const specificContext = context; ///
-
-    context = this.getContext();
-
-    const generalContext = context;  ///
+  unifyLabel(label) {
+    let labelUnifies = false;
 
-    context = specificContext;  ///
-
-    const reference = this, ///
+    const context = label.getContext(),
           labelString = label.getString(),
-          referenceString = reference.getString();
+          referenceString = this.getString(); ///
 
     context.trace(`Unifying the '${labelString}' label with the '${referenceString}' reference...`);
 
-    const labelMetavariable = label.getMetavariable(),
-          generalMetavariable = this.metavariable,  ///
-          specificMetavariable = labelMetavariable, ///
-          metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, generalContext, specificContext);
+    reconcile((context) => {
+      const metavariable = label.getMetavariable(),
+            metavariableUnifies = this.unifyMetavariable(metavariable, context);
 
-    labelUnifies = metavariableUnifiesIntrinsically; ///
+      if (metavariableUnifies) {
+        labelUnifies = true;
+      }
+    }, context);
 
     if (labelUnifies) {
       context.debug(`...unified the '${labelString}' label with the '${referenceString}' reference.`);
@@ -221,22 +242,20 @@ export default define(class Reference extends Element {
   unifyMetavariable(metavariable, context) {
     let metavariableUnifies = false;
 
-    const specificContext = context; ///
+    const referenceString = this.getString(), ///
+          metavariableString = metavariable.getString();
 
-    context = this.getContext();
+    context.trace(`Unifying the '${metavariableString}' metavariable with the '${referenceString}' reference...`);
 
-    const generalContext = context;  ///
+    const specificContext = context;  ///
 
-    context = specificContext;  ///
+    context = this.getContext();
 
-    const referenceString = this.getString(), ///
-          metavariableString = metavariable.getString();
+    const generalContext = context; ///
 
-    context.trace(`Unifying the '${metavariableString}' metavariable with the '${referenceString}' reference...`);
+    context = specificContext;  ///
 
-    const generalMetavariable = this.metavariable,  ///
-          specificMetavariable = metavariable, ///
-          metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, generalContext, specificContext);
+    const metavariableUnifiesIntrinsically = this.metavariable.unifyMetavariableIntrinsically(metavariable, generalContext, specificContext);
 
     if (metavariableUnifiesIntrinsically) {
       metavariableUnifies = true;
@@ -249,52 +268,72 @@ export default define(class Reference extends Element {
     return metavariableUnifies;
   }
 
-  compareTopLevelMetaAssertion(topLevelMetaAssertion, context) {
-    let topLevelMetaAssertionCompares = false;
+  unifyTopLevelMetaAssertion(topLevelMetaAssertion, context) {
+    let topLevelMetaAssertionUUnifies = false;
 
-    const reference = this, ///
-          referenceString = reference.getString(),
+    const label = topLevelMetaAssertion.getLabel(),
+          referenceString = this.getString(), ///
           topLevelMetaAssertionString = topLevelMetaAssertion.getString();
 
-    context.trace(`Comparing the '${topLevelMetaAssertionString}' top level meta-assertion to the '${referenceString}' reference...`);
+    context.trace(`Unifying the '${topLevelMetaAssertionString}' top level meta-assertion with the '${referenceString}' reference...`);
 
-    const label = topLevelMetaAssertion.getLabel(),
-          labelUnifies = this.unifyLabel(label, context);
+    const specificContext = context;  ///
 
-    if (labelUnifies) {
-      topLevelMetaAssertionCompares = true;
-    }
+    context = label.getContext();
 
-    if (topLevelMetaAssertionCompares) {
-      context.trace(`...compared the '${topLevelMetaAssertionString}' top level meta-assertion to the '${referenceString}' reference.`);
+    reconcile((context) => {
+      const metavariable = label.getMetavariable(),
+            metavariableUnifies = this.unifyMetavariable(metavariable, context);
+
+      if (metavariableUnifies) {
+        this.topLevelMetaAssertion = topLevelMetaAssertion;
+
+        context.commit(specificContext);
+
+        topLevelMetaAssertionUUnifies = true;
+      }
+    }, context);
+
+    context = specificContext;  ///
+
+    if (topLevelMetaAssertionUUnifies) {
+      context.debug(`...unified the '${topLevelMetaAssertionString}' top level meta-assertion with the '${referenceString}' reference.`);
     }
 
-    return topLevelMetaAssertionCompares;
+    return topLevelMetaAssertionUUnifies;
   }
 
   toJSON() {
-    const string = this.getString(),
-          json = {
-            string
-          };
+    const context = this.getContext();
+
+    return serialise((context) => {
+      const string = this.getString(),
+            json = {
+              context,
+              string
+            };
 
-    return json;
+      return json;
+    }, context);
   }
 
   static name = "Reference";
 
   static fromJSON(json, context) {
-    return instantiate((context) => {
-      const { string } = json,
-            referenceNode = instantiateReference(string, context),
-            node = referenceNode,  ///
-            metavariable = metavariableFromReferenceNode(referenceNode, context);
+    let reference;
 
-      context = null;
+    unserialise((json, context) => {
+      instantiate((context) => {
+        const { string } = json,
+              referenceNode = instantiateReference(string, context),
+              node = referenceNode,  ///
+              metavariable = metavariableFromReferenceNode(referenceNode, context),
+              topLevelMetaAssertion = topLevelMetaAssertionFromReferenceNode(referenceNode, context);
 
-      const reference = new Reference(context, string, node, metavariable);
+        reference = new Reference(context, string, node, metavariable, topLevelMetaAssertion);
+      }, context);
+    }, json, context);
 
-      return reference;
-    }, context);
+    return reference;
   }
 });

package/src/element/signature.js

@@ -3,6 +3,8 @@
 import { Element } from "occam-languages";
 import { arrayUtilities } from "necessary";
 
+import elements from "../elements";
+
 import { define } from "../elements";
 import { instantiate } from "../utilities/context";
 import { instantiateSignature } from "../process/instantiate";
@@ -125,9 +127,10 @@ export default define(class Signature extends Element {
           termsA = this.terms,  ///
           termsB = terms, ///
           matches = match(termsA, termsB, (termA, termB) => {
-            const term = termB, ///
+            const { Variable } = elements,
+                  term = termB, ///
                   context = generalContext, ///
-                  variable = variableFromTerm(term, context);
+                  variable = Variable.fromTerm(term, context);
 
             if (variable !== null) {
               const term = termA, ///