occam-verify-cli 1.0.587 → 1.0.602

package/src/element/proofAssertion/premise.js

@@ -1,7 +1,6 @@
 "use strict";
 
 import ProofAssertion from "../proofAssertion";
-import assignAssignments from "../../process/assign";
 
 import { define } from "../../elements";
 import { attempt, liminally } from "../../utilities/context";
@@ -24,90 +23,56 @@ export default define(class Premise extends ProofAssertion {
     return stated;
   }
 
-  async verify(context) {
-    let verifies = false;
-
-    await this.break(context);
+  validate(assignments, context) {
+    let validates = false;
 
     const premiseString = this.getString(); ///
 
-    context.trace(`Verifying the '${premiseString}' premise...`);
+    context.trace(`Validatting the '${premiseString}' premise...`);
 
     const statement = this.getStatement(),
           procedureCall = this.getProcedureCall();
 
-    if ((statement !== null) || (procedureCall !== null)) {
-      attempt((context) => {
-        if (statement !== null) {
-          const assignments = [],
-                statementValidates = this.validateStatement(assignments, context);
-
-          if (statementValidates) {
-            const assignmentsAssigned = assignAssignments(assignments, context);
-
-            if (assignmentsAssigned) {
-              const subproofOrProofAssertion = this;  ///
+    if (false) {
+      ///
+    } else if (statement !== null) {
+      const statementValidates = this.validateStatement(assignments, context);
 
-              context.addSubproofOrProofAssertion(subproofOrProofAssertion);
-
-              this.setContext(context);
-
-              verifies = true;
-            }
-          }
-        }
-
-        if (procedureCall !== null) {
-          const procedureCallValidates = procedureCall.validate(context);
-
-          if (procedureCallValidates) {
-            this.setContext(context);
+      if (statementValidates) {
+        validates = true;
+      }
+    } else if (procedureCall !== null) {
+      const procedureCallValidates = this.validateProcedureCall(assignments, context);
 
-            verifies = true;
-          }
-        }
-      }, context);
+      if (procedureCallValidates) {
+        validates = true;
+      }
     } else {
-      context.debug(`Unable to verify the '${premiseString}' premise because it is nonsense.`);
+      context.debug(`Unable to validate the '${premiseString}' premise because it is nonsense.`);
     }
 
-    if (verifies) {
-      context.debug(`...verified the '${premiseString}' premise.`);
+    if (validates) {
+      context.debug(`...validated the '${premiseString}' premise.`);
     }
 
-    return verifies;
+    return validates;
   }
 
-  async unifyIndependently(context) {
-    let unifiesIndependently = false;
-
-    const premiseString = this.getString(); ///
-
-    context.trace(`Unifying the '${premiseString}' premise independently...`);
-
-    const statement = this.getStatement();
+  validateProcedureCall(assignments, context) {
+    let procedureCallValidates = false;
 
-    if (statement !== null) {
-      const statementUnifiesIndependently = statement.unifyIndependently(context);
+    const premiseString = this.getString(), ///
+          procedureCallString = this.procedureCall.getString();
 
-      if (statementUnifiesIndependently) {
-        unifiesIndependently = true;
-      }
-    }
+    context.trace(`Validatting the '${premiseString}' premise's '${procedureCallString}' procedure call...`);
 
-    if (this.procedureCall !== null) {
-      const procedureCallResolvedIndependently = await this.procedureCall.unifyIndependently(context);
+    procedureCallValidates = this.procedureCall.validate(context);
 
-      if (procedureCallResolvedIndependently) {
-        unifiesIndependently = true;
-      }
+    if (procedureCallValidates) {
+      context.debug(`...validated the '${premiseString}' premise's '${procedureCallString}' procedure call.`);
     }
 
-    if (unifiesIndependently) {
-      context.debug(`...unified the '${premiseString}' premise independenly.`);
-    }
-
-    return unifiesIndependently;
+    return procedureCallValidates;
   }
 
   unifySubproofOrProofAssertion(subproofOrProofAssertion, context) {
@@ -119,12 +84,12 @@ export default define(class Premise extends ProofAssertion {
     context.trace(`Unifying the '${subproofOrProofAssertionString}' subproof or proof assertion with the '${premiseString}' premise...`);
 
     const subproofOrProofAssertionProofAssertion = subproofOrProofAssertion.isProofAssertion(),
-          proofAssertion = subproofOrProofAssertionProofAssertion ?
-                             subproofOrProofAssertion :
-                               null,
-          subproof = subproofOrProofAssertionProofAssertion ?
-                        null :
-                          subproofOrProofAssertion;
+                                                   proofAssertion = subproofOrProofAssertionProofAssertion ?
+                                                                      subproofOrProofAssertion :
+                                                                        null,
+                                                   subproof = subproofOrProofAssertionProofAssertion ?
+                                                                 null :
+                                                                   subproofOrProofAssertion;
 
     if (proofAssertion !== null) {
       const proofAssertionUnifies = this.unifyProofAssertion(proofAssertion, context);
@@ -222,6 +187,73 @@ export default define(class Premise extends ProofAssertion {
     return subproofUnifies;
   }
 
+  async verify(assignments, context) {
+    let verifies = false;
+
+    await this.break(context);
+
+    const premiseString = this.getString();
+
+    context.trace(`Verifying the '${premiseString}' premise...`);
+
+    attempt((context) => {
+      const validates = this.validate(assignments, context);
+
+      if (validates) {
+        this.setContext(context);
+
+        verifies = true;
+      }
+    }, context);
+
+    if (verifies) {
+      context.debug(`...verified the '${premiseString}' premise.`);
+    }
+
+    return verifies;
+  }
+
+  async unifyIndependently(context) {
+    let unifiesIndependently = false;
+
+    const premiseString = this.getString(); ///
+
+    context.trace(`Unifying the '${premiseString}' premise independently...`);
+
+    const statement = this.getStatement(),
+          procedureCall = this.getProcedureCall();
+
+    if (statement !== null) {
+      const specificContext = context;  ///
+
+      context = this.getContext();
+
+      const generalContext = context; ///
+
+      context = specificContext;  ///
+
+      const statementUnifiesIndependently = statement.unifyIndependently(generalContext, specificContext);
+
+      if (statementUnifiesIndependently) {
+        unifiesIndependently = true;
+      }
+    }
+
+    if (procedureCall !== null) {
+      const procedureCallResolvedIndependently = await procedureCall.unifyIndependently(context);
+
+      if (procedureCallResolvedIndependently) {
+        unifiesIndependently = true;
+      }
+    }
+
+    if (unifiesIndependently) {
+      context.debug(`...unified the '${premiseString}' premise independenly.`);
+    }
+
+    return unifiesIndependently;
+  }
+
   toJSON() {
     const procedureCallJSON = procedureCallToProcedureCallJSON(this.procedureCall),
           statementJSON = statementToStatementJSON(this.statement),

package/src/element/proofAssertion/step.js

@@ -59,62 +59,38 @@ export default define(class Step extends ProofAssertion {
     return comparesToTermAndPropertyRelation;
   }
 
-  async verify(assignments, context) {
-    let verifies = false;
-
-    await this.break(context);
+  validate(assignments, context) {
+    let validates = false;
 
     const stepString = this.getString(); ///
 
-    context.trace(`Verifying the '${stepString}' step...`);
+    context.trace(`Validating the '${stepString}' step...`);
 
     const statement = this.getStatement();
 
     if (statement !== null) {
-      asyncAttempt(async (context) => {
-        const referenceValidates = this.validateReference(context);
-
-        if (referenceValidates) {
-          const satisfiesAssertioValidates = this.validateSatisfiesAssertion(context);
-
-          if (satisfiesAssertioValidates) {
-            const statementValidates = this.validateStatement(assignments, context);
+      const referenceValidates = this.validateReference(context);
 
-            if (statementValidates) {
-              const reference = this.getReference(),
-                    satisfiesAssertion = this.getSatisfiesAssertion(),
-                    statementUnifies = await asyncLiminally(async (context) => {
-                      const statementUnifies = await asyncSome(unifyStatements, async (unifyStatement) => {
-                        const statementUnifies = await unifyStatement(statement, reference, satisfiesAssertion, context);
-
-                        if (statementUnifies) {
-                          this.setContext(context);
-
-                          return true;
-                        }
-                      });
+      if (referenceValidates) {
+        const satisfiesAssertioValidates = this.validateSatisfiesAssertion(context);
 
-                      return statementUnifies;
-                    }, context);
+        if (satisfiesAssertioValidates) {
+          const statementValidates = this.validateStatement(assignments, context);
 
-              if (statementUnifies) {
-                verifies = true;
-              }
-            }
+          if (statementValidates) {
+            validates = true;
           }
         }
-
-        return verifies;
-      }, context);
+      }
     } else {
-      context.debug(`Unable to verify the '${stepString}' step because it is nonsense.`);
+      context.debug(`Unable to validate the '${stepString}' step because it is nonsense.`);
     }
 
-    if (verifies) {
-      context.debug(`...verified the '${stepString}' step.`);
+    if (validates) {
+      context.debug(`...validate the '${stepString}' step.`);
     }
 
-    return verifies;
+    return validates;
   }
 
   validateReference(context) {
@@ -190,5 +166,68 @@ export default define(class Step extends ProofAssertion {
     return unifiesWithSatisfiesAssertion;
   }
 
+  async verify(assignments, context) {
+    let verifies = false;
+
+    await this.break(context);
+
+    const stepString = this.getString(); ///
+
+    context.trace(`Verifying the '${stepString}' step...`);
+
+    await asyncAttempt(async (context) => {
+      const validates = this.validate(assignments, context);
+
+      if (validates) {
+        const unifies = await this.unify(context);
+
+        if (unifies) {
+          this.setContext(context);
+
+          verifies = true;
+        }
+      }
+    }, context);
+
+    if (verifies) {
+      context.debug(`...verified the '${stepString}' step.`);
+    }
+
+    return verifies;
+  }
+
+  async unify(context) {
+    let unifies = false;
+
+    const stepString = this.getString(); ///
+
+    context.trace(`Unifying the '${stepString}' step...`);
+
+    const statement = this.getStatement(),
+          reference = this.getReference(),
+          satisfiesAssertion = this.getSatisfiesAssertion(),
+          statementUnifies = await asyncLiminally(async (context) => {
+            const statementUnifies = await asyncSome(unifyStatements, async (unifyStatement) => {
+              const statementUnifies = await unifyStatement(statement, reference, satisfiesAssertion, context);
+
+              if (statementUnifies) {
+                return true;
+              }
+            });
+
+            return statementUnifies;
+          }, context);
+
+    if (statementUnifies) {
+      unifies = true;
+    }
+
+    if (unifies) {
+      context.debug(`...unified the '${stepString}' step.`);
+    }
+
+    return unifies;
+  }
+
   static name = "Step";
 });