occam-verify-cli 1.0.635 → 1.0.638

package/src/element/frame.js

@@ -56,14 +56,15 @@ export default define(class Frame extends Element {
     return frameNodeMatches;
   }
 
-  isValid(context) {
+  findValidFrame(context) {
     const frameNode = this.getFrameNode(),
-          framePresent = context.isFramePresentByFrameNode(frameNode),
-          valid = framePresent;  ///
+          frame = context.findFrameByFrameNode(frameNode),
+          validFrame = frame; ///
 
-    return valid;
+    return validFrame;
   }
 
+
   isEqualTo(frame) {
     const frameNode = frame.getNode(),
           frameNodeMatches = this.matchFrameNode(frameNode),
@@ -165,29 +166,32 @@ export default define(class Frame extends Element {
     return comparesToMetavariableName;
   }
 
-  validate(assignments, stated, context) {
-    let validates = false;
+  validate(stated, context) {
+    let frame = null;
 
     const frameString = this.getString();  ///
 
     context.trace(`Validating the '${frameString}' frame...`);
 
-    const valid = this.isValid(context);
+    const validFrame = this.findValidFrame(context),
+          valid = (validFrame !== null);
 
     if (valid) {
-      validates = true;
+      frame = validFrame; ///
 
       context.debug(`...the '${frameString}' frame is already valid.`);
     } else {
-      const assumptionsValidate = this.validateAssumptions(assignments, stated, context),
-            metavariablevalidates = this.validateMetavariable(assignments, stated, context);
+      let validates = false;
+
+      const assumptionsValidate = this.validateAssumptions(stated, context),
+            metavariablevalidates = this.validateMetavariable(stated, context);
 
       if (assumptionsValidate && metavariablevalidates) {
         let validatesWhenStated = false,
             validatesWhenDerived = false;
 
         if (stated) {
-          validatesWhenStated = this.validateWhenStated(assignments, context);
+          validatesWhenStated = this.validateWhenStated(context);
         } else {
           validatesWhenDerived = this.validateWhenDerived(context);
         }
@@ -198,7 +202,7 @@ export default define(class Frame extends Element {
       }
 
       if (validates) {
-        const frame = this; ///
+        frame = this; ///
 
         context.addFrame(frame);
 
@@ -206,10 +210,10 @@ export default define(class Frame extends Element {
       }
     }
 
-    return validates;
+    return frame;
   }
 
-  validateWhenStated(assignments, context) {
+  validateWhenStated(context) {
     let validatesWhenStated = false;
 
     const frameString = this.getString();  ///
@@ -247,7 +251,7 @@ export default define(class Frame extends Element {
     return validatesWhenDerived;
   }
 
-  validateAssumptions(assignments, stated, context) {
+  validateAssumptions(stated, context) {
     let assumptionsValidate;
 
     const singular = this.isSingular();
@@ -260,15 +264,21 @@ export default define(class Frame extends Element {
 
       stated = true;  ///
 
-      assignments = null; ///
+      const assumptions = [];
 
       assumptionsValidate = this.assumptions.every((assumption) => {
-        const assumptionVerifies = assumption.validate(assignments, stated, context);
+        const assumptionValidates = assumption.validate(stated, context);
 
-        return assumptionVerifies;
+        if (assumptionValidates) {
+          assumptions.push(assumption);
+
+          return true;
+        }
       });
 
       if (assumptionsValidate) {
+        this.assumptions = assumptions;
+
         context.debug(`...validated the '${assumptionsString}' assumptions of the '${frameString}' frame.`);
       }
     } else {
@@ -278,7 +288,7 @@ export default define(class Frame extends Element {
     return assumptionsValidate;
   }
 
-  validateMetavariable(assignments, stated, context) {
+  validateMetavariable(stated, context) {
     let metavariableValidates = false;
 
     const singular = this.isSingular();
@@ -313,7 +323,7 @@ export default define(class Frame extends Element {
     return metavariableValidates;
   }
 
-  validateGivenMetaType(metaType, assignments, stated, context) {
+  validateGivenMetaType(metaType, stated, context) {
     let validatesGivenMetaType = false;
 
     const frameString = this.getString(),  ///
@@ -324,7 +334,7 @@ export default define(class Frame extends Element {
     const metaTypeName = metaType.getName();
 
     if (metaTypeName === FRAME_META_TYPE_NAME) {
-      const validates = this.validate(assignments, stated, context)
+      const validates = this.validate(stated, context)
 
       validatesGivenMetaType = validates; ///
     }

package/src/element/hypothesis.js

@@ -2,8 +2,6 @@
 
 import { Element } from "occam-languages";
 
-import assignAssignments from "../process/assign";
-
 import { define } from "../elements";
 import { statementFromJSON, statementToStatementJSON } from "../utilities/json";
 
@@ -37,15 +35,20 @@ export default define(class Hypothesis extends Element {
     if (false) {
       ///
     } else if (this.statement !== null) {
+      let statementValidates = false;
+
       const stated = true,
-            assignments = [],
-            statementValidates = this.statement.validate(assignments, stated, context);
+            statement = this.statement.validate(stated, context);
 
-      if (statementValidates) {
-        assignAssignments(assignments, context);
+      if (statement !== null) {
+        statementValidates = true;
+      }
 
+      if (statementValidates) {
         const subproofOrProofAssertion = this;  ///
 
+        context.assignAssignments();
+
         context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
         verifies = true;

package/src/element/judgement.js

@@ -51,39 +51,41 @@ export default define(class Judgement extends Element {
     return judgementNodeMatches;
   }
 
-  isValid(context) {
+  findValidJudgement(context) {
     const judgementNode = this.getJudgementNode(),
-          judgementPresent = context.isJudgementPresentByJudgementNode(judgementNode),
-          valid = judgementPresent;  ///
+          judgement = context.findJudgementByJudgementNode(judgementNode),
+          validJudgemenet = judgement;  ///
 
-    return valid;
+    return validJudgemenet;
   }
 
-  validate(assignments, stated, context) {
-    let validates = false;
+  validate(stated, context) {
+    let judgement = null;
 
     const judgementString = this.getString();  ///
 
     context.trace(`Validating the '${judgementString}' judgement...`);
 
-    const valid = this.isValid(context);
+    const validJudgement = this.findValidJudgement(context);
 
-    if (valid) {
-      validates = true;
+    if (validJudgement !== null) {
+      judgement = validJudgement; ///
 
       context.debug(`...the '${judgementString}' judgement is already valid.`);
     } else {
-      const frameValidates = this.frame.validate(assignments, stated, context);
+      let validates = false;
+
+      const frameValidates = this.validateFrame(stated, context);
 
       if (frameValidates) {
-        const assumptionValidates = this.assumption.validate(assignments, stated, context);
+        const assumptionValidates = this.validateAssumption(stated, context);
 
         if (assumptionValidates) {
           let validatesWhenStated = false,
               validatesWhenDerived = false;
 
           if (stated) {
-            validatesWhenStated = this.validateWhenStated(assignments, context);
+            validatesWhenStated = this.validateWhenStated(context);
           } else {
             validatesWhenDerived = this.validateWhenDerived(context);
           }
@@ -103,10 +105,56 @@ export default define(class Judgement extends Element {
       }
     }
 
-    return validates;
+    return judgement;
+  }
+
+  validateFrame(stated, context) {
+    let frameValidates = false;
+
+    const frameString = this.frame.getString(),
+          judgementString = this.getString(); ///
+
+    context.trace(`Validating the '${judgementString}' judgement's '${frameString}' frame...`);
+
+    const frame = this.frame.validate(stated, context);
+
+    if (frame !== null) {
+      this.frame = frame;
+
+      frameValidates = true;
+    }
+
+    if (frameValidates) {
+      context.trace(`...validated the '${judgementString}' judgement's '${frameString}' frame.`);
+    }
+
+    return frameValidates;
+  }
+
+  validateAssumption(stated, context) {
+    let assumptionValidates = false;
+
+    const assumptionString = this.assumption.getString(),
+          judgementString = this.getString(); ///
+
+    context.trace(`Validating the '${judgementString}' judgement's '${assumptionString}' assumption...`);
+
+    const assumption = this.assumption.validate(stated, context);
+
+    if (assumption !== null) {
+      this.assumption = assumption;
+
+      assumptionValidates = true;
+    }
+
+    if (assumptionValidates) {
+      context.trace(`...validated the '${judgementString}' judgement's '${assumptionString}' assumption.`);
+    }
+
+    return assumptionValidates;
   }
 
-  validateWhenStated(assignments, context) {
+  validateWhenStated(context) {
     let validatesWhenStated;
 
     const judgementString = this.getString();  ///
@@ -146,11 +194,7 @@ export default define(class Judgement extends Element {
     return validatesWhenDerived;
   }
 
-  assign(assignments, stated, context) {
-    if (assignments === null) {
-      return;
-    }
-
+  assign(stated, context) {
     if (!stated) {
       return;
     }
@@ -159,7 +203,7 @@ export default define(class Judgement extends Element {
           judgementAssignment = judgementAssignmentFromJudgement(judgement, context),
           assignment = judgementAssignment; ///
 
-    assignments.push(assignment);
+    context.addAssignment(assignment);
   }
 
   static name = "Judgement";

package/src/element/metavariable.js

@@ -156,11 +156,15 @@ export default define(class Metavariable extends Element {
         }
       } else {
         const { FrameSubstitution } = elements,
-              metavariable = this, ///
-              frameSubstitution = FrameSubstitution.fromFrameAndMetavariable(frame, metavariable, context),
-              framesubstitutionValidates = frameSubstitution.validate(generalContext, specificContext);
+              metavariable = this; ///
 
-        if (framesubstitutionValidates) {
+        let frameSubstitution;
+
+        frameSubstitution = FrameSubstitution.fromFrameAndMetavariable(frame, metavariable, context);
+
+        frameSubstitution = frameSubstitution.validate(generalContext, specificContext);  ///
+
+        if (frameSubstitution !== null) {
           frameUnifies = true;
         }
       }
@@ -194,10 +198,14 @@ export default define(class Metavariable extends Element {
       statementUnifies = true;
     } else {
       const metavariableName = metavariable.getName(),
-            substitutionPresent = context.isSubstitutionPresentByMetavariableNameAndSubstitution(metavariableName, substitution);
+            substitutionPresent = (substitution !== null) ?
+                                    context.isSubstitutionPresentByMetavariableNameAndSubstitution(metavariableName, substitution) :
+                                      context.findSubstitutionByMetavariableName(metavariableName);
 
       if (substitutionPresent) {
-        substitution = context.findSubstitutionByMetavariableNameAndSubstitution(metavariableName, substitution); ///
+        substitution = (substitution !== null) ?
+                         context.findSubstitutionByMetavariableNameAndSubstitution(metavariableName, substitution) :
+                           context.findSubstitutionByMetavariableName(metavariableName);
 
         const substitutionComparesToStatement = substitution.compareStatement(statement, context);
 
@@ -205,10 +213,13 @@ export default define(class Metavariable extends Element {
           statementUnifies = true;
         }
       } else {
-        const { StatementSubstitution } = elements,
-              statementSubstitution = (substitution !== null) ?
-                                        StatementSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context) :
-                                          StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context);
+        const { StatementSubstitution } = elements;
+
+        let statementSubstitution;
+
+        statementSubstitution = (substitution !== null) ?
+                                  StatementSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context) :
+                                    StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context);
 
         if (substitution !== null) {
           const context = generalContext; ///
@@ -218,9 +229,9 @@ export default define(class Metavariable extends Element {
           substitution.setContext(context);
         }
 
-        const statementSubstitutionValidates = statementSubstitution.validate(generalContext, specificContext);
+        statementSubstitution = statementSubstitution.validate(generalContext, specificContext);  ///
 
-        if (statementSubstitutionValidates) {
+        if (statementSubstitution !== null) {
           statementUnifies = true;
         }
       }
@@ -260,11 +271,15 @@ export default define(class Metavariable extends Element {
         }
       } else {
         const { ReferenceSubstitution } = elements,
-              metavariable = this, ///
-              referenceSubstitution = ReferenceSubstitution.fromReferenceAndMetavariable(reference, metavariable, context),
-              referenceSubstitutionValidates = referenceSubstitution.validate(generalContext, specificContext);
+              metavariable = this; ///
+
+        let referenceSubstitution;
+
+        referenceSubstitution = ReferenceSubstitution.fromReferenceAndMetavariable(reference, metavariable, context);
+
+        referenceSubstitution = referenceSubstitution.validate(generalContext, specificContext);  ///
 
-        if (referenceSubstitutionValidates) {
+        if (referenceSubstitution !== null) {
           referenceUnifies = true;
 
         }

package/src/element/proofAssertion/premise.js

@@ -30,7 +30,7 @@ export default define(class Premise extends ProofAssertion {
     return stated;
   }
 
-  validate(assignments, context) {
+  validate(context) {
     let validates = false;
 
     const premiseString = this.getString(); ///
@@ -43,13 +43,13 @@ export default define(class Premise extends ProofAssertion {
     if (false) {
       ///
     } else if (statement !== null) {
-      const statementValidates = this.validateStatement(assignments, context);
+      const statementValidates = this.validateStatement(context);
 
       if (statementValidates) {
         validates = true;
       }
     } else if (procedureCall !== null) {
-      const procedureCallValidates = this.validateProcedureCall(assignments, context);
+      const procedureCallValidates = this.validateProcedureCall(context);
 
       if (procedureCallValidates) {
         validates = true;
@@ -65,7 +65,7 @@ export default define(class Premise extends ProofAssertion {
     return validates;
   }
 
-  validateProcedureCall(assignments, context) {
+  validateProcedureCall(context) {
     let procedureCallValidates = false;
 
     const premiseString = this.getString(), ///
@@ -182,7 +182,7 @@ export default define(class Premise extends ProofAssertion {
         if (assertion !== null) {
           const subproofAssertion = assertion;  ///
 
-          subproofUnifies = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);
+          subproofUnifies = subproofAssertion.unifySubproof(subproof, generalContext, specificContext);
         }
       }
     }
@@ -194,7 +194,7 @@ export default define(class Premise extends ProofAssertion {
     return subproofUnifies;
   }
 
-  async verify(assignments, context) {
+  async verify(context) {
     let verifies = false;
 
     await this.break(context);
@@ -204,7 +204,7 @@ export default define(class Premise extends ProofAssertion {
     context.trace(`Verifying the '${premiseString}' premise...`);
 
     attempt((context) => {
-      const validates = this.validate(assignments, context);
+      const validates = this.validate(context);
 
       if (validates) {
         this.setContext(context);

package/src/element/proofAssertion/step.js

@@ -66,7 +66,7 @@ export default define(class Step extends ProofAssertion {
     return comparesToTermAndPropertyRelation;
   }
 
-  validate(assignments, context) {
+  validate(context) {
     let validates = false;
 
     const stepString = this.getString(); ///
@@ -82,7 +82,7 @@ export default define(class Step extends ProofAssertion {
         const satisfiesAssertioValidates = this.validateSatisfiesAssertion(context);
 
         if (satisfiesAssertioValidates) {
-          const statementValidates = this.validateStatement(assignments, context);
+          const statementValidates = this.validateStatement(context);
 
           if (statementValidates) {
             validates = true;
@@ -109,7 +109,11 @@ export default define(class Step extends ProofAssertion {
 
       context.trace(`Validating the '${stepString}' step's '${referenceString}' reference... `);
 
-      referenceValidates = this.reference.validate(context);
+      const reference = this.reference.validate(context);
+
+      if (reference === null) {
+        referenceValidates = false;
+      }
 
       if (referenceValidates) {
         context.debug(`...validated the '${stepString}' step's '${referenceString}' reference. `);
@@ -124,17 +128,19 @@ export default define(class Step extends ProofAssertion {
 
     if (this.satisfiesAssertion !== null) {
       const stepString = this.getString(),  ///
-            satisfiesAssertion = this.satisfiesAssertion.getString();
+            satisfiesAssertionString = this.satisfiesAssertion.getString();
 
-      context.trace(`Validating the '${stepString}' step's '${satisfiesAssertion}' satisfies assertion... `);
+      context.trace(`Validating the '${stepString}' step's '${satisfiesAssertionString}' satisfies assertion... `);
 
       const stated = true,
-            assignments = null;
+            satisfiesAssertion = this.satisfiesAssertion.validate(stated, context);
 
-      satisfiesAssertionValidates = this.satisfiesAssertion.validate(assignments, stated, context);
+      if (satisfiesAssertion !== null) {
+        satisfiesAssertionValidates = true;
+      }
 
       if (satisfiesAssertionValidates) {
-        context.debug(`...validating the '${stepString}' step's '${satisfiesAssertion}' satisfies assertion. `);
+        context.debug(`...validating the '${stepString}' step's '${satisfiesAssertionString}' satisfies assertion. `);
       }
     }
 
@@ -173,7 +179,7 @@ export default define(class Step extends ProofAssertion {
     return unifiesWithSatisfiesAssertion;
   }
 
-  async verify(assignments, context) {
+  async verify(context) {
     let verifies = false;
 
     await this.break(context);
@@ -183,7 +189,7 @@ export default define(class Step extends ProofAssertion {
     context.trace(`Verifying the '${stepString}' step...`);
 
     await asyncAttempt(async (context) => {
-      const validates = this.validate(assignments, context);
+      const validates = this.validate(context);
 
       if (validates) {
         const unifies = await this.unify(context);

package/src/element/proofAssertion/supposition.js

@@ -30,7 +30,7 @@ export default define(class Supposition extends ProofAssertion {
     return stated;
   }
 
-  validate(assignments, context) {
+  validate(context) {
     let validates = false;
 
     const suppositionString = this.getString(); ///
@@ -43,13 +43,13 @@ export default define(class Supposition extends ProofAssertion {
     if (false) {
       ///
     } else if (statement !== null) {
-      const statementValidates = this.validateStatement(assignments, context);
+      const statementValidates = this.validateStatement(context);
 
       if (statementValidates) {
         validates = true;
       }
     } else if (procedureCall !== null) {
-      const procedureCallValidates = this.validateProcedureCall(assignments, context);
+      const procedureCallValidates = this.validateProcedureCall(context);
 
       if (procedureCallValidates) {
         validates = true;
@@ -65,7 +65,7 @@ export default define(class Supposition extends ProofAssertion {
     return validates;
   }
 
-  validateProcedureCall(assignments, context) {
+  validateProcedureCall(context) {
     let procedureCallValidates = false;
 
     const suppositionString = this.getString(), ///
@@ -216,7 +216,7 @@ export default define(class Supposition extends ProofAssertion {
     return subproofUnifies;
   }
 
-  async verify(assignments, context) {
+  async verify(context) {
     let verifies = false;
 
     await this.break(context);
@@ -226,7 +226,7 @@ export default define(class Supposition extends ProofAssertion {
     context.trace(`Verifying the '${suppositionString}' supposition...`);
 
     attempt((context) => {
-      const validates = this.validate(assignments, context);
+      const validates = this.validate(context);
 
       if (validates) {
         this.setContext(context);

package/src/element/proofAssertion.js

@@ -53,17 +53,20 @@ export default class ProofAssertion extends Element {
     return comparesToStatement;
   }
 
-  validateStatement(assignments, context) {
-    let statementValidates;
+  validateStatement(context) {
+    let statementValidates = false;
 
     const statementString = this.statement.getString(),
           proofAssertionString = this.getString();  ///
 
     context.trace(`Validating the '${proofAssertionString}' proof assertion's '${statementString}' statement... `);
 
-    const stated = this.isStated();
+    const stated = this.isStated(),
+          statement = this.statement.validate(stated, context);
 
-    statementValidates = this.statement.validate(assignments, stated, context);
+    if (statement !== null) {
+      statementValidates = true;
+    }
 
     if (statementValidates) {
       context.debug(`...validated the '${proofAssertionString}' proof assertion's '${statementString}' statement. `);

package/src/element/propertyRelation.js

@@ -50,18 +50,24 @@ export default define(class PropertyRelation extends Element {
   }
 
   validateTerm(context) {
-    let termValidates;
+    let termValidates = false;
 
     const termString = this.term.getString();
 
     context.trace(`Validating the '${termString}' term...`);
 
-    termValidates = this.term.validate(context, () => {
+    const term = this.term.validate(context, () => {
       const validatesForwards = true;
 
       return validatesForwards;
     });
 
+    if (term !== null) {
+      this.term = term;
+
+      termValidates = true;
+    }
+
     if (termValidates) {
       context.debug(`...validated the '${termString}' term.`);
     }