occam-verify-cli 1.0.768 → 1.0.781

package/src/element/judgement.js

@@ -2,11 +2,10 @@
 
 import { Element } from "occam-languages";
 
-import elements from "../elements";
-
 import { define } from "../elements";
 import { instantiateJudgement } from "../process/instantiate";
 import { reconcile, instantiate } from "../utilities/context";
+import { judgementFromStatementNode } from "../utilities/element";
 import { judgementAssignmentFromJudgement } from "../process/assign";
 
 export default define(class Judgement extends Element {
@@ -21,7 +20,7 @@ export default define(class Judgement extends Element {
     return this.frame;
   }
 
-  getDeclaration() {
+  getAssumption() {
     return this.assumption;
   }
 
@@ -41,8 +40,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 +48,10 @@ export default define(class Judgement extends Element {
     return judgementNodeMatches;
   }
 
+  matchMetavariableNode(metavariableNode) { return this.frame.matchMetavariableNode(metavariableNode); }
+
+  compareMetavariableName(metavariableName) { return this.frame.compareMetavariableName(metavariableName); }
+
   findValidJudgement(context) {
     const judgementNode = this.getJudgementNode(),
           judgement = context.findJudgementByJudgementNode(judgementNode),
@@ -59,7 +60,7 @@ export default define(class Judgement extends Element {
     return validJudgemenet;
   }
 
-  validate(stated, context) {
+  validate(context) {
     let judgement = null;
 
     const judgementString = this.getString();  ///
@@ -76,34 +77,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 +115,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 +123,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 +138,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 +146,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 +184,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 +199,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() {
@@ -236,6 +238,13 @@ export default define(class Judgement extends Element {
       return judgement;
     }, context);
   }
+
+  static fromStatement(statement, context) {
+    const statementNode = statement.getNode(),
+          judgement = judgementFromStatementNode(statementNode, context);
+
+    return judgement;
+  }
 });
 
 function frameFromJudgementNode(judgementNode, context) {
@@ -251,12 +260,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

@@ -10,7 +10,7 @@ import { EMPTY_STRING } from "../constants";
 import { instantiateMetavariable } from "../process/instantiate";
 import { metaTypeFromJSON, metaTypeToMetaTypeJSON } from "../utilities/json";
 import { unifyMetavariable, unifyMetavariableIntrinsically } from "../process/unify";
-import { nameFromMetavariableNode, termFromMetavariableNode, typeFromMetavariableNode } from "../utilities/element";
+import { nameFromMetavariableNode, termFromMetavariableNode, typeFromMetavariableNode, metavariableFromStatementNode } from "../utilities/element";
 
 export default define(class Metavariable extends Element {
   constructor(context, string, node, name, term, type, metaType) {
@@ -58,6 +58,14 @@ export default define(class Metavariable extends Element {
 
   isMetaTypeEqualTo(metaType) { return this.metaType.isEqualTo(metaType); }
 
+  matchMetavariableNode(metavariableNode) {
+    const node = metavariableNode, ///
+          nodeMatches = this.matchNode(node),
+          metavariableNodeMatches = nodeMatches; ///
+
+    return metavariableNodeMatches;
+  }
+
   compare(metavariable) {
     const metavariableName = metavariable.getName(),
           comparesToMetavariableName = this.compareMetavariableName(metavariableName),
@@ -73,14 +81,6 @@ export default define(class Metavariable extends Element {
     return comparesToMetavariableName;
   }
 
-  matchMetavariableNode(metavariableNode) {
-    const node = metavariableNode, ///
-          nodeMatches = this.matchNode(node),
-          metavariableNodeMatches = nodeMatches; ///
-
-    return metavariableNodeMatches;
-  }
-
   verify(context) {
     let verifies = false;
 
@@ -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,  ///
@@ -605,4 +625,11 @@ export default define(class Metavariable extends Element {
       return metavariable;
     }, context);
   }
+
+  static fromStatement(statement, context) {
+    const statementNode = statement.getNode(),
+          metavariable = metavariableFromStatementNode(statementNode, context);
+
+    return metavariable;
+  }
 });

package/src/element/proofAssertion/premise.js

@@ -5,8 +5,7 @@ import ProofAssertion from "../proofAssertion";
 import { define } from "../../elements";
 import { instantiatePremise } from "../../process/instantiate";
 import { procedureCallFromPremiseNode } 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 Premise extends ProofAssertion {
   constructor(context, string, node, statement, procedureCall) {
@@ -26,12 +25,6 @@ export default define(class Premise extends ProofAssertion {
     return premiseNode;
   }
 
-  isStated() {
-    const stated = true; ///
-
-    return stated;
-  }
-
   async verify(context) {
     let verifies = false;
 
@@ -64,29 +57,31 @@ export default define(class Premise extends ProofAssertion {
 
     context.trace(`Validatting the '${premiseString}' premise...`);
 
-    attempt((context) => {
-      const statement = this.getStatement(),
-            procedureCall = this.getProcedureCall();
+    declare((context) => {
+      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) {
-          context.commit(this);
+          if (statementValidates) {
+            context.commit(this);
 
-          validates = true;
+            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) {
+            context.commit(this);
 
-          validates = true;
+            validates = true;
+          }
         }
-      }
+      }, context);
     }, context);
 
     if (validates) {
@@ -96,6 +91,30 @@ export default define(class Premise extends ProofAssertion {
     return validates;
   }
 
+  validateStatement(context) {
+    let statementValidates = false;
+
+    const premiseString = this.getString();
+
+    context.trace(`Validating the '${premiseString}' premise's statsement... `);
+
+    let statement;
+
+    statement = this.getStatement();
+
+    statement = statement.validate(context);  ///
+
+    if (statement !== null) {
+      statementValidates = true;
+    }
+
+    if (statementValidates) {
+      context.debug(`...validated the '${premiseString}' premise's statement. `);
+    }
+
+    return statementValidates;
+  }
+
   validateProcedureCall(context) {
     let procedureCallValidates = false;
 
@@ -266,42 +285,37 @@ export default define(class Premise 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 = "Premise";
 
   static fromJSON(json, context) {
-    const ephemeralContext = ephemeralContextFromJSON(json, context);
+    let premise;
 
-    context = ephemeralContext; ///
+    unserialise((json, context) => {
+      instantiate((context) => {
+        const { string } = json,
+              premiseNode = instantiatePremise(string, context),
+              node = premiseNode,  ///
+              statement = statementFromPremiseNode(premiseNode, context),
+              procedureCall = procedureCallFromPremiseNode(premiseNode, context);
 
-    return instantiate((context) => {
-      const { string } = json,
-            premiseNode = instantiatePremise(string, context),
-            node = premiseNode,  ///
-            statement = statementFromPremiseNode(premiseNode, context),
-            procedureCall = procedureCallFromPremiseNode(premiseNode, context),
-            premise = new Premise(context, string, node, statement, procedureCall);
+        premise = new Premise(context, string, node, statement, procedureCall);
+      }, context);
+    }, json, context);
 
-      return premise;
-    }, context);
+    return premise;
   }
 });