occam-verify-cli 1.0.768 → 1.0.776

package/src/element/frame.js

@@ -3,11 +3,11 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { instantiate } from "../utilities/context";
 import { instantiateFrame } from "../process/instantiate";
 import { FRAME_META_TYPE_NAME } from "../metaTypeNames";
 import { metavariableFromFrameNode } from "../utilities/element";
-import { assumptionsStringFromAssumptions } from "../utilities/string";
+import { descend, reconcile, instantiate } from "../utilities/context";
+import { assumptionsStringFromAssumptions, metaLevelSubstitutionsStringFromMetaLevelSubstitutions } from "../utilities/string";
 
 export default define(class Frame extends Element {
   constructor(context, string, node, assumptions, metavariable) {
@@ -97,17 +97,17 @@ export default define(class Frame extends Element {
     return comparesToParamter;
   }
 
-  compareSubstitution(substitution, context) {
-    let comparesToSubstitution = false;
+  compareMetaLevelSubstitution(metaLevelSubstitution, context) {
+    let comparesToMetaLevelSubstitution = false;
 
     const frameString = this.getString(),  ///
-          substitutionString = substitution.getString();
+          metaLevelSubstitutioString = metaLevelSubstitution.getString();
 
-    context.trace(`Comparing the '${frameString}' frame to the '${substitutionString}' substitution...`);
+    context.trace(`Comparing the '${frameString}' frame to the '${metaLevelSubstitutioString}' meta-level substitutio...`);
 
-    if (!comparesToSubstitution) {
-      comparesToSubstitution = this.assumptions.some((assumption) => {
-        const assumptionComparesToSubstitution = assumption.compareSubstitution(substitution, context);
+    if (!comparesToMetaLevelSubstitution) {
+      comparesToMetaLevelSubstitution = this.assumptions.some((assumption) => {
+        const assumptionComparesToSubstitution = assumption.compareMetaLevelSubstitution(metaLevelSubstitution, context);
 
         if (assumptionComparesToSubstitution) {
           return true;
@@ -115,34 +115,34 @@ export default define(class Frame extends Element {
       });
     }
 
-    if (comparesToSubstitution) {
-      context.debug(`...compared the the '${frameString}' frame to the '${substitutionString}' substitutions.`);
+    if (comparesToMetaLevelSubstitution) {
+      context.debug(`...compared the the '${frameString}' frame to the '${metaLevelSubstitutioString}' meta-Level-substituution.`);
     }
 
-    return comparesToSubstitution;
+    return comparesToMetaLevelSubstitution;
   }
 
-  compareSubstitutions(substitutions, context) {
-    let comparesToSubstitutions;
+  compareMetaLevelSubstitutions(metaLevelSubstitutions, context) {
+    let comparesToMetaLevelSubstitutions;
 
     const frameString = this.getString(),  ///
-          substitutionsString = substitutions.asString();
+          metaLevelSubstitutionsString = metaLevelSubstitutionsStringFromMetaLevelSubstitutions(metaLevelSubstitutions);
 
-    context.trace(`Comparing the '${frameString}' frame to the '${substitutionsString}' substitutions...`);
+    context.trace(`Comparing the '${frameString}' frame to the '${metaLevelSubstitutionsString}' meta-level substitutio...`);
 
-    comparesToSubstitutions = substitutions.every((substitution) => {
-      const compaaresToSubstitution = this.compareSubstitution(substitution, context);
+    comparesToMetaLevelSubstitutions = metaLevelSubstitutions.every((metaLevelSubstitution) => {
+      const compaaresToMetaLevelSubstitution = this.compareMetaLevelSubstitution(metaLevelSubstitution, context);
 
-      if (compaaresToSubstitution) {
+      if (compaaresToMetaLevelSubstitution) {
         return true;
       }
     });
 
-    if (comparesToSubstitutions) {
-      context.debug(`...compared the '${frameString}' frame to the '${substitutionsString}' substitutions.`);
+    if (comparesToMetaLevelSubstitutions) {
+      context.debug(`...compared the '${frameString}' frame to the '${metaLevelSubstitutionsString}' metaLevelSubstitutions.`);
     }
 
-    return comparesToSubstitutions;
+    return comparesToMetaLevelSubstitutions;
   }
 
   compareMetavariableName(metavariableName) {
@@ -163,7 +163,7 @@ export default define(class Frame extends Element {
     return comparesToMetavariableName;
   }
 
-  validate(stated, context) {
+  validate(context) {
     let frame = null;
 
     const frameString = this.getString();  ///
@@ -180,12 +180,14 @@ export default define(class Frame extends Element {
     } else {
       let validates = false;
 
-      const metavariableValidates = this.validatMetavariable(stated, context);
+      const metavariableValidates = this.validatMetavariable(context);
 
       if (metavariableValidates) {
-        const assumptionsValidate = this.validateAssumptions(stated, context);
+        const assumptionsValidate = this.validateAssumptions(context);
 
         if (assumptionsValidate) {
+          const stated = context.isStated();
+
           let validatesWhenStated = false,
               validatesWhenDerived = false;
 
@@ -251,17 +253,25 @@ export default define(class Frame extends Element {
     return validatesWhenDerived;
   }
 
-  validateAssumption(assumption, context) {
-    let assumptionValidates;
+  validateAssumption(assumption, assumptions, context) {
+    let assumptionValidates = false;
 
     const frameString = this.getString(), ///
           assumptionstring = assumption.getString();
 
     context.trace(`Validating the '${frameString}' frame's '${assumptionstring}' assumption.`);
 
-    const stated = true;  ///
+    reconcile((context) => {
+      descend((context) => {
+        assumption = assumption.validate(context);  ///
 
-    assumptionValidates = assumption.validate(stated, context);
+        if (assumption !== null) {
+          assumptions.push(assumption);
+
+          assumptionValidates = true;
+        }
+      }, context);
+    }, context);
 
     if (assumptionValidates) {
       context.debug(`...validated the '${frameString}' frame's '${assumptionstring}' assumption.`);
@@ -270,7 +280,7 @@ export default define(class Frame extends Element {
     return assumptionValidates;
   }
 
-  validateAssumptions(stated, context) {
+  validateAssumptions(context) {
     let assumptionsValidate;
 
     const singular = this.isSingular();
@@ -284,11 +294,9 @@ export default define(class Frame extends Element {
       const assumptions = [];
 
       assumptionsValidate = this.assumptions.every((assumption) => {
-        const assumptionValidates = this.validateAssumption(assumption, context);
+        const assumptionValidates = this.validateAssumption(assumption, assumptions, context);
 
         if (assumptionValidates) {
-          assumptions.push(assumption);
-
           return true;
         }
       });
@@ -305,7 +313,7 @@ export default define(class Frame extends Element {
     return assumptionsValidate;
   }
 
-  validatMetavariable(stated, context) {
+  validatMetavariable(context) {
     let metavariableValidates = false;
 
     const singular = this.isSingular();

package/src/element/hypothesis.js

@@ -3,7 +3,7 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import {instantiate} from "../utilities/context";
+import {descend, instantiate} from "../utilities/context";
 import { instantiateHypothesis } from "../process/instantiate";
 import { statementFromHypothesisNode } from "../utilities/element";
 
@@ -61,12 +61,13 @@ export default define(class Hypothesis extends Element {
     } else if (this.statement !== null) {
       let statementValidates = false;
 
-      const stated = true,
-            statement = this.statement.validate(stated, context);
+      descend((context) => {
+        const statement = this.statement.validate(context);
 
-      if (statement !== null) {
-        statementValidates = true;
-      }
+        if (statement !== null) {
+          statementValidates = true;
+        }
+      }, context);
 
       if (statementValidates) {
         const subproofOrProofAssertion = this;  ///

package/src/element/judgement.js

@@ -2,8 +2,6 @@
 
 import { Element } from "occam-languages";
 
-import elements from "../elements";
-
 import { define } from "../elements";
 import { instantiateJudgement } from "../process/instantiate";
 import { reconcile, instantiate } from "../utilities/context";
@@ -41,8 +39,6 @@ export default define(class Judgement extends Element {
 
   getMetavariable() { return this.frame.getMetavariable(); }
 
-  compareMetavariableName(metavariableName) { return this.frame.compareMetavariableName(metavariableName); }
-
   matchJudgementNode(judgementNode) {
     const node = judgementNode, ///
           nodeMatches = this.matchNode(node),
@@ -51,6 +47,8 @@ export default define(class Judgement extends Element {
     return judgementNodeMatches;
   }
 
+  compareMetavariableName(metavariableName) { return this.frame.compareMetavariableName(metavariableName); }
+
   findValidJudgement(context) {
     const judgementNode = this.getJudgementNode(),
           judgement = context.findJudgementByJudgementNode(judgementNode),
@@ -59,7 +57,7 @@ export default define(class Judgement extends Element {
     return validJudgemenet;
   }
 
-  validate(stated, context) {
+  validate(context) {
     let judgement = null;
 
     const judgementString = this.getString();  ///
@@ -76,34 +74,36 @@ export default define(class Judgement extends Element {
       let validates = false;
 
       reconcile((context) => {
+        const frameValidates = this.validateFrame(context);
 
-      }, context);
-
-      const frameValidates = this.validateFrame(stated, context);
+        if (frameValidates) {
+          const assumptionValidates = this.validateAssumption(context);
 
-      if (frameValidates) {
-        const assumptionValidates = this.validateAssumption(stated, context);
+          if (assumptionValidates) {
+            const stated = context.isStated();
 
-        if (assumptionValidates) {
-          let validatesWhenStated = false,
-              validatesWhenDerived = false;
+            let validatesWhenStated = false,
+                validatesWhenDerived = false;
 
-          if (stated) {
-            validatesWhenStated = this.validateWhenStated(context);
-          } else {
-            validatesWhenDerived = this.validateWhenDerived(context);
-          }
+            if (stated) {
+              validatesWhenStated = this.validateWhenStated(context);
+            } else {
+              validatesWhenDerived = this.validateWhenDerived(context);
+            }
 
-          if (validatesWhenStated || validatesWhenDerived) {
-            validates = true;
+            if (validatesWhenStated || validatesWhenDerived) {
+              validates = true;
+            }
           }
         }
-      }
+      }, context);
 
       if (validates) {
         judgement = this; ///
 
-        context.addJudgement(judgement)
+        this.assign(context);
+
+        context.addJudgement(judgement);
 
         context.debug(`...validated the '${judgementString}' judgement.`);
       }
@@ -112,7 +112,7 @@ export default define(class Judgement extends Element {
     return judgement;
   }
 
-  validateFrame(stated, context) {
+  validateFrame(context) {
     let frameValidates = false;
 
     const frameString = this.frame.getString(),
@@ -120,7 +120,7 @@ export default define(class Judgement extends Element {
 
     context.trace(`Validating the '${judgementString}' judgement's '${frameString}' frame...`);
 
-    const frame = this.frame.validate(stated, context);
+    const frame = this.frame.validate(context);
 
     if (frame !== null) {
       this.frame = frame;
@@ -135,7 +135,7 @@ export default define(class Judgement extends Element {
     return frameValidates;
   }
 
-  validateAssumption(stated, context) {
+  validateAssumption(context) {
     let assumptionValidates = false;
 
     const assumptionString = this.assumption.getString(),
@@ -143,7 +143,7 @@ export default define(class Judgement extends Element {
 
     context.trace(`Validating the '${judgementString}' judgement's '${assumptionString}' assumption...`);
 
-    const assumption = this.assumption.validate(stated, context);
+    const assumption = this.assumption.validate(context);
 
     if (assumption !== null) {
       this.assumption = assumption;
@@ -181,11 +181,9 @@ export default define(class Judgement extends Element {
 
     context.trace(`Validating the '${judgementString}' derived judgement...`);
 
-    const metavariable = this.assumption.getMetavariable(),
-          reference = referenceFromMetavariable(metavariable, context),
-          topLevelMetaAssertion = context.findTopLevelMetaAssertionByReference(reference, context),
-          substitutions = topLevelMetaAssertion.getSubstitutions(),
-          frameComparesToSubstitutions = this.frame.compareSubstitutions(substitutions, context);
+    const topLevelMetaAssertion = this.assumption.getTopLevelMetaAssertion(),
+          metaLevelSubstitutions = topLevelMetaAssertion.getMetaLevelSubstitutions(),
+          frameComparesToSubstitutions = this.frame.compareMetaLevelSubstitutions(metaLevelSubstitutions, context);
 
     if (frameComparesToSubstitutions) {
       validatesWhenDerived = true;
@@ -198,16 +196,17 @@ export default define(class Judgement extends Element {
     return validatesWhenDerived;
   }
 
-  assign(stated, context) {
+  assign(context) {
+    const stated = context.isStated();
+
     if (!stated) {
       return;
     }
 
     const judgement = this, ///
-          judgementAssignment = judgementAssignmentFromJudgement(judgement, context),
-          assignment = judgementAssignment; ///
+          judgementAssignment = judgementAssignmentFromJudgement(judgement, context);
 
-    context.addAssignment(assignment);
+    context.addAssignment(judgementAssignment);
   }
 
   toJSON() {
@@ -251,12 +250,3 @@ function assumptionFromJudgementNode(judgementNode, context) {
 
   return assumption;
 }
-
-function referenceFromMetavariable(metavariable, context) {
-  const { Reference } = elements,
-        metavariableNode = metavariable.getNode(),
-        reference = Reference.fromMetavariableNode(metavariableNode, context);
-
-  return reference;
-}
-

package/src/element/label.js

@@ -4,9 +4,8 @@ import { Element } from "occam-languages";
 
 import { define } from "../elements";
 import { instantiateLabel } from "../process/instantiate";
-import { attempt, instantiate } from "../utilities/context";
 import { metavariableFromLabelNode } from "../utilities/element";
-import { ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../utilities/json";
+import { attempt, serialise, unserialise, instantiate } from "../utilities/context";
 
 export default define(class Label extends Element {
   constructor(context, string, node, metavariable) {
@@ -38,10 +37,6 @@ export default define(class Label extends Element {
     return labelNodeMatches;
   }
 
-  compareMetavariable(metavariable) { return this.metavariable.compare(metavariable); }
-
-  compareMetavariableName(metavariableName) { return this.metavariable.compareMetavariableName(metavariableName); }
-
   compareReference(reference) {
     const metavariable = reference.getMetavariable(),
           metavariableComparesToMetavariable = this.compareMetavariable(metavariable),
@@ -50,6 +45,10 @@ export default define(class Label extends Element {
     return comparesToReference;
   }
 
+  compareMetavariable(metavariable) { return this.metavariable.compare(metavariable); }
+
+  compareMetavariableName(metavariableName) { return this.metavariable.compareMetavariableName(metavariableName); }
+
   verify() {
     let verifies = false;
 
@@ -127,40 +126,35 @@ export default define(class Label extends Element {
   }
 
   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 = "Label";
 
   static fromJSON(json, context) {
-    const ephemeralContext = ephemeralContextFromJSON(json, context);
+    let label;
 
-    context = ephemeralContext; ///
+    unserialise((json, context) => {
+      instantiate((context) => {
+        const { string } = json,
+              labelNode = instantiateLabel(string, context),
+              node = labelNode, ///
+              metavariable = metavariableFromLabelNode(labelNode, context);
 
-    return instantiate((context) => {
-      const { string } = json,
-            labelNode = instantiateLabel(string, context),
-            node = labelNode, ///
-            metavariable = metavariableFromLabelNode(labelNode, context),
-            label = new Label(context, string, node, metavariable);
+        label = new Label(context, string, node, metavariable);
+      }, context);
+    }, json, context);
 
-      return label;
-    }, context);
+    return label;
   }
 });

package/src/element/metavariable.js

@@ -486,11 +486,11 @@ export default define(class Metavariable extends Element {
         if (frameSingular) {
           const frameMetavariableName = frame.getMetavariableName(),
                 frameMetavariable = context.findMetavariableByMetavariableName(frameMetavariableName),
-                generalMetavariable = this, ///
-                specificMetavariable = frameMetavariable, ///
-                metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, generalContext, specificContext);
+                frameMetavariableUnifiesIntrinsically = this.unifyMetavariableIntrinsically(frameMetavariable, generalContext, specificContext);
 
-          frameMetavariableUnifies = metavariableUnifiesIntrinsically; ///
+          if (frameMetavariableUnifiesIntrinsically) {
+            frameMetavariableUnifies = true;
+          }
         }
       }
     }
@@ -522,11 +522,11 @@ export default define(class Metavariable extends Element {
         referenceMetavariableUnifies = true;
       } else {
         const referenceMetavariable = reference.getMetavariable(),
-              generalMetavariable = this, ///
-              specificMetavariable = referenceMetavariable, ///
-              metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, generalContext, specificContext);
+              referenceMetavariableUnifiesIntrinsically = this.unifyMetavariableIntrinsically(referenceMetavariable, generalContext, specificContext);
 
-        referenceMetavariableUnifies = metavariableUnifiesIntrinsically; ///
+        if (referenceMetavariableUnifiesIntrinsically) {
+          referenceMetavariableUnifies = true;
+        }
       }
     }
 
@@ -561,11 +561,11 @@ export default define(class Metavariable extends Element {
         if (statementSingular) {
           const statementMetavariableName = statement.getMetavariableName(),
                 statementMetavariable = context.findMetavariableByMetavariableName(statementMetavariableName),
-                generalMetavariable = this, ///
-                specificMetavariable = statementMetavariable, ///
-                metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, generalContext, specificContext);
+                statementMetavariableUnifiesIntrinsically = this.unifyMetavariableIntrinsically(statementMetavariable, generalContext, specificContext);
 
-          statementMetavariableUnifies = metavariableUnifiesIntrinsically; ///
+          if (statementMetavariableUnifiesIntrinsically) {
+            statementMetavariableUnifies = true;
+          }
         }
       }
     }
@@ -577,6 +577,26 @@ export default define(class Metavariable extends Element {
     return statementMetavariableUnifies;
   }
 
+  unifyMetavariableIntrinsically(metavariable, generalContext, specificContext) {
+    let metavariableUnifiesIntrinsically;
+
+    const context = specificContext,  ///
+          generalMetavariable = this, ///
+          specificMetavariable = metavariable,
+          generalMetavariableString = generalMetavariable.getString(),  ///
+          specificMetavariableString = specificMetavariable.getString();
+
+    context.trace(`Unifying the '${specificMetavariableString}' metavariable with the '${generalMetavariableString}' metavariable intrinsically...`);
+
+    metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, generalContext, specificContext);
+
+    if (metavariableUnifiesIntrinsically) {
+      context.debug(`...unified the '${specificMetavariableString}' metavariable with the '${generalMetavariableString}' metavariable intrinsically.`);
+    }
+
+    return metavariableUnifiesIntrinsically;
+  }
+
   toJSON() {
     const metaTypeJSON = metaTypeToMetaTypeJSON(this.metaType),
           metaType = metaTypeJSON,  ///