occam-verify-cli 1.0.708 → 1.0.714

package/src/element/frame.js

@@ -252,6 +252,25 @@ export default define(class Frame extends Element {
     return validatesWhenDerived;
   }
 
+  validateAssumption(assumption, context) {
+    let assumptionValidates;
+
+    const frameString = this.getString(), ///
+          assumptionstring = assumption.getString();
+
+    context.trace(`Validating the '${frameString}' frame's '${assumptionstring}' assumption.`);
+
+    const stated = true;  ///
+
+    assumptionValidates = assumption.validate(stated, context);
+
+    if (assumptionValidates) {
+      context.debug(`...validated the '${frameString}' frame's '${assumptionstring}' assumption.`);
+    }
+
+    return assumptionValidates;
+  }
+
   validateAssumptions(stated, context) {
     let assumptionsValidate;
 
@@ -261,14 +280,12 @@ export default define(class Frame extends Element {
       const frameString = this.getString(), ///
             assumptionsString = assumptionsStringFromAssumptions(this.assumptions);
 
-      context.trace(`Validating the '${assumptionsString}' assumptions of the '${frameString}' frame...`);
-
-      stated = true;  ///
+      context.trace(`Validating the '${frameString}' frame's '${assumptionsString}' assumptions...`);
 
       const assumptions = [];
 
       assumptionsValidate = this.assumptions.every((assumption) => {
-        const assumptionValidates = assumption.validate(stated, context);
+        const assumptionValidates = this.validateAssumption(assumption, context);
 
         if (assumptionValidates) {
           assumptions.push(assumption);
@@ -280,7 +297,7 @@ export default define(class Frame extends Element {
       if (assumptionsValidate) {
         this.assumptions = assumptions;
 
-        context.debug(`...validated the '${assumptionsString}' assumptions of the '${frameString}' frame.`);
+        context.debug(`...validated the '${frameString}' frame's '${assumptionsString}' assumptions.`);
       }
     } else {
       assumptionsValidate = true;
@@ -335,9 +352,11 @@ export default define(class Frame extends Element {
     const metaTypeName = metaType.getName();
 
     if (metaTypeName === FRAME_META_TYPE_NAME) {
-      const validates = this.validate(stated, context)
+      const frame = this.validate(stated, context);
 
-      validatesGivenMetaType = validates; ///
+      if (frame !== null) {
+        validatesGivenMetaType = true;
+      }
     }
 
     if (validatesGivenMetaType) {

package/src/element/metavariable.js

@@ -284,7 +284,6 @@ export default define(class Metavariable extends Element {
 
         if (referenceSubstitution !== null) {
           referenceUnifies = true;
-
         }
       }
     }

package/src/element/proofAssertion/premise.js

@@ -41,18 +41,17 @@ export default define(class Premise extends ProofAssertion {
 
     context.trace(`Verifying the '${premiseString}' premise...`);
 
-    attempt((context) => {
+    const statement = this.getStatement(),
+          procedureCall = this.getProcedureCall();
+
+    if ((statement !== null) || (procedureCall !== null)) {
       const validates = this.validate(context);
 
       if (validates) {
-        this.setContext(context);
-
         verifies = true;
       }
-    }, context);
-
-    if (verifies) {
-      context.debug(`...verified the '${premiseString}' premise.`);
+    } else {
+      context.debug(`Unable to validate the '${premiseString}' premise because it is nonsense.`);
     }
 
     return verifies;
@@ -65,26 +64,30 @@ export default define(class Premise extends ProofAssertion {
 
     context.trace(`Validatting the '${premiseString}' premise...`);
 
-    const statement = this.getStatement(),
-          procedureCall = this.getProcedureCall();
+    attempt((context) => {
+      const statement = this.getStatement(),
+            procedureCall = this.getProcedureCall();
+
+      if (statement !== null) {
+        const statementValidates = this.validateStatement(context);
 
-    if (false) {
-      ///
-    } else if (statement !== null) {
-      const statementValidates = this.validateStatement(context);
+        if (statementValidates) {
+          this.setContext(context);
 
-      if (statementValidates) {
-        validates = true;
+          validates = true;
+        }
       }
-    } else if (procedureCall !== null) {
-      const procedureCallValidates = this.validateProcedureCall(context);
 
-      if (procedureCallValidates) {
-        validates = true;
+      if (procedureCall !== null) {
+        const procedureCallValidates = this.validateProcedureCall(context);
+
+        if (procedureCallValidates) {
+          this.setContext(context);
+
+          validates = true;
+        }
       }
-    } else {
-      context.debug(`Unable to validate the '${premiseString}' premise because it is nonsense.`);
-    }
+    }, context);
 
     if (validates) {
       context.debug(`...validated the '${premiseString}' premise.`);
@@ -101,7 +104,11 @@ export default define(class Premise extends ProofAssertion {
 
     context.trace(`Validatting the '${premiseString}' premise's '${procedureCallString}' procedure call...`);
 
-    procedureCallValidates = this.procedureCall.validate(context);
+    const procedureCall = this.procedureCall.validate(context);
+
+    if (procedureCall !== null) {
+      procedureCallValidates = true;
+    }
 
     if (procedureCallValidates) {
       context.debug(`...validated the '${premiseString}' premise's '${procedureCallString}' procedure call.`);
@@ -150,7 +157,7 @@ export default define(class Premise extends ProofAssertion {
   }
 
   unifyProofAssertion(proofAssertion, context) {
-    let proofAssertionUnifies;
+    let proofAssertionUnifies = false;
 
     const premiseString = this.getString(), ///
           proofAssertionString = proofAssertion.getString();
@@ -160,18 +167,21 @@ export default define(class Premise extends ProofAssertion {
     const proofAssertionContext = proofAssertion.getContext(),
           premiseContext = this.getContext(),
           generalContext = premiseContext, ///
-          specificContext = proofAssertionContext; ///
+          specificContext = proofAssertionContext,
+          statementUnifies = liminally((specificContext) => {
+            const statement = proofAssertion.getStatement(),
+                  statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
 
-    proofAssertionUnifies = liminally((specificContext) => {
-      const statement = proofAssertion.getStatement(),
-            statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
+            if (statementUnifies) {
+              specificContext.commit(context);
 
-      if (statementUnifies) {
-        specificContext.commit(context);
+              return true;
+            }
+          }, specificContext);
 
-        return true;
-      }
-    }, specificContext);
+    if (statementUnifies) {
+      proofAssertionUnifies = true;
+    }
 
     if (proofAssertionUnifies) {
       context.debug(`...unified the '${proofAssertionString}' proof assertion with the '${premiseString}' premise.`);

package/src/element/proofAssertion/step.js

@@ -6,7 +6,7 @@ import ProofAssertion from "../proofAssertion";
 
 import { define } from "../../elements";
 import { unifyStatements } from "../../utilities/unification";
-import { asyncAttempt, asyncLiminally } from "../../utilities/context";
+import { attempt, asyncLiminally } from "../../utilities/context";
 import { propertyAssertionFromStatement } from "../../utilities/statement";
 
 const { asyncSome } = asynchronousUtilities;
@@ -75,19 +75,23 @@ export default define(class Step extends ProofAssertion {
 
     context.trace(`Verifying the '${stepString}' step...`);
 
-    await asyncAttempt(async (context) => {
+    const statement = this.getStatement();
+
+    if (statement !== null) {
       const validates = this.validate(context);
 
       if (validates) {
-        const unifies = await this.unify(context);
+        context = this.getContext();
 
-        if (unifies) {
-          this.setContext(context);
+        const unifiies = await this.unify(context);
 
+        if (unifiies) {
           verifies = true;
         }
       }
-    }, context);
+    } else {
+      context.debug(`Unable to verify the '${stepString}' step because it is nonsense.`);
+    }
 
     if (verifies) {
       context.debug(`...verified the '${stepString}' step.`);
@@ -103,9 +107,7 @@ export default define(class Step extends ProofAssertion {
 
     context.trace(`Validating the '${stepString}' step...`);
 
-    const statement = this.getStatement();
-
-    if (statement !== null) {
+    attempt((context) => {
       const referenceValidates = this.validateReference(context);
 
       if (referenceValidates) {
@@ -115,16 +117,16 @@ export default define(class Step extends ProofAssertion {
           const statementValidates = this.validateStatement(context);
 
           if (statementValidates) {
+            this.setContext(context);
+
             validates = true;
           }
         }
       }
-    } else {
-      context.debug(`Unable to validate the '${stepString}' step because it is nonsense.`);
-    }
+    }, context);
 
     if (validates) {
-      context.debug(`...validate the '${stepString}' step.`);
+      context.debug(`...validated the '${stepString}' step.`);
     }
 
     return validates;
@@ -223,11 +225,10 @@ export default define(class Step extends ProofAssertion {
 
     if (axiom !== null) {
       const step = this,  ///
-            substitutions = [],
-            stepUnifies = axiom.unifyStep(step, substitutions, context);
+            stepUnifies = axiom.unifyStep(step, context);
 
       if (stepUnifies) {
-        const substitutionsCompare = satisfiesAssertion.compareSubstitutions(substitutions, context);
+        const substitutionsCompare = satisfiesAssertion.compareSubstitutions(context);
 
         if (substitutionsCompare) {
           unifiesWithSatisfiesAssertion = true;

package/src/element/proofAssertion/supposition.js

@@ -37,22 +37,21 @@ export default define(class Supposition extends ProofAssertion {
 
     await this.break(context);
 
-    const suppositionString = this.getString(); ///
+    const suppositionString = this.getString();
 
     context.trace(`Verifying the '${suppositionString}' supposition...`);
 
-    attempt((context) => {
+    const statement = this.getStatement(),
+          procedureCall = this.getProcedureCall();
+
+    if ((statement !== null) || (procedureCall !== null)) {
       const validates = this.validate(context);
 
       if (validates) {
-        this.setContext(context);
-
         verifies = true;
       }
-    }, context);
-
-    if (verifies) {
-      context.debug(`...verified the '${suppositionString}' supposition.`);
+    } else {
+      context.debug(`Unable to validate the '${suppositionString}' supposition because it is nonsense.`);
     }
 
     return verifies;
@@ -65,26 +64,30 @@ export default define(class Supposition extends ProofAssertion {
 
     context.trace(`Validatting the '${suppositionString}' supposition...`);
 
-    const statement = this.getStatement(),
-          procedureCall = this.getProcedureCall();
+    attempt((context) => {
+      const statement = this.getStatement(),
+            procedureCall = this.getProcedureCall();
+
+      if (statement !== null) {
+        const statementValidates = this.validateStatement(context);
 
-    if (false) {
-      ///
-    } else if (statement !== null) {
-      const statementValidates = this.validateStatement(context);
+        if (statementValidates) {
+          this.setContext(context);
 
-      if (statementValidates) {
-        validates = true;
+          validates = true;
+        }
       }
-    } else if (procedureCall !== null) {
-      const procedureCallValidates = this.validateProcedureCall(context);
 
-      if (procedureCallValidates) {
-        validates = true;
+      if (procedureCall !== null) {
+        const procedureCallValidates = this.validateProcedureCall(context);
+
+        if (procedureCallValidates) {
+          this.setContext(context);
+
+          validates = true;
+        }
       }
-    } else {
-      context.debug(`Unable to validate the '${suppositionString}' supposition because it is nonsense.`);
-    }
+    }, context);
 
     if (validates) {
       context.debug(`...validated the '${suppositionString}' supposition.`);
@@ -101,7 +104,11 @@ export default define(class Supposition extends ProofAssertion {
 
     context.trace(`Validatting the '${suppositionString}' supposition's '${procedureCallString}' procedure call...`);
 
-    procedureCallValidates = this.procedureCall.validate(context);
+    const procedureCall = this.procedureCall.validate(context);
+
+    if (procedureCall !== null) {
+      procedureCallValidates =true;
+    }
 
     if (procedureCallValidates) {
       context.debug(`...validated the '${suppositionString}' supposition's '${procedureCallString}' procedure call.`);
@@ -172,7 +179,7 @@ export default define(class Supposition extends ProofAssertion {
   }
 
   unifyProofAssertion(proofAssertion, context) {
-    let proofAssertionUnifies;
+    let proofAssertionUnifies = false;
 
     const suppositionString = this.getString(), ///
           proofAssertionString = proofAssertion.getString();
@@ -182,18 +189,21 @@ export default define(class Supposition extends ProofAssertion {
     const proofAssertionContext = proofAssertion.getContext(),
           suppositionContext = this.getContext(),
           generalContext = suppositionContext, ///
-          specificContext = proofAssertionContext; ///
+          specificContext = proofAssertionContext,
+          statementUnifies = liminally((specificContext) => {
+            const statement = proofAssertion.getStatement(),
+              statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
 
-    proofAssertionUnifies = liminally((specificContext) => {
-      const statement = proofAssertion.getStatement(),
-            statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
+            if (statementUnifies) {
+              specificContext.commit(context);
 
-      if (statementUnifies) {
-        specificContext.commit(context);
+              return true;
+            }
+          }, specificContext);
 
-        return true;
-      }
-    }, specificContext);
+    if (statementUnifies) {
+      proofAssertionUnifies = true;
+    }
 
     if (proofAssertionUnifies) {
       context.debug(`...unified the '${proofAssertionString}' proof assertion with the '${suppositionString}' supposition.`);

package/src/element/reference.js

@@ -3,7 +3,7 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { attempt, literally } from "../utilities/context";
+import { literally } from "../utilities/context";
 import { instantiateReference } from "../process/instantiate";
 import { REFERENCE_META_TYPE_NAME } from "../metaTypeNames";
 import { metavariableFromReferenceNode } from "../utilities/element";
@@ -160,7 +160,7 @@ export default define(class Reference extends Element {
     const referenceString = this.getString(), ///
           metavariableString = this.metavariable.getString();
 
-    context.trace(`Validating the '${referenceString}' reference's '${metavariableString}' metavariable....'`);
+    context.trace(`Validating the '${referenceString}' reference's '${metavariableString}' metavariable...'`);
 
     const metaTypeName = REFERENCE_META_TYPE_NAME,
           referenceMetaType = context.findMetaTypeByMetaTypeName(metaTypeName),
@@ -249,13 +249,9 @@ export default define(class Reference extends Element {
 
     context.trace(`Unifying the '${metavariableString}' metavariable with the '${referenceString}' reference...`);
 
-    const metavariableUnifiesIntrinsically = attempt((specificContext) => {
-      const generalMetavariable = this.metavariable,  ///
-            specificMetavariable = metavariable, ///
-            metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, generalContext, specificContext);
-
-      return metavariableUnifiesIntrinsically;
-    }, specificContext);
+    const generalMetavariable = this.metavariable,  ///
+          specificMetavariable = metavariable, ///
+          metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, generalContext, specificContext);
 
     if (metavariableUnifiesIntrinsically) {
       metavariableUnifies = true;
@@ -278,8 +274,7 @@ export default define(class Reference extends Element {
     context.trace(`Unifying the '${topLevelMetaAssertionString}' top level meta-assertion with the '${referenceString}' reference...`);
 
     const label = topLevelMetaAssertion.getLabel(),
-          substitutions = [],
-          labelUnifies = this.unifyLabel(label, substitutions, context);
+          labelUnifies = this.unifyLabel(label, context);
 
     topLevelMetaAssertionUnifies = labelUnifies;  ///
 

package/src/element/rule.js

@@ -109,7 +109,7 @@ export default define(class Rule extends Element {
     }, context);
 
     if (verifies) {
-      const rule = this;
+      const rule = this;  ///
 
       context.addRule(rule);
 

package/src/element/signature.js

@@ -35,9 +35,9 @@ export default define(class Signature extends Element {
 
     context.trace(`Verifying the '${signatureString}' signature...`);
 
-    const validates = this.validate(context);
+    const signature = this.validate(context);
 
-    if (validates) {
+    if (signature !== null) {
       verifies = true;
     }
 
@@ -49,7 +49,7 @@ export default define(class Signature extends Element {
   }
 
   validate(context) {
-    let validates = false;
+    let signature = null;
 
     const signatureString = this.getString();  ///
 
@@ -61,14 +61,14 @@ export default define(class Signature extends Element {
     if (termsValidate) {
       this.terms = terms;
 
-      validates = true;
+      signature = this; ///
     }
 
-    if (validates) {
+    if (signature) {
       context.debug(`...validated the '${signatureString}' signature.`);
     }
 
-    return validates
+    return signature
   }
 
   validateTerm(term, terms, context) {

package/src/element/statement.js

@@ -220,9 +220,11 @@ export default define(class Statement extends Element {
     const metaTypeName = metaType.getName();
 
     if (metaTypeName === STATEMENT_META_TYPE_NAME) {
-      const validates = this.validate(stated, context)
+      const statement = this.validate(stated, context)
 
-      validatesGivenMetaType = validates; ///
+      if (statement !== null) {
+        validatesGivenMetaType = true;
+      }
     }
 
     if (validatesGivenMetaType) {

package/src/element/subproof.js

@@ -106,8 +106,7 @@ export default define(class Subproof extends Element {
 
       if (axiomSatisfiable) {
         const subproof = this,  ///
-              substitutions = [],
-              statementUnifies = axiom.unifySubproof(subproof, substitutions, context);
+              statementUnifies = axiom.unifySubproof(subproof, context);
 
         if (statementUnifies) {
           const substitutionsCompare = satisfiesAssertion.compareSubstitutions(substitutions, context);

package/src/element/term.js

@@ -199,20 +199,19 @@ export default define(class Term extends Element {
 
     context.trace(`Validating the '${termString}' term given the '${typeString}' type...`);
 
-    const validates = this.validate(context, () => {
-      let validatesForwards;
-
-      const typeEqualToOrSubTypeOfGivenTypeType = this.type.isEqualToOrSubTypeOf(type);
-
-      if (typeEqualToOrSubTypeOfGivenTypeType) {
-        validatesForwards = true;
-      }
+    const term = this.validate(context, () => {
+      const validatesForwards = true;
 
       return validatesForwards;
     });
 
-    if (validates) {
-      validatesGivenType = true;
+    if (term !== null) {
+      const termType = term.getType(),
+            termTypeEqualToOrSubTypeOfGivenTypeType = termType.isEqualToOrSubTypeOf(type);
+
+      if (termTypeEqualToOrSubTypeOfGivenTypeType) {
+        validatesGivenType = true;
+      }
     }
 
     if (validatesGivenType) {