occam-verify-cli 1.0.764 → 1.0.776

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 {
@@ -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, ///

package/src/element/statement.js

@@ -7,7 +7,7 @@ import { define } from "../elements";
 import { unifyStatement } from "../process/unify";
 import { validateStatements } from "../utilities/validation";
 import { instantiateStatement } from "../process/instantiate";
-import { reconcile, instantiate } from "../utilities/context";
+import { join, reconcile, instantiate } from "../utilities/context";
 
 const { backwardsSome } = arrayUtilities;
 
@@ -184,7 +184,7 @@ export default define(class Statement extends Element {
     return frameContained;
   }
 
-  validate(stated, context) {
+  validate(context) {
     let statement = null;
 
     const statementString = this.getString();  ///
@@ -200,7 +200,7 @@ export default define(class Statement extends Element {
     } else {
       const validates = validateStatements.some((validateStatement) => {
         const statement = this, ///
-              statementValidates = validateStatement(statement, stated, context);
+              statementValidates = validateStatement(statement, context);
 
         if (statementValidates) {
           return true;
@@ -244,34 +244,33 @@ export default define(class Statement extends Element {
     return subproofUnifies;
   }
 
-  unifyDeduction(deduction, generalContext, specificContext) {
+  unifyDeduction(deduction, context) {
     let deductionUnifies = false;
 
     const statementString = this.getString(),  ///
           deductionString = deduction.getString(),
-          deductionStatement = deduction.getStatement(),
-          deductionStatementString = deductionStatement.getString();
+          deductionContext = deduction.getContext(),
+          deductionStatement = deduction.getStatement();
 
-    let context;
+    context.trace(`Unifying the '${deductionString}' deduction with the '${statementString}' statement...`);
 
-    context = specificContext;  ///
+    const generalContext = context, ///
+          specificContext = deductionContext;  ///
 
-    context.trace(`Unifying the '${deductionString}' deduction's '${deductionStatementString}' statement with the '${statementString}' statement...`);
+    join((specificContext) => {
+      reconcile((specificContext) => {
+        const deductionStatementUnifies = this.unifyStatement(deductionStatement, generalContext, specificContext);
 
-    context = deduction.getContext();
+        if (deductionStatementUnifies) {
+          specificContext.commit(context);
 
-    specificContext = context;  ///
-
-    reconcile((specificContext) => {
-      const deductionStatementUnfies = this.unifyStatement(deductionStatement, generalContext, specificContext);
-
-      if (deductionStatementUnfies) {
-        deductionUnifies = true;
-      }
-    }, specificContext);
+          deductionUnifies = true;
+        }
+      }, specificContext);
+    }, specificContext, context);
 
     if (deductionUnifies) {
-      context.debug(`...unified the '${deductionString}' deduction's '${deductionStatementString}' statement with the '${statementString}' statement.`);
+      context.debug(`...unified the '${deductionString}' deduction with the '${statementString}' statement.`);
     }
 
     return deductionUnifies;
@@ -336,41 +335,39 @@ export default define(class Statement extends Element {
     return unifiesIndependently;
   }
 
-  unifyTopLevelMetaAssertion(topLevelMetaAssertion, generalContext, specificContext) {
-    let topLevelMetaAssertionUnifies = false;
+  unifyTopLevelMetaAssertion(topLevelMetaAssertion, context) {
+    let topLevelAssertionUnifies = false;
 
-    const context = specificContext,  ///
-          statementString = this.getString(), ///
+    const statementString = this.getString(), ///
           topLevelMetaAssertionString = topLevelMetaAssertion.getString();
 
     context.trace(`Unifying the '${topLevelMetaAssertionString}' top level meta-assertion with the '${statementString}' statement...`);
 
-    const topLevelMetaAssertionUnconditional = topLevelMetaAssertion.isUnconditional();
+    const unconditional = topLevelMetaAssertion.isUnconditional();
 
-    if (topLevelMetaAssertionUnconditional) {
+    if (unconditional) {
       const deduction = topLevelMetaAssertion.getDeduction(),
-            deductionUnifies = this.unifyDeduction(deduction, generalContext, specificContext);
+            deductionUnifies = this.unifyDeduction(deduction, context);
 
       if (deductionUnifies) {
-        topLevelMetaAssertionUnifies = true;
+        topLevelAssertionUnifies = true;
       }
     } else {
       const statementNode = this.getStatementNode(),
             subproofAssertionNode = statementNode.getSubproofAssertionNode();
 
       if (subproofAssertionNode !== null) {
-        const context = generalContext, ///
-              subproofAssertion = context.findAssertionByAssertionNode(subproofAssertionNode);
+        const subproofAssertion = context.findAssertionByAssertionNode(subproofAssertionNode);
 
-        topLevelMetaAssertionUnifies = subproofAssertion.unifyTopLevelMetaAssertion(topLevelMetaAssertion, generalContext, specificContext);
+        topLevelAssertionUnifies = subproofAssertion.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
       }
     }
 
-    if (topLevelMetaAssertionUnifies) {
+    if (topLevelAssertionUnifies) {
       context.debug(`...unified the '${topLevelMetaAssertionString}' top level meta-assertion with the '${statementString}' statement.`);
     }
 
-    return topLevelMetaAssertionUnifies;
+    return topLevelAssertionUnifies;
   }
 
   toJSON() {

package/src/element/substitution/frame.js

@@ -3,8 +3,8 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
-import { instantiate } from "../../utilities/context";
 import { instantiateFrameSubstitution } from "../../process/instantiate";
+import { descend, simplify, instantiate } from "../../utilities/context";
 import { frameSubstitutionStringFromFrameAndMetavariable } from "../../utilities/string";
 import { frameSubstitutionFromStatementNode, frameSubstitutionFromFrameSubstitutionNode } from "../../utilities/element";
 
@@ -73,11 +73,8 @@ export default define(class FrameSubstitution extends Substitution {
   validate(generalContext, specificContext) {
     let frameSubstitution = null;
 
-    const context = this.getContext();
-
-    specificContext = context;  ///
-
-    const frameSubstitutionString = this.getString();  ///
+    const context = specificContext,  ///
+          frameSubstitutionString = this.getString();  ///
 
     context.trace(`Validating the '${frameSubstitutionString}' frame substitution...`);
 
@@ -126,14 +123,15 @@ export default define(class FrameSubstitution extends Substitution {
     const targetFrameSingular = this.targetFrame.isSingular();
 
     if (targetFrameSingular) {
-      const stated = true,
-            tragetFrame = this.targetFrame.validate(stated, context);
+      descend((context) => {
+        const tragetFrame = this.targetFrame.validate(context);
 
-      if (tragetFrame !== null) {
-        this.targetFrame = tragetFrame;
+        if (tragetFrame !== null) {
+          this.targetFrame = tragetFrame;
 
-        targetFrameValidates = true;
-      }
+          targetFrameValidates = true;
+        }
+      }, context);
     } else {
       context.debug(`The '${frameSubstitutionString}' frame substitution's '${targetFrameString}' target frame is not singular.`);
     }
@@ -146,22 +144,23 @@ export default define(class FrameSubstitution extends Substitution {
   }
 
   validateReplacementFrame(generalContext, specificContext) {
-    let replacementFrameValidates;
+    let replacementFrameValidates = false;
 
-    const context = specificContext, ///
+    const context = this.getContext(),
           replacementFrameString = this.replacementFrame.getString(),
           frameSubstitutionString = this.getString();  ///
 
     context.trace(`Validating the '${frameSubstitutionString}' frame substitution's '${replacementFrameString}' replacement frame...`);
 
-    const stated = true,
-          replacementFrame = this.replacementFrame.validate(stated, context);
+    descend((context) => {
+      const replacementFrame = this.replacementFrame.validate(context);
 
-    if (replacementFrame !== null) {
-      this.replacementFrame = replacementFrame;
+      if (replacementFrame !== null) {
+        this.replacementFrame = replacementFrame;
 
-      replacementFrameValidates = true;
-    }
+        replacementFrameValidates = true;
+      }
+    }, context);
 
     if (replacementFrameValidates) {
       context.debug(`...validated the '${frameSubstitutionString}' frame substitution's '${replacementFrameString}' replacement frame.`);
@@ -178,7 +177,7 @@ export default define(class FrameSubstitution extends Substitution {
     const { name } = json;
 
     if (this.name === name) {
-      frameSubstitutionn = instantiate((context) => {
+      instantiate((context) => {
         const { string } = json,
               frameSubstitutionNode = instantiateFrameSubstitution(string, context),
               node = frameSubstitutionNode,  ///
@@ -187,9 +186,7 @@ export default define(class FrameSubstitution extends Substitution {
 
         context = null;
 
-        const frameSubstitutionn = new FrameSubstitution(context, string, node, targetFrame, replacementFrame);
-
-        return frameSubstitutionn;
+        frameSubstitutionn = new FrameSubstitution(context, string, node, targetFrame, replacementFrame);
       }, context);
     }
 
@@ -204,14 +201,19 @@ export default define(class FrameSubstitution extends Substitution {
   }
 
   static fromFrameAndMetavariable(frame, metavariable, context) {
-    return instantiate((context) => {
-      const frameSubstitutionString = frameSubstitutionStringFromFrameAndMetavariable(frame, metavariable),
-            string = frameSubstitutionString,  ///
-            frameSubstitutionNode = instantiateFrameSubstitution(string, context),
-            frameSubstitution = frameSubstitutionFromFrameSubstitutionNode(frameSubstitutionNode, context);
+    let frameSubstitution
+
+    simplify((context) => {
+      instantiate((context) => {
+        const frameSubstitutionString = frameSubstitutionStringFromFrameAndMetavariable(frame, metavariable),
+              string = frameSubstitutionString,  ///
+              frameSubstitutionNode = instantiateFrameSubstitution(string, context);
 
-      return frameSubstitution;
+        frameSubstitution = frameSubstitutionFromFrameSubstitutionNode(frameSubstitutionNode, context);
+      }, context);
     }, context);
+
+    return frameSubstitution;
   }
 });