occam-verify-cli 1.0.587 → 1.0.602

package/src/element/proofAssertion/supposition.js

@@ -1,10 +1,9 @@
 "use strict";
 
 import ProofAssertion from "../proofAssertion";
-import assignAssignments from "../../process/assign";
 
 import { define } from "../../elements";
-import { attempt } from "../../utilities/context";
+import { attempt, liminally } from "../../utilities/context";
 import { statementFromJSON, procedureCallFromJSON, statementToStatementJSON, procedureCallToProcedureCallJSON } from "../../utilities/json";
 
 export default define(class Supposition extends ProofAssertion {
@@ -24,161 +23,142 @@ export default define(class Supposition extends ProofAssertion {
     return stated;
   }
 
-  async verify(context) {
-    let verifies = false;
-
-    await this.break(context);
+  validate(assignments, context) {
+    let validates = false;
 
     const suppositionString = this.getString(); ///
 
-    context.trace(`Verifying the '${suppositionString}' supposition...`);
+    context.trace(`Validatting the '${suppositionString}' supposition...`);
 
     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 (false) {
+      ///
+    } else if (statement !== null) {
+      const statementValidates = this.validateStatement(assignments, context);
 
-          if (statementValidates) {
-            const assignmentsAssigned = assignAssignments(assignments, context);
+      if (statementValidates) {
+        validates = true;
+      }
+    } else if (procedureCall !== null) {
+      const procedureCallValidates = this.validateProcedureCall(assignments, context);
 
-            if (assignmentsAssigned) {
-              const subproofOrProofAssertion = this;  ///
+      if (procedureCallValidates) {
+        validates = true;
+      }
+    } else {
+      context.debug(`Unable to validate the '${suppositionString}' supposition because it is nonsense.`);
+    }
 
-              context.addSubproofOrProofAssertion(subproofOrProofAssertion);
+    if (validates) {
+      context.debug(`...validated the '${suppositionString}' supposition.`);
+    }
 
-              this.setContext(context);
+    return validates;
+  }
 
-              verifies = true;
-            }
-          }
-        }
+  validateProcedureCall(assignments, context) {
+    let procedureCallValidates = false;
 
-        if (procedureCall !== null) {
-          const procedureCallValidates = procedureCall.validate(context);
+    const suppositionString = this.getString(), ///
+          procedureCallString = this.procedureCall.getString();
 
-          if (procedureCallValidates) {
-            this.setContext(context);
+    context.trace(`Validatting the '${suppositionString}' supposition's '${procedureCallString}' procedure call...`);
 
-            verifies = true;
-          }
-        }
-      }, context);
-    } else {
-      context.debug(`Unable to verify the '${suppositionString}' supposition because it is nonsense.`);
-    }
+    procedureCallValidates = this.procedureCall.validate(context);
 
-    if (verifies) {
-      context.debug(`...verified the '${suppositionString}' supposition.`);
+    if (procedureCallValidates) {
+      context.debug(`...validated the '${suppositionString}' supposition's '${procedureCallString}' procedure call.`);
     }
 
-    return verifies;
+    return procedureCallValidates;
   }
 
-  unifyIndependently(substitutions, context) {
-    let unifiesIndependently = false;
+  unifySupposition(supposition, generalContext, specificContext) {
+    let suppositionUnifies;
 
-    const suppositionString = this.getString(); ///
+    const context = specificContext,  ///
+      specificSupposition = supposition,  ///
+      generalSuppositionString = this.getString(), ///
+      specificSuppositionString = specificSupposition.getString();
 
-    context.trace(`Unifying the '${suppositionString}' supposition independently...`);
+    context.trace(`Unifying the '${specificSuppositionString}' supposition with the '${generalSuppositionString}' supposition...`);
 
-    const statement = this.getStatement();
+    const statement = specificSupposition.getStatement(),
+      statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
 
-    if (statement !== null) {
-      const statementUnifiesIndependently = statement.unifyIndependently(context);
+    suppositionUnifies = statementUnifies;  ///
 
-      if (statementUnifiesIndependently) {
-        unifiesIndependently = true;
-      }
+    if (suppositionUnifies) {
+      context.debug(`...unified the '${specificSuppositionString}' supposition with the '${generalSuppositionString}' supposition.`);
     }
 
-    if (this.procedureCall !== null) {
-      const procedureCallResolvedIndependently = this.procedureCall.unifyIndependently(context);
-
-      if (procedureCallResolvedIndependently) {
-        unifiesIndependently = true;
-      }
-    }
+    return suppositionUnifies;
+  }
 
-    if (unifiesIndependently) {
-      context.debug(`...unified the '${suppositionString}' supposition independenly.`);
-    }
+  unifySubproofOrProofAssertion(subproofOrProofAssertion, context) {
+    let subproofOrProofAssertionUnifies;
 
-    return unifiesIndependently;
-  }
+    const suppositionString = this.getString(), ///
+          subproofOrProofAssertionString = subproofOrProofAssertion.getString();
 
-  unifySubproofOrProosAssertion(subproofOrProofAssertion, substitutions, context) {
-    let subproofOrProofAssertionUnifies = false;
+    context.trace(`Unifying the '${subproofOrProofAssertionString}' subproof or proof assertion with the '${suppositionString}' supposition...`);
 
     const subproofOrProofAssertionProofAssertion = subproofOrProofAssertion.isProofAssertion(),
-          subproof = subproofOrProofAssertionProofAssertion ?
-                        null :
-                          subproofOrProofAssertion,
-          proofAssertion = subproofOrProofAssertionProofAssertion ?
-                             subproofOrProofAssertion :
-                               null;
-
-    substitutions.snapshot(context);
+                                                   proofAssertion = subproofOrProofAssertionProofAssertion ?
+                                                                      subproofOrProofAssertion :
+                                                                        null,
+                                                   subproof = subproofOrProofAssertionProofAssertion ?
+                                                                null :
+                                                                  subproofOrProofAssertion;
 
-    if (subproof !== null) {
-      const subproofUnifies = this.unifySubproof(subproof, substitutions, context);
+    if (proofAssertion !== null) {
+      const proofAssertionUnifies = this.unifyProofAssertion(proofAssertion, context);
 
-      if (subproofUnifies) {
+      if (proofAssertionUnifies) {
         subproofOrProofAssertionUnifies = true;
       }
     }
 
-    if (proofAssertion !== null) {
-      const proofAssertionUnifies = this.unifyProofAssertion(proofAssertion, substitutions, context);
+    if (subproof !== null) {
+      const subproofUnifies = this.unifySubproof(subproof, context);
 
-      if (proofAssertionUnifies) {
+      if (subproofUnifies) {
         subproofOrProofAssertionUnifies = true;
       }
     }
 
     if (subproofOrProofAssertionUnifies) {
-      substitutions.resolve(context);
+      context.debug(`...unified the '${subproofOrProofAssertionString}' subproof or proof assertion with the '${suppositionString}' supposition.`);
     }
 
-    subproofOrProofAssertionUnifies ?
-      substitutions.continue(context) :
-        substitutions.rollback(context);
-
     return subproofOrProofAssertionUnifies;
   }
 
-  unifyProofAssertion(proofAssertion, substitutions, context) {
-    let proofAssertionUnifies = false;
+  unifyProofAssertion(proofAssertion, context) {
+    let proofAssertionUnifies;
 
     const suppositionString = this.getString(), ///
           proofAssertionString = proofAssertion.getString();
 
     context.trace(`Unifying the '${proofAssertionString}' proof assertion with the '${suppositionString}' supposition...`);
 
-    const specificContext = context;  ///
-
-    context = this.getContext();
-
-    const generalContext = context; ///
-
-    context = specificContext;  ///
+    const proofAssertionContext = proofAssertion.getContext(),
+          suppositionContext = this.getContext(),
+          generalContext = suppositionContext, ///
+          specificContext = proofAssertionContext; ///
 
-    debugger
+    proofAssertionUnifies = liminally((specificContext) => {
+      const statement = proofAssertion.getStatement(),
+            statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
 
-    // const proofAssertionContext = proofAssertion.getContext(),
-    //       statementUnifies = synthetically((specificContext) => {
-    //         const statement = proofAssertion.getStatement(),
-    //               statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
-    //
-    //         return statementUnifies;
-    //       }, specificContext, proofAssertionContext);
+      if (statementUnifies) {
+        specificContext.commit(context);
 
-    if (statementUnifies) {
-      proofAssertionUnifies = true;
-    }
+        return true;
+      }
+    }, specificContext);
 
     if (proofAssertionUnifies) {
       context.debug(`...unified the '${proofAssertionString}' proof assertion with the '${suppositionString}' supposition.`);
@@ -187,11 +167,11 @@ export default define(class Supposition extends ProofAssertion {
     return proofAssertionUnifies;
   }
 
-  unifySubproof(subproof, substitutions, context) {
+  unifySubproof(subproof, context) {
     let subproofUnifies = false;
 
-    const subproofString = subproof.getString(),
-          suppositionString = this.getString(); ///
+    const suppositionString = this.getString(),
+          subproofString = subproof.getString();
 
     context.trace(`Unifying the '${subproofString}' subproof with the '${suppositionString}' supposition...`);
 
@@ -229,26 +209,71 @@ export default define(class Supposition extends ProofAssertion {
     return subproofUnifies;
   }
 
-  unifySupposition(supposition, substitutions, generalContext, specificContext) {
-    let suppositionUnifies;
+  async verify(assignments, context) {
+    let verifies = false;
 
-    const context = specificContext,  ///
-          specificSupposition = supposition,  ///
-          generalSuppositionString = this.getString(), ///
-          specificSuppositionString = specificSupposition.getString();
+    await this.break(context);
 
-    context.trace(`Unifying the '${specificSuppositionString}' supposition with the '${generalSuppositionString}' supposition...`);
+    const suppositionString = this.getString(); ///
 
-    const statement = specificSupposition.getStatement(),
-          statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+    context.trace(`Verifying the '${suppositionString}' supposition...`);
 
-    suppositionUnifies = statementUnifies;  ///
+    attempt((context) => {
+      const validates = this.validate(assignments, context);
 
-    if (suppositionUnifies) {
-      context.debug(`...unified the '${specificSuppositionString}' supposition with the '${generalSuppositionString}' supposition.`);
+      if (validates) {
+        this.setContext(context);
+
+        verifies = true;
+      }
+    }, context);
+
+    if (verifies) {
+      context.debug(`...verified the '${suppositionString}' supposition.`);
     }
 
-    return suppositionUnifies;
+    return verifies;
+  }
+
+  async unifyIndependently(context) {
+    let unifiesIndependently = false;
+
+    const suppositionString = this.getString(); ///
+
+    context.trace(`Unifying the '${suppositionString}' supposition 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 '${suppositionString}' supposition independenly.`);
+    }
+
+    return unifiesIndependently;
   }
 
   toJSON() {
@@ -287,3 +312,4 @@ export default define(class Supposition extends ProofAssertion {
     return supposition;
   }
 });
+

package/src/element/proofAssertion.js

@@ -65,7 +65,7 @@ export default class ProofAssertion extends Element {
     return statementValidates;
   }
 
-  unifyStatement(statement, substitutions, generalContext, specificContext) {
+  unifyStatement(statement, generalContext, specificContext) {
     let statementUnifies = false;
 
     if (this.statement !== null) {
@@ -74,7 +74,8 @@ export default class ProofAssertion extends Element {
             proofAssertionString = this.getString();  ///
 
       context.trace(`Unifying the '${statementString}' statement with the '${proofAssertionString}' proof assertion...`);
-      statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
+
+      statementUnifies = this.statement.unifyStatement(statement, generalContext, specificContext);
 
       if (statementUnifies) {
         context.debug(`...unified the '${statementString}' statement with the '${proofAssertionString}' proof assertion.`);

package/src/element/reference.js

@@ -34,15 +34,37 @@ export default define(class Reference extends Element {
     return metavariableNode;
   }
 
-  isMetavariableEqualToMetavariable(metavariable) { return this.metavariable.isEqualTo(metavariable); }
+  getReferenceNode() {
+    const node = this.getNode(),
+          assertionNode = node; ///
 
-  isEqualTo(reference) {
-    const referenceA = this, ///
-          referenceB = reference, ///
-          referenceANode = referenceA.getNode(),
-          referenceBNode = referenceB.getNode(),
-          referenceANodeMatchesReferenceBNode = referenceANode.match(referenceBNode),
-          equalTo = referenceANodeMatchesReferenceBNode; ///
+    return assertionNode;
+  }
+
+  matchReferenceNode(assertionNode) {
+    const assertionNodeA = assertionNode; ///
+
+    assertionNode = this.getReferenceNode();
+
+    const assertionNodeB = assertionNode, ///
+          assertionNodeAAMatchesReferenceBNodeB = assertionNodeA.match(assertionNodeB),
+          equalTo = assertionNodeAAMatchesReferenceBNodeB; ///
+
+    return equalTo;
+  }
+
+  isValid(context) {
+    const assertionNode = this.getReferenceNode(),
+          assertionPresent = context.isReferencePresentByReferenceNode(assertionNode),
+          valid = assertionPresent;  ///
+
+    return valid;
+  }
+
+  isEqualTo(assertion) {
+    const assertionNode = assertion.getNode(),
+          assertionNodeMatches = this.matchReferenceNode(assertionNode),
+          equalTo = assertionNodeMatches;  ///
 
     return equalTo;
   }
@@ -63,6 +85,26 @@ export default define(class Reference extends Element {
     return comparesToParamter;
   }
 
+  compareMetavariable(metavariable) {
+    let metavaraibleComparseTo = false;
+
+    let metavariableName;
+
+    metavariableName = this.metavariable.getName();
+
+    const metavariableNameA = metavariableName ///
+
+    metavariableName = metavariable.getName();
+
+    const metavariableNameB = metavariableName; ///
+
+    if (metavariableNameA === metavariableNameB) {
+      metavaraibleComparseTo = true;
+    }
+
+    return metavaraibleComparseTo;
+  }
+
   compareMetavariableName(metavariableName) { return this.metavariable.compareMetavariableName(metavariableName); }
 
   matchMetavariableNode(metavariableNode) { return this.metavariable.matchNode(metavariableNode); }
@@ -105,7 +147,7 @@ export default define(class Reference extends Element {
   validateMetavariable(context) {
     let metavariableValidates = false;
 
-    const referenceString = this.getString(),
+    const referenceString = this.getString(), ///
           metavariableString = this.metavariable.getString();
 
     context.trace(`Validating the '${referenceString}' reference's '${metavariableString}' metavariable....'`);
@@ -131,7 +173,7 @@ export default define(class Reference extends Element {
   validateAsMetavariable(context) {
     let validatesAsMetavariable = false;
 
-    const referenceString = this.getString();
+    const referenceString = this.getString(); ///
 
     context.trace(`Validating the '${referenceString}' reference as a metavaraible...`);