occam-verify-cli 1.0.635 → 1.0.638

package/src/context.js

@@ -358,6 +358,12 @@ export default class Context extends ContextBase {
     context.addJudgement(judgement);
   }
 
+  addAssignment(assignment) {
+    const context = this.getContext();
+
+    context.addAssignment(assignment);
+  }
+
   addSubstitution(substitution) {
     const context = this.getContext();
 

package/src/element/assertion/contained.js

@@ -38,30 +38,32 @@ export default define(class ContainedAssertion extends Assertion {
     return containedAssertionNode;
   }
 
-  validate(assignments, stated, context) {
-    let validates = false;
+  validate(stated, context) {
+    let containedAssertion = null;
 
     const containedAssertionString = this.getString(); ///
 
     context.trace(`Validating the '${containedAssertionString}' contained assertion...`);
 
-    const valid = this.isValid(context);
+    const validAssertion = this.findValidAssertion(context);
 
-    if (!valid) {
-      validates = true;
+    if (validAssertion !== null) {
+      containedAssertion = validAssertion;  ///
 
       context.debug(`...the '${containedAssertionString}' contained assertion is already valid.`);
     } else {
-      const termValidates = this.validateTerm(assignments, stated, context),
-            frameVerifies = this.validateFrame(assignments, stated, context),
-            statementValidates = this.validateStatement(assignments, stated, context)
+      let validates = false;
 
-      if (termValidates || frameVerifies || statementValidates) {
+      const termValidates = this.validateTerm(stated, context),
+            frameValidates = this.validateFrame(stated, context),
+            statementValidates = this.validateStatement(stated, context)
+
+      if (termValidates || frameValidates || statementValidates) {
         let validatesWhenStated = false,
             validatesWhenDerived = false;
 
         if (stated) {
-          validatesWhenStated = this.validateWhenStated(assignments, context);
+          validatesWhenStated = this.validateWhenStated(context);
         } else {
           validatesWhenDerived = this.validateWhenDerived(context);
         }
@@ -74,16 +76,18 @@ export default define(class ContainedAssertion extends Assertion {
       if (validates) {
         const assertion = this; ///
 
+        containedAssertion = assertion;  ///
+
         context.addAssertion(assertion);
 
         context.debug(`...validated the '${containedAssertionString}' contained assertion.`);
       }
     }
 
-    return validates;
+    return containedAssertion;
   }
 
-  validateTerm(assignments, stated, context) {
+  validateTerm(stated, context) {
     let termValidates = false;
 
     if (this.term !== null) {
@@ -97,12 +101,18 @@ export default define(class ContainedAssertion extends Assertion {
       if (!termSingular) {
         context.debug(`The '${termString}' term is not singular.`);
       } else {
-        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 '${containedAssertionString}' contained assertino's '${termString}' term.`);
         }
@@ -112,8 +122,8 @@ export default define(class ContainedAssertion extends Assertion {
     return termValidates;
   }
 
-  validateFrame(assignments, stated, context) {
-    let frameVerifies = false;
+  validateFrame(stated, context) {
+    let frameValidates = false;
 
     if (this.frame !== null) {
       const frameString = this.frame.getString(),
@@ -128,20 +138,24 @@ export default define(class ContainedAssertion extends Assertion {
       } else {
         stated = true;  ///
 
-        assignments = null; ///
+        const frame = this.frame.validate(stated, context);
 
-        frameVerifies = this.frame.validate(assignments, stated, context);
+        if (frame !== null) {
+          this.frame = frame;
 
-        if (frameVerifies) {
-          context.debug(`...validated the '${containedAssertionString}' contained assertino's '${frameString}' frame.`);
+          frameValidates = true;
         }
       }
+
+      if (frameValidates) {
+        context.debug(`...validated the '${containedAssertionString}' contained assertino's '${frameString}' frame.`);
+      }
     }
 
-    return frameVerifies;
+    return frameValidates;
   }
 
-  validateStatement(assignments, stated, context) {
+  validateStatement(stated, context) {
     let statementValidates = false;
 
     if (this.statement !== null) {
@@ -151,9 +165,11 @@ export default define(class ContainedAssertion extends Assertion {
 
       stated = true;  ///
 
-      assignments = null; ///
+      const statement = this.statement.validate(stated, context);
 
-      statementValidates = this.statement.validate(assignments, stated, context);
+      if (statement !== null) {
+        statementValidates = true;
+      }
 
       if (statementValidates) {
         context.debug(`...validated the '${statementString}' statement.`);
@@ -163,7 +179,7 @@ export default define(class ContainedAssertion extends Assertion {
     return statementValidates;
   }
 
-  validateWhenStated(assignments, context) {
+  validateWhenStated(context) {
     let validatesWhenStated;
 
     const containedAssertionString = this.getString(); ///

package/src/element/assertion/defined.js

@@ -33,29 +33,31 @@ export default define(class DefinedAssertion extends Assertion {
     return definedAssertionNode;
   }
 
-  validate(assignments, stated, context) {
-    let validates = false;
+  validate(stated, context) {
+    let definedAssertion = null;
 
     const definedAssertionString = this.getString(); ///
 
     context.trace(`Validating the '${definedAssertionString}' defined assertion...`);
 
-    const valid = this.isValid(context);
+    const validAssertion = this.findValidAssertion(context);
 
-    if (valid) {
-      validates = true;
+    if (validAssertion !== null) {
+      definedAssertion = validAssertion;  ///
 
-      context.debug(`...the '${definedAssertionString}' defined assertion is already valid.`);
+      context.debug(`...the '${definedAssertionString}' defined definedAssertion is already valid.`);
     } else {
-      const termValidates = this.validateTerm(assignments, stated, context),
-            frameVerifies = this.validateFrame(assignments, stated, context);
+      let validates = false;
 
-      if (termValidates || frameVerifies) {
+      const termValidates = this.validateTerm(stated, context),
+            frameValidates = this.validateFrame(stated, context);
+
+      if (termValidates || frameValidates) {
         let verifiesWhenStated = false,
             verifiesWhenDerived = false;
 
         if (stated) {
-          verifiesWhenStated = this.validateWhenStated(assignments, context);
+          verifiesWhenStated = this.validateWhenStated(context);
         } else {
           verifiesWhenDerived = this.validateWhenDerived(context);
         }
@@ -68,16 +70,18 @@ export default define(class DefinedAssertion extends Assertion {
       if (validates) {
         const assertion = this; ///
 
+        definedAssertion = assertion; ///
+
         context.addAssertion(assertion);
 
-        context.debug(`...validates the '${definedAssertionString}' defined assertion.`);
+        context.debug(`...validated the '${definedAssertionString}' defined assertion.`);
       }
     }
 
-    return validates;
+    return definedAssertion;
   }
 
-  validateTerm(assignments, stated, context) {
+  validateTerm(stated, context) {
     let termValidates = false;
 
     if (this.term !== null) {
@@ -91,11 +95,17 @@ export default define(class DefinedAssertion extends Assertion {
       if (!termSingular) {
         context.debug(`The '${termString}' term is not singular.`);
       } else {
-        termValidates = this.term.validate(context, () => {
-          const validatesForwards = true;
+        const term = this.term.validate(context, () => {
+                const validatesForwards = true;
 
-          return validatesForwards;
-        });
+                return validatesForwards;
+              });
+
+        if (term !== null) {
+          this.term = term; ///
+
+          termValidates = true;
+        }
 
         if (termValidates) {
           context.debug(`...validates the'${definedAssertionString}' defined assertino's '${termString}' term.`);
@@ -106,8 +116,8 @@ export default define(class DefinedAssertion extends Assertion {
     return termValidates;
   }
 
-  validateFrame(assignments, stated, context) {
-    let frameVerifies = false;
+  validateFrame(stated, context) {
+    let frameValidates = false;
 
     if (this.frame !== null) {
       const frameString = this.frame.getString(), ///
@@ -122,20 +132,24 @@ export default define(class DefinedAssertion extends Assertion {
       } else {
         stated = true;  ///
 
-        assignments = null; ///
+        const frame = this.frame.validate(stated, context);
+
+        if (frame !== null) {
+          this.frame = frame;
 
-        frameVerifies = this.frame.validate(assignments, stated, context);
+          frameValidates = true;
+        }
 
-        if (frameVerifies) {
+        if (frameValidates) {
           context.debug(`...validates the'${definedAssertionString}' defined assertino's '${frameString}' frame.`);
         }
       }
     }
 
-    return frameVerifies;
+    return frameValidates;
   }
 
-  validateWhenStated(assignments, context) {
+  validateWhenStated(context) {
     let verifiesWhenStated;
 
     const definedAssertionString = this.getString(); ///

package/src/element/assertion/property.js

@@ -54,31 +54,33 @@ export default define(class PropertyAssertion extends Assertion {
     return comparesToTermAndPropertyRelation;
   }
 
-  validate(assignments, stated, context) {
-    let validates = false;
+  validate(stated, context) {
+    let propertyAssertion = null;
 
     const propertyAssertionString = this.getString(); ///
 
     context.trace(`Validating the '${propertyAssertionString}' property assertion...`);
 
-    const valid = this.isValid(context);
+    const validAssertion = this.findValidAssertion(context);
 
-    if (valid) {
-      validates = true;
+    if (validAssertion) {
+      propertyAssertion = validAssertion; ///
 
       context.debug(`...the '${propertyAssertionString}' property assertion is already valid.`);
     } else {
-      const termValidates = this.validateTerm(assignments, stated, context);
+      let validates = false;
+
+      const termValidates = this.validateTerm(stated, context);
 
       if (termValidates) {
-        const propertyRelationVerifies = this.validatePropertyRelation(assignments, stated, context);
+        const propertyRelationVerifies = this.validatePropertyRelation(stated, context);
 
         if (propertyRelationVerifies) {
           let validatesWhenStated = false,
               validatesWhenDerived = false;
 
           if (stated) {
-            validatesWhenStated = this.validateWhenStated(assignments, context);
+            validatesWhenStated = this.validateWhenStated(context);
           } else {
             validatesWhenDerived = this.validateWhenDerived(context);
           }
@@ -92,30 +94,38 @@ export default define(class PropertyAssertion extends Assertion {
       if (validates) {
         const assertion = this; ///
 
-        context.addAssertion(assertion);
+        propertyAssertion = assertion;  ///
 
-        this.assign(assignments, stated, context);
+        this.assign(stated, context);
+
+        context.addAssertion(assertion);
 
         context.debug(`...validated the '${propertyAssertionString}' property assertion.`);
       }
     }
 
-    return validates;
+    return propertyAssertion;
   }
 
-  validateTerm(assignments, stated, context) {
-    let termValidates;
+  validateTerm(stated, context) {
+    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.`);
     }
@@ -123,7 +133,7 @@ export default define(class PropertyAssertion extends Assertion {
     return termValidates;
   }
 
-  validatePropertyRelation(assignments, stated, context) {
+  validatePropertyRelation(stated, context) {
     let propertyRelationVerifies;
 
     const propertyRelationString = this.propertyRelation.getString();
@@ -139,7 +149,7 @@ export default define(class PropertyAssertion extends Assertion {
     return propertyRelationVerifies;
   }
 
-  validateWhenStated(assignments, context) {
+  validateWhenStated(context) {
     let validatesWhenStated;
 
     const propertyAssertionString = this.getString(); ///
@@ -171,11 +181,7 @@ export default define(class PropertyAssertion extends Assertion {
     return validatesWhenDerived;
   }
 
-  assign(assignments, stated, context) {
-    if (assignments === null) {
-      return;
-    }
-
+  assign(stated, context) {
     if (!stated) {
       return;
     }
@@ -184,7 +190,7 @@ export default define(class PropertyAssertion extends Assertion {
           variableAssigment = variableAssignmentFromPrepertyAssertion(propertyAssertion, context),
           assignment = variableAssigment; ///
 
-    assignments.push(assignment);
+    context.addAssignment(assignment);
   }
 
   static name = "PropertyAssertion";

package/src/element/assertion/satisfies.js

@@ -31,47 +31,55 @@ export default define(class SatisfiesAssertion extends Assertion {
 
   correlateSubstitutions(substitutions, context) { return this.signature.correlateSubstitutions(substitutions, context); }
 
-  validate(assignments, stated, context) {
-    let validates = false;
+  validate(stated, context) {
+    let satisfiesAssertion = null;
 
     const satisfiesAssertionString = this.getString(); ///
 
     context.trace(`Validating the '${satisfiesAssertionString}' satisfies assertion...`);
 
-    const valid = this.isValid(context);
+    const validAssertion = this.findValidAssertion(context);
 
-    if (valid) {
-      validates = true;
+    if (validAssertion) {
+      satisfiesAssertion = validAssertion; ///
 
-      context.debug(`...the '${satisfiesAssertionString}' satisfies assertion is already valid.`);
+      context.debug(`...the '${satisfiesAssertionString}' satisfies satisfiesAssertion is already valid.`);
     } else {
-      const signatureVerifies = this.validateSignature(assignments, stated, context);
+      let validates = true;
+
+      const signatureVerifies = this.validateSignature(stated, context);
 
       if (signatureVerifies) {
-        const referenceVerifies = this.validateReference(assignments, stated, context);
+        const referenceVerifies = this.validateReference(stated, context);
+
+        if (referenceVerifies) {
+          validates = true;
+        }
 
-        validates = referenceVerifies; ///
+        validates = true;
       }
 
       if (validates) {
         const assertion = this; ///
 
-        context.addAssertion(assertion);
+        satisfiesAssertion = assertion; ///
+
+        context.addAssertion(satisfiesAssertion);
 
         context.debug(`...validated the '${satisfiesAssertionString}' satisfies assertion.`);
       }
     }
 
-    return validates;
+    return satisfiesAssertion;
   }
 
-  validateSignature(assignments, stated, context) {
+  validateSignature(stated, context) {
     const signatureVerifies = this.signature.validate(context);
 
     return signatureVerifies;
   }
 
-  validateReference(assignments, stated, context) {
+  validateReference(stated, context) {
     let referenceVerifies = false;
 
     const referenceString = this.reference.getString(),

package/src/element/assertion/subproof.js

@@ -27,21 +27,23 @@ export default define(class SubproofAssertion extends Assertion {
     return subproofAssertionNode;
   }
 
-  validate(assignments, stated, context) {
-    let validates = false;
+  validate(stated, context) {
+    let subproofAssertion = null;
 
     const subproofAssertionString = this.getString();  ///
 
     context.trace(`Validating the '${subproofAssertionString}' subproof assertion...`);
 
-    const valid = this.isValid(context);
+    const validAssertion = this.findValidAssertion(context);
 
-    if (valid) {
-      validates = true;
+    if (validAssertion) {
+      subproofAssertion = validAssertion; ///
 
       context.debug(`...the '${subproofAssertionString}' subproof assertion is already valid.`);
     } else {
-      const statementsValidate = this.validateStatements(assignments, stated, context);
+      let validates = false;
+
+      const statementsValidate = this.validateStatements(stated, context);
 
       if (statementsValidate) {
         validates = true;
@@ -50,22 +52,28 @@ export default define(class SubproofAssertion extends Assertion {
       if (validates) {
         const assertion = this; ///
 
+        subproofAssertion = assertion;  ///
+
         context.addAssertion(assertion);
 
         context.debug(`...validated the '${subproofAssertionString}' subproof assertion.`);
       }
     }
 
-    return validates;
+    return subproofAssertion;
   }
 
-  validateStatements(assignments, stated, context) {
+  validateStatements(stated, context) {
     stated = true;  ///
 
-    assignments = null; ///
-
     const statementsValidate = this.statements.map((statement) => {
-      const statementValidates = statement.validate(assignments, stated, context);
+      let statementValidates = false;
+
+      statement = statement.validate(stated, context);  ///
+
+      if (statement !== null) {
+        statementValidates = true;
+      }
 
       if (statementValidates) {
         return true;
@@ -75,7 +83,7 @@ export default define(class SubproofAssertion extends Assertion {
     return statementsValidate;
   }
 
-  unifySubproof(subproof, substitutions, generalContext, specificContext) {
+  unifySubproof(subproof, generalContext, specificContext) {
     let subproofUnifies;
 
     const subproofString = subproof.getString(),
@@ -89,7 +97,7 @@ export default define(class SubproofAssertion extends Assertion {
     subproofUnifies = match(subproofAssertionStatements, subproofStatements, (subproofAssertionStatement, subproofStatement) => {
       const generalStatement = subproofAssertionStatement,  ///
             specificStatement = subproofStatement,  ///
-            statementUnifies = unifyStatement(generalStatement, specificStatement, substitutions, generalContext, specificContext);
+            statementUnifies = unifyStatement(generalStatement, specificStatement, generalContext, specificContext);
 
       if (statementUnifies) {
         return true;