occam-verify-cli 1.0.635 → 1.0.641

package/src/element/derivation.js

@@ -39,11 +39,10 @@ export default define(class Derivation extends Element {
     let verifies;
 
     verifies = await asyncEvery(this.subproofOrProofAssertions, async (subproofOrProofAssertion) => { ///
-      const assignments = [],
-            subproofOrProofAssertionVerifies = await subproofOrProofAssertion.verify(assignments, context);
+      const subproofOrProofAssertionVerifies = await subproofOrProofAssertion.verify(context);
 
       if (subproofOrProofAssertionVerifies) {
-        assignAssignments(assignments, context);
+        context.assignAssignments();
 
         context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 

package/src/element/equality.js

@@ -111,28 +111,30 @@ export default define(class Equality extends Element {
     return equal;
   }
 
-  isValid(context) {
+  findValidEquality(context) {
     const equalityNode = this.getEqualityNode(),
-          equalityPresent = context.isEqualityPresentByEqualityNode(equalityNode),
-          valid = equalityPresent;  ///
+          equality = context.findEqualityByEqualityNode(equalityNode),
+          validEquality = equality;  ///
 
-    return valid;
+    return validEquality;
   }
 
-  validate(assignments, stated, context) {
-    let validates = false;
+  validate(stated, context) {
+    let equality = null;
 
     const equalityString = this.getString(); ///
 
     context.trace(`Validating the '${equalityString}' equality...`);
 
-    const valid = this.isValid(context);
+    const validEquality = this.findValidEquality(context);
 
-    if (valid) {
-      validates = true;
+    if (validEquality !== null) {
+      equality = validEquality; ///
 
       context.debug(`...the '${equalityString}' equality is already valid.`);
     } else {
+      let validates = false;
+
       const termsValidate = this.validateTerms(context);
 
       if (termsValidate) {
@@ -140,7 +142,7 @@ export default define(class Equality extends Element {
             validatesWhenDerived = false;
 
         if (stated) {
-          validatesWhenStated = this.validateWhenStated(assignments, context);
+          validatesWhenStated = this.validateWhenStated(context);
         } else {
           validatesWhenDerived = this.validateWhenDerived(context);
         }
@@ -151,47 +153,58 @@ export default define(class Equality extends Element {
       }
 
       if (validates) {
-        const equality = this;  ///
+        equality = this;  ///
 
-        context.addEquality(equality);
+        this.assign(stated, context);
 
-        this.assign(assignments, stated, context);
+        context.addEquality(equality);
 
         context.debug(`...validated the '${equalityString}' equality.`);
       }
     }
 
-    return validates;
+    return equality;
   }
 
   validateTerms(context) {
-    let termsValidate;
+    let termsValidate = false;
 
     const equalityString = this.getString(); ///
 
     context.trace(`Validating the '${equalityString}' equality's terms...`);
 
-    const leftTermValidates = this.leftTerm.validate(context, () => {
-      let validatesForwards;
+    let leftTerm,
+        rightTerm;
 
-      const rightTermValidates = this.rightTerm.validate(context, () => {
-        let validatesForwards;
+    leftTerm = this.leftTerm.validate(context, () => {
+        let validatesForwards = false;
 
-        const leftTermType = this.leftTerm.getType(),
-              rightTermType = this.rightTerm.getType(),
-              leftTermTypeComparableToRightTermType = leftTermType.isComparableTo(rightTermType);
+        rightTerm = this.rightTerm.validate(context, () => {
+          const validatesForwards = true;
 
-        validatesForwards = leftTermTypeComparableToRightTermType;  ///
+          return validatesForwards;
+        });
+
+        if (rightTerm !== null) {
+          validatesForwards = true;
+        }
 
         return validatesForwards;
       });
 
-      validatesForwards = rightTermValidates; ///
+    if (leftTerm !== null) {
+      const leftTermType = leftTerm.getType(),
+            rightTermType = rightTerm.getType(),
+            leftTermTypeComparableToRightTermType = leftTermType.isComparableTo(rightTermType);
 
-      return validatesForwards;
-    });
+      if (leftTermTypeComparableToRightTermType) {
+        this.leftTerm = leftTerm;
 
-    termsValidate = leftTermValidates; ///
+        this.rightTerm = rightTerm;
+
+        termsValidate = true;
+      }
+    }
 
     if (termsValidate) {
       context.debug(`...validated the '${equalityString}' equality's terms.`);
@@ -200,7 +213,7 @@ export default define(class Equality extends Element {
     return termsValidate;
   }
 
-  validateWhenStated(assignments, context) {
+  validateWhenStated(context) {
     let validatesWhenStated;
 
     const equalityString = this.getString(); ///
@@ -232,11 +245,7 @@ export default define(class Equality extends Element {
     return validatesWhenDerived;
   }
 
-  assign(assignments, stated, context) {
-    if (assignments === null) {
-      return;
-    }
-
+  assign(stated, context) {
     const equality = this,  ///
           equalityAssignment = equalityAssignmentFromEquality(equality, context),
           leftVariableAssignment = leftVariableAssignmentFromEquality(equality, context),
@@ -246,18 +255,18 @@ export default define(class Equality extends Element {
 
     assignment = equalityAssignment; ///
 
-    assignments.push(assignment);
+    context.addAssignment(assignment);
 
     if (leftVariableAssignment !== null) {
       assignment = leftVariableAssignment;  ///
 
-      assignments.push(assignment);
+      context.addAssignment(assignment);
     }
 
     if (rightVariableAssignment !== null) {
       assignment = rightVariableAssignment;  ///
 
-      assignments.push(assignment);
+      context.addAssignment(assignment);
     }
   }
 

package/src/element/frame.js

@@ -56,12 +56,12 @@ 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) {
@@ -165,29 +165,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 +201,7 @@ export default define(class Frame extends Element {
       }
 
       if (validates) {
-        const frame = this; ///
+        frame = this; ///
 
         context.addFrame(frame);
 
@@ -206,10 +209,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 +250,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 +263,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);
+
+        if (assumptionValidates) {
+          assumptions.push(assumption);
 
-        return assumptionVerifies;
+          return true;
+        }
       });
 
       if (assumptionsValidate) {
+        this.assumptions = assumptions;
+
         context.debug(`...validated the '${assumptionsString}' assumptions of the '${frameString}' frame.`);
       }
     } else {
@@ -278,7 +287,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 +322,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 +333,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);
           }
@@ -95,7 +97,7 @@ export default define(class Judgement extends Element {
       }
 
       if (validates) {
-        const judgement = this; ///
+        judgement = this; ///
 
         context.addJudgement(judgement)
 
@@ -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);