occam-verify-cli 1.0.792 → 1.0.799

package/src/element/assumption.js

@@ -5,9 +5,7 @@ import { Element } from "occam-languages";
 import { define } from "../elements";
 import { unifyAssumption } from "../process/unify";
 import { instantiateAssumption } from "../process/instantiate";
-import { assumptionFromAssumptionNode } from "../utilities/element";
-import { join, descend, reconcile, instantiate } from "../utilities/context";
-import { assumptionStringFromStatementAndReference } from "../utilities/string";
+import { join, reconcile, instantiate } from "../utilities/context";
 
 export default define(class Assumption extends Element {
   constructor(context, string, node, reference, statement) {
@@ -44,12 +42,6 @@ export default define(class Assumption extends Element {
     return equalTo;
   }
 
-  isMetaLevel() {
-    const metaLevel = (this.context !== null);
-
-    return metaLevel;
-  }
-
   matchAssumptionNode(assumptionNode) {
     const node = assumptionNode, ///
           nodeMatches = this.matchNode(node),
@@ -58,9 +50,9 @@ export default define(class Assumption extends Element {
     return assumptionNodeMatches;
   }
 
-  findValidAssumption(context, metaLevel = false) {
+  findValidAssumption(context) {
     const assumptionNode = this.getAssumptionNode(),
-          assumption = context.findAssumptionByAssumptionNode(assumptionNode, metaLevel),
+          assumption = context.findAssumptionByAssumptionNode(assumptionNode),
           validAssumption = assumption;  ///
 
     return validAssumption;
@@ -69,17 +61,11 @@ export default define(class Assumption extends Element {
   validate(context) {
     let assumption = null;
 
-    const metaLevel = this.isMetaLevel();
-
-    if (metaLevel) {
-      context = this.getContext();
-    }
-
     const assumptionString = this.getString();  ///
 
     context.trace(`Validating the '${assumptionString}' assumption...`);
 
-    const validAssumption = this.findValidAssumption(context, metaLevel);
+    const validAssumption = this.findValidAssumption(context);
 
     if (validAssumption) {
       assumption = validAssumption; ///
@@ -114,7 +100,7 @@ export default define(class Assumption extends Element {
       if (validates) {
         assumption = this;  ///
 
-        context.addAssumption(assumption, metaLevel);
+        context.addAssumption(assumption);
 
         context.debug(`...validated the '${assumptionString}' assumption.`);
       }
@@ -170,13 +156,11 @@ export default define(class Assumption extends Element {
 
     context.trace(`Validating the '${assumptionString}' assumption's '${statementString}' statement...`);
 
-    descend((context) => {
-      const statement = this.statement.validate(context);
+    const statement = this.statement.validate(context);
 
-      if (statement !== null) {
-        statementValidates = true;
-      }
-    }, context);
+    if (statement !== null) {
+      statementValidates = true;
+    }
 
     if (statementValidates) {
       context.debug(`...validated the '${assumptionString}' assumption's '${statementString}' statement.`);
@@ -207,6 +191,7 @@ export default define(class Assumption extends Element {
     const assumptionString = this.getString();  ///
 
     context.trace(`Validating the '${assumptionString}' derived assumption...`);
+
     const topLevelMetaAssertion = this.getTopLevelMetaAssertion();
 
     if (topLevelMetaAssertion !== null) {
@@ -222,37 +207,43 @@ export default define(class Assumption extends Element {
     return validatesWhenDerived;
   }
 
-  unifyAssumption(assumption, generalContext, specificContext) {
-    let assumptionUnifies;
+  unifyMetaLevelAssumption(metaLevelAssumption, context) {
+    let metaLevelAssumptionUnifies;
 
-    const context = specificContext,  ///
-          generalAssumption = this, ///
-          specificAssumption = assumption,  ///
-          generalAssumptionString = generalAssumption.getString(),
-          specificAssumptionString = specificAssumption.getString();
-
-    context.trace(`Unifying the '${specificAssumptionString}' assumption with the '${generalAssumptionString}' assumption...`);
+    const assumptionString = this.getString(),  ///
+          metaLevelAssumptionString = metaLevelAssumption.getString();
 
-    const assumptionContext = assumption.getContext();
+    context.trace(`Unifying the '${metaLevelAssumptionString}' meta-level assumption with the '${assumptionString}' assumption...`);
 
-    specificContext = assumptionContext;  ///
+    const metaLevelAssumptionContext = metaLevelAssumption.getContext(),
+          assumptionContext = this.getContext(),
+          generalContext = assumptionContext, ///
+          specificContext = metaLevelAssumptionContext;  ///
 
     join((specificContext) => {
       reconcile((specificContext) => {
-        assumptionUnifies = unifyAssumption(generalAssumption, specificAssumption, generalContext, specificContext);
+        const generalAssumption = this, ///
+              specificAssumption = metaLevelAssumption,  ///
+              assumptionUnifies = unifyAssumption(generalAssumption, specificAssumption, generalContext, specificContext);
 
         if (assumptionUnifies) {
-          specificContext.commit(context);
-        }
+          const assumption = this,  ///
+                specificContextQualifies = specificContext.qualify(assumption, metaLevelAssumption);
 
+          if (specificContextQualifies) {
+            specificContext.commit(context);
+
+            metaLevelAssumptionUnifies = true;
+          }
+        }
       }, specificContext);
     }, specificContext, context);
 
-    if (assumptionUnifies) {
-      context.debug(`...unified the '${specificAssumptionString}' assumption with the '${generalAssumptionString}' assumption.`);
+    if (metaLevelAssumptionUnifies) {
+      context.debug(`...unified the '${metaLevelAssumptionString}' meta-level assumption with the '${assumptionString}' assumption.`);
     }
 
-    return assumptionUnifies;
+    return metaLevelAssumptionUnifies;
   }
 
   unifyTopLevelMetaAssertion(topLevelMetaAssertion, context) {
@@ -293,33 +284,14 @@ export default define(class Assumption extends Element {
             assumptionNode = instantiateAssumption(string, context),
             node = assumptionNode,  ///
             reference = referenceFromAssumptionNode(assumptionNode, context),
-            statement = statementFromAssumptionNode(assumptionNode, context);
-
-      context = null; ///
-
-      const assumption = new Assumption(context, string, node, reference, statement);
+            statement = statementFromAssumptionNode(assumptionNode, context),
+            assumption = new Assumption(context, string, node, reference, statement);
 
       return assumption;
     }, context);
 
     return assumption;
   }
-
-  static fromStatementAndReference(statement, reference, context) {
-    let assumption;
-
-    instantiate((context) => {
-      const assumptionString = assumptionStringFromStatementAndReference(statement, reference),
-            string = assumptionString,  ///
-            assumptionNode = instantiateAssumption(string, context);
-
-      assumption = assumptionFromAssumptionNode(assumptionNode, context);
-
-      assumption.setContext(context);
-    }, context);
-
-    return assumption;
-  }
 });
 
 function referenceFromAssumptionNode(assumptionNode, context) {

package/src/element/frame.js

@@ -3,10 +3,10 @@
 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 { descend, reconcile, instantiate } from "../utilities/context";
 import { assumptionsStringFromAssumptions } from "../utilities/string";
 
 export default define(class Frame extends Element {
@@ -225,17 +225,13 @@ export default define(class Frame extends Element {
 
     context.trace(`Validating the '${frameString}' frame's '${assumptionstring}' assumption.`);
 
-    reconcile((context) => {
-      descend((context) => {
-        assumption = assumption.validate(context);  ///
+    assumption = assumption.validate(context);  ///
 
-        if (assumption !== null) {
-          assumptions.push(assumption);
+    if (assumption !== null) {
+      assumptions.push(assumption);
 
-          assumptionValidates = true;
-        }
-      }, context);
-    }, context);
+      assumptionValidates = true;
+    }
 
     if (assumptionValidates) {
       context.debug(`...validated the '${frameString}' frame's '${assumptionstring}' assumption.`);
@@ -247,9 +243,9 @@ export default define(class Frame extends Element {
   validateAssumptions(context) {
     let assumptionsValidate;
 
-    const singular = this.isSingular();
+    const assumptionsLength = this.assumptions.length;
 
-    if (!singular) {
+    if (assumptionsLength) {
       const frameString = this.getString(), ///
             assumptionsString = assumptionsStringFromAssumptions(this.assumptions);
 
@@ -278,11 +274,11 @@ export default define(class Frame extends Element {
   }
 
   validatMetavariable(context) {
-    let metavariableValidates = false;
+    let metavariableValidates = true; ///
 
-    const singular = this.isSingular();
+    if (this.metavariable !== null) {
+      metavariableValidates = false;
 
-    if (singular) {
       const frameString = this.getString(), ///
             metavariableString = this.metavariable.getString();
 
@@ -296,8 +292,6 @@ export default define(class Frame extends Element {
       if (metavariableMetaTypeEqualToFrameMetaType) {
         metavariableValidates = true;
       }
-    } else {
-      metavariableValidates = true;
     }
 
     return metavariableValidates;

package/src/element/hypothesis.js

@@ -3,7 +3,7 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import {descend, instantiate} from "../utilities/context";
+import { descend, instantiate } from "../utilities/context";
 import { instantiateHypothesis } from "../process/instantiate";
 import { statementFromHypothesisNode } from "../utilities/element";
 

package/src/element/judgement.js

@@ -38,10 +38,14 @@ export default define(class Judgement extends Element {
     return singular;
   }
 
+  getAssumptions() { return this.frame.getAssumptions(); }
+
   getMetavariable() { return this.frame.getMetavariable(); }
 
   getMetavariableNode() { return this.frame.getMetavariableNode(); }
 
+  getTopLevelMetaAssertion() { return this.assumption.getTopLevelMetaAssertion(); }
+
   matchJudgementNode(judgementNode) {
     const node = judgementNode, ///
           nodeMatches = this.matchNode(node),
@@ -186,38 +190,33 @@ export default define(class Judgement extends Element {
 
     context.trace(`Validating the '${judgementString}' derived judgement...`);
 
-    const topLevelMetaAssertion = this.assumption.getTopLevelMetaAssertion(),
-          metavariableNode = this.getMetavariableNode(),
+    const metavariableNode = this.getMetavariableNode(),
+          topLevelMetaAssertion = this.getTopLevelMetaAssertion(),
+          metaLevelAssumptions = topLevelMetaAssertion.getMetaLevelAssumptions(),
           judgements = context.findJudgementsByMetavariableNode(metavariableNode);
 
     let assumptions;
 
-    assumptions = topLevelMetaAssertion.getAssumptions();
-
-    const specificAssumptions = assumptions; ///
-
-    assumptions = assumptionsFromJudgements(judgements);
+    assumptions = this.getAssumptions();
 
-    const generalAssumptions = assumptions;  ///
+    assumptions = assumptionsFromJudgements(judgements, assumptions);
 
     reconcile((context) => {
-      const specificAssumptionsUnify = specificAssumptions.every((specificAssumption) => {
-        const specificAssumptionUnifies = generalAssumptions.some((generalAssumption) => {
-          const generalContext = context, ///
-                specificContext = context,  ///
-                specificAssumptionUnifies = generalAssumption.unifyAssumption(specificAssumption, generalContext, specificContext);
+      const metaLevelAssumptionsUnify = metaLevelAssumptions.every((metaLevelAssumption) => {
+        const metaLevelAssumptionUnifies = assumptions.some((assumption) => {
+          const metaLevelAssumptionUnifies = assumption.unifyMetaLevelAssumption(metaLevelAssumption, context);
 
-          if (specificAssumptionUnifies) {
+          if (metaLevelAssumptionUnifies) {
             return true;
           }
         });
 
-        if (specificAssumptionUnifies) {
+        if (metaLevelAssumptionUnifies) {
           return true;
         }
       });
 
-      if (specificAssumptionsUnify) {
+      if (metaLevelAssumptionsUnify) {
         validatesWhenDerived = true;
       }
     }, context);
@@ -284,11 +283,11 @@ function frameFromJudgementNode(judgementNode, context) {
   return frame;
 }
 
-function assumptionsFromJudgements(judgements) {
-  const assumptions = judgements.map((judgement) => {
+function assumptionsFromJudgements(judgements, assumptions = []) {
+  judgements.map((judgement) => {
     const assumption = judgement.getAssumption();
 
-    return assumption;
+    assumptions.push(assumption);
   });
 
   return assumptions;

package/src/element/metavariable.js

@@ -56,6 +56,22 @@ export default define(class Metavariable extends Element {
     return metavariableName;
   }
 
+  isDeclared(context) {
+    const metavariableName = this.getMetavariableName(),
+          metavariable = context.findMetavariableByMetavariableName(metavariableName),
+          declared = (metavariable !== null);
+
+    return declared;
+  }
+
+  isEqualTo(metavariable) {
+    const metavariableNode = metavariable.getNode(),
+          metavariableNodeMatches = this.matchMetavariableNode(metavariableNode),
+          equalTo = metavariableNodeMatches;  ///
+
+    return equalTo;
+  }
+
   isMetaTypeEqualTo(metaType) { return this.metaType.isEqualTo(metaType); }
 
   matchMetavariableNode(metavariableNode) {
@@ -148,39 +164,90 @@ export default define(class Metavariable extends Element {
     return typeVerifies;
   }
 
-  validate(context) {
+  findValidMetavariable(context) {
+    const metavariableNode = this.getMetavariableNode(),
+          metavariable = context.findMetavariableByMetavariableNode(metavariableNode),
+          validMetavariable = metavariable; ///
+
+    return validMetavariable;
+  }
+
+  validate(strict, context) {
+    if (context === undefined) {
+      context = strict; ///
+
+      strict = false;
+    }
+
     let metavariable = null;
 
     const metavariableString = this.getString(); ///
 
     context.trace(`Validating the '${metavariableString}' metavariable...`);
 
-    let validates = false;
+    const validMetavariable = this.findValidMetavariable(context),
+          valid = (validMetavariable !== null);
 
-    const typeValidates = this.validateType(context);
+    if (valid) {
+      metavariable = validMetavariable; ///
 
-    if (typeValidates) {
-      const termValidates = this.validateTerm(context);
+      context.debug(`...the '${metavariableString}' metavariable is already valid.`);
+    } else {
+      let validates = false;
 
-      if (termValidates) {
-        const nameValidates = this.validateName(context);
+      const typeValidates = this.validateType(strict, context);
+
+      if (typeValidates) {
+        const termValidates = this.validateTerm(strict, context);
 
-        if (nameValidates) {
-          validates = true;
+        if (termValidates) {
+          const nameValidates = this.validateName(strict, context);
+
+          if (nameValidates) {
+            validates = true;
+          }
         }
       }
-    }
 
-    if (validates) {
-      metavariable = this;  ///
+      if (validates) {
+        metavariable = this;  ///
+
+        const declared = this.isDeclared(context);
 
-      context.debug(`...validated the '${metavariableString}' metavariable.`);
+        if (declared) {
+          context.addMetavariable(metavariable);
+        }
+
+        context.debug(`...validated the '${metavariableString}' metavariable.`);
+      }
     }
 
     return metavariable;
   }
 
-  validateTerm(context) {
+  validateType(strict, context) {
+    let typeValidates = false;
+
+    const metavariableString = this.getString();  ///
+
+    context.trace(`Validating  the '${metavariableString}' metavariable's type...`);
+
+    if (this.type === null) {
+      typeValidates = true;
+    } else {
+      const typeString = this.type.getString();
+
+      context.trace(`A '${typeString}' type is present in the '${metavariableString}' metavariable.`);
+    }
+
+    if (typeValidates) {
+      context.trace(`...validated  the '${metavariableString}' metavariable's type.`);
+    }
+
+    return typeValidates;
+  }
+
+  validateTerm(strict, context) {
     let termValidates = true; ///
 
     if (this.term !== null) {
@@ -197,20 +264,19 @@ export default define(class Metavariable extends Element {
       let term = null;
 
       if (metavariable !== null) {
-        const type = metavariable.getType(),
-              metavariableString = metavariable.getString();
+        const type = metavariable.getType();
 
         if (type !== null) {
           term = this.term.validateGivenType(type, context);
-        } else {
-          context.trace(`The '${metavariableString}' metavariable does not have a type`);
         }
       } else {
-        term = this.term.validate(context, (term) => {
-          const validatesForwards = true;
+        if (!strict) {
+          term = this.term.validate(context, (term) => {
+            const validatesForwards = true;
 
-          return validatesForwards;
-        });
+            return validatesForwards;
+          });
+        }
       }
 
       if (term !== null) {
@@ -227,8 +293,8 @@ export default define(class Metavariable extends Element {
     return termValidates;
   }
 
-  validateName(context) {
-    let termValidates = true; ///
+  validateName(strict, context) {
+    let nameValidates = true; ///
 
     const metavariableName = this.getMetavariableName(),  ///
           metavariableString = this.getString();  ///
@@ -239,40 +305,22 @@ export default define(class Metavariable extends Element {
 
     if (metavariable !== null) {
       const metaType = metavariable.getMetaType(),
-            metaTypeSTring = metaType.getString();
+            metaTypeString = metaType.getString();
 
       this.metaType = metaType;
 
-      context.trace(`Setting the '${metavariableString}' metavariable's meta-type to the '${metaTypeSTring}' meta-type.`);
-    }
-
-    if (termValidates) {
-      context.debug(`...validated the '${metavariableString}' metavariable's '${metavariableName}' name.`);
-    }
-
-    return termValidates;
-  }
-
-  validateType(context) {
-    let typeValidates = false;
-
-    const metavariableString = this.getString();  ///
-
-    context.trace(`Validating  the '${metavariableString}' metavariable's type...`);
-
-    if (this.type === null) {
-      typeValidates = true;
+      context.trace(`Setting the '${metavariableString}' metavariable's meta-type to the '${metaTypeString}' meta-type.`);
     } else {
-      const typeString = this.type.getString();
-
-      context.trace(`A '${typeString}' type is present in the '${metavariableString}' metavariable.`);
+      if (strict) {
+        nameValidates = false;
+      }
     }
 
-    if (typeValidates) {
-      context.trace(`...validated  the '${metavariableString}' metavariable's type.`);
+    if (nameValidates) {
+      context.debug(`...validated the '${metavariableString}' metavariable's '${metavariableName}' name.`);
     }
 
-    return typeValidates;
+    return nameValidates;
   }
 
   unifyFrame(frame, generalContext, specificContext) {
@@ -365,14 +413,6 @@ export default define(class Metavariable extends Element {
                                         StatementSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context) :
                                           StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context);
 
-        if (substitution !== null) {
-          const context = generalContext; ///
-
-          substitution = statementSubstitution.getSubstitution();
-
-          substitution.setContext(context);
-        }
-
         statementSubstitution.validate(generalContext, specificContext);
 
         statementUnifies = true;

package/src/element/proofAssertion/step.js

@@ -7,7 +7,7 @@ import ProofAssertion from "../proofAssertion";
 
 import { define } from "../../elements";
 import { unifyStatements } from "../../utilities/unification";
-import { derive, attempt, descend, asyncReconcile } from "../../utilities/context";
+import { derive, attempt, asyncReconcile } from "../../utilities/context";
 
 const { asyncSome } = asynchronousUtilities;
 
@@ -184,13 +184,11 @@ export default define(class Step extends ProofAssertion {
 
       context.trace(`Validating the '${stepString}' step's '${satisfiesAssertionString}' satisfies assertion... `);
 
-      descend((context) => {
-        const satisfiesAssertion = this.satisfiesAssertion.validate(context);
+      const satisfiesAssertion = this.satisfiesAssertion.validate(context);
 
-        if (satisfiesAssertion === null) {
-          satisfiesAssertionValidates = false;
-        }
-      }, context);
+      if (satisfiesAssertion === null) {
+        satisfiesAssertionValidates = false;
+      }
 
       if (satisfiesAssertionValidates) {
         context.debug(`...validating the '${stepString}' step's '${satisfiesAssertionString}' satisfies assertion. `);