occam-verify-cli 1.0.220 → 1.0.224

package/src/dom/step.js

@@ -2,8 +2,8 @@
 
 import dom from "../dom";
 import unifyMixins from "../mixins/step/unify";
-import LocalContext from "../context/local";
 import Substitutions from "../substitutions";
+import equationalUnifier from "../unifier/equantional";
 
 import { domAssigned } from "../dom";
 import { propertyAssertionFromStatement } from "../utilities/context";
@@ -52,29 +52,29 @@ export default domAssigned(class Step {
   }
 
   unify(substitutions, context) {
-    let unified;
+    let unifies;
 
     const stepString = this.string;  ///
 
     context.trace(`Unifying the '${stepString}' step...`);
 
-    unified = unifyMixins.some((unifyMixin) => {
-      const unified = unifyMixin(this.statement, this.reference, substitutions, context);
+    unifies = unifyMixins.some((unifyMixin) => {
+      const unifies = unifyMixin(this.statement, this.reference, substitutions, context);
 
-      if (unified) {
+      if (unifies) {
         return true;
       }
     });
 
-    if (unified) {
+    if (unifies) {
       context.debug(`...unified the '${stepString}' step.`);
     }
 
-    return unified;
+    return unifies;
   }
 
   verify(substitutions, assignments, context) {
-    let verified = false;
+    let verifies = false;
 
     const stepString = this.string; ///
 
@@ -83,77 +83,71 @@ export default domAssigned(class Step {
     if (this.statement !== null) {
       const qualified = this.isQualified(),
             stated = qualified, ///
-            statementVerified = this.statement.verify(assignments, stated, context);
+            statementVerifies = this.statement.verify(assignments, stated, context);
 
-      if (statementVerified) {
+      if (statementVerifies) {
         if (this.reference === null) {
-          verified = true;
+          verifies = true;
         } else {
-          const referenceVerified = this.reference.verify(context);
+          const referenceVerifies = this.reference.verify(context);
 
-          verified = referenceVerified; ///
+          verifies = referenceVerifies; ///
         }
       }
     } else {
       context.debug(`Cannot verify the '${stepString}' step because it is nonsense.`);
     }
 
-    if (verified) {
+    if (verifies) {
       context.debug(`...verified the '${stepString}' step.`);
     }
 
-    return verified;
+    return verifies;
   }
 
-  unifyStatement(statement, context) {
-    let statementUnified;
+  equateWithStatement(statement, context) {
+    let statementEquates;
 
-    const substitutions = Substitutions.fromNothing(),
-          generalContext = context, ///
-          specificContext = context; ///
+    const statementA = statement,  ///
+          statementB = this.statement,  ///
+          statementANode = statementA.getNode(),
+          statementBNode = statementB.getNode(),
+          statementsEquates = equationalUnifier.equateStatements(statementANode, statementBNode, context);
 
-    statementUnified = statement.unifyStatement(this.statement, substitutions, generalContext, specificContext);
+    statementEquates = statementsEquates;  ///
 
-    if (statementUnified) {
-      substitutions.removeTrivialSubstitutions();
-
-      const equivalences = context.getEquivalences(),
-            substitutionsUnified = equivalences.unifySubstitutions(substitutions);
-
-      statementUnified = substitutionsUnified;  ///
-    }
-
-    return statementUnified;
+    return statementEquates;
   }
 
   unifySatisfiesAssertion(satisfiesAssertion, context) {
     let unifySatisfiesAssertion = false;
 
+    const stepString = this.string, ///
+          satisfiesAssertionString = satisfiesAssertion.getString();
+
+    context.trace(`Unifying hte '${satisfiesAssertionString}' with the '${stepString}' step...`);
+
     const reference = satisfiesAssertion.getReference(),
           axiom = context.findAxiomByReference(reference);
 
     if (axiom !== null) {
-      const axiomUnconditional = axiom.isUnconditional();
-
-      if (axiomUnconditional) {
-        const step = this,  ///
-              fileContext = axiom.getFileContext(),
-              localContext = LocalContext.fromFileContext(fileContext),
-              substitutions = Substitutions.fromNothing(),
-              generalContext = localContext,  ///
-              specificContext = context,  ///
-              statementUnified = axiom.unifyStep(step, substitutions, generalContext, specificContext);
-
-        if (statementUnified) {
-          const substitutionsMatch = satisfiesAssertion.matchSubstitutions(substitutions, context);
-
-          if (substitutionsMatch) {
-            unifySatisfiesAssertion = true;
-          }
+      const step = this,  ///
+            substitutions = Substitutions.fromNothing(),
+            stepUnifies = axiom.unifyStep(step, substitutions, context);
+
+      if (stepUnifies) {
+        const substitutionsMatch = satisfiesAssertion.matchSubstitutions(substitutions, context);
+
+        if (substitutionsMatch) {
+          unifySatisfiesAssertion = true;
         }
       }
     }
 
+    if (unifySatisfiesAssertion) {
+      context.debug(`...unified hte '${satisfiesAssertionString}' with the '${stepString}' step.`);
+    }
+
     return unifySatisfiesAssertion;
   }
 

package/src/dom/subDerivation.js

@@ -26,16 +26,16 @@ export default domAssigned(class SubDerivation {
   }
 
   verify(substitutions, context) {
-    let verified;
+    let verifies;
 
-    verified = this.stepsOrSubproofs.every((stepOrSubproof) => { ///
+    verifies = this.stepsOrSubproofs.every((stepOrSubproof) => { ///
       const assignments = [],
-            stepOrSubproofVerified = stepOrSubproof.verify(substitutions, assignments, context);
+            stepOrSubproofVerifies = stepOrSubproof.verify(substitutions, assignments, context);
 
-      if (stepOrSubproofVerified) {
-        const stepOrSubproofUnified = stepOrSubproof.unify(substitutions, context);
+      if (stepOrSubproofVerifies) {
+        const stepOrSubproofUnifies = stepOrSubproof.unify(substitutions, context);
 
-        if (stepOrSubproofUnified) {
+        if (stepOrSubproofUnifies) {
           const assignmentsAssigned = assignAssignments(assignments, context);
 
           if (assignmentsAssigned) {
@@ -47,7 +47,7 @@ export default domAssigned(class SubDerivation {
       }
     });
 
-    return verified;
+    return verifies;
   }
 
   static name = "SubDerivation";

package/src/dom/subproof.js

@@ -55,81 +55,67 @@ export default domAssigned(class Subproof {
   }
 
   unify(substitutions, context) {
-    let unified;
+    let unifies;
 
-    unified = true; ///
+    unifies = true; ///
 
-    return unified;
+    return unifies;
   }
 
   verify(substitutions, assignments, context) {
-    let subproofVerified = false;
+    let subproofVerifies = false;
 
     const localContext = LocalContext.fromContext(context);  ///
 
     context = localContext; ///
 
-    const suppositionsVerified = this.suppositions.every((supposition) => {
-      const suppositionVerified = supposition.verify(context);
+    const suppositionsVerify = this.suppositions.every((supposition) => {
+      const suppositionVerifies = supposition.verify(context);
 
-      if (suppositionVerified) {
+      if (suppositionVerifies) {
         return true;
       }
     });
 
-    if (suppositionsVerified) {
-      const subDerivationVerified = this.subDerivation.verify(substitutions, context);
+    if (suppositionsVerify) {
+      const subDerivationVerifies = this.subDerivation.verify(substitutions, context);
 
-      if (subDerivationVerified) {
-        subproofVerified = true;
+      if (subDerivationVerifies) {
+        subproofVerifies = true;
       }
     }
 
-    return subproofVerified;
+    return subproofVerifies;
   }
 
-  unifyStatement(statement, context) {
-    let statementUnified = false;
+  equateWithStatement(statement, context) {
+    let statementUnifies = false;
 
-    const subproof = this,
-          substitutions = Substitutions.fromNothing(),
-          generalContext = context, ///
-          specificContext = context, ///
-          subproofUnified = statement.unifySubproof(subproof, substitutions, generalContext, specificContext);
+    debugger
 
-    if (subproofUnified) {
-      if (statementUnified) {
-        const equivalences = context.getEquivalences(),
-              substitutionsUnified = equivalences.unifySubstitutions(substitutions);
-
-        if (substitutionsUnified) {
-          statementUnified = true;
-        }
-      }
-    }
-
-    return statementUnified;
+    return statementUnifies;
   }
 
   unifySatisfiesAssertion(satisfiesAssertion, context) {
     let unifySatisfiesAssertion = false;
 
+    const subproofString = this.string, ///
+          satisfiesAssertionString = satisfiesAssertion.getString();
+
+    context.trace(`Unifying the '${satisfiesAssertionString}' satisfies assertion with the '${subproofString}' subproof...`)
+
     const reference = satisfiesAssertion.getReference(),
           axiom = context.findAxiomByReference(reference);
 
     if (axiom !== null) {
-      const axiomUnconditional = axiom.isUnconditional();
+      const axiomSatisfiable = axiom.isSatisfiable();
 
-      if (!axiomUnconditional) {
-        const subproof = this,
-              fileContext = axiom.getFileContext(),
-              localContext = LocalContext.fromFileContext(fileContext),
+      if (axiomSatisfiable) {
+        const subproof = this,  ///
               substitutions = Substitutions.fromNothing(),
-              generalContext = localContext,  ///
-              specificContext = context,  ///
-              statementUnified = axiom.unifySubproof(subproof, substitutions, generalContext, specificContext);
+              statementUnifies = axiom.unifySubproof(subproof, substitutions, context);
 
-        if (statementUnified) {
+        if (statementUnifies) {
           const substitutionsMatch = satisfiesAssertion.matchSubstitutions(substitutions, context);
 
           if (substitutionsMatch) {
@@ -139,6 +125,10 @@ export default domAssigned(class Subproof {
       }
     }
 
+    if (unifySatisfiesAssertion) {
+      context.debug(`...unified the '${satisfiesAssertionString}' satisfies assertion with the '${subproofString}' subproof.`)
+    }
+
     return unifySatisfiesAssertion;
   }
 

package/src/dom/substitution/statement.js

@@ -116,18 +116,18 @@ export default domAssigned(class StatementSubstitution extends Substitution {
 
       specificContext.trace(`Unifying the '${specificSubstitutionString}' substitution with the '${generalSubstitutionString}' substitution...`);
 
-      const substitutionUnified = unifySubstitution(generalSubstitution, specificSubstitution, substitutions, generalContext, specificContext);
+      const substitutionUnifies = unifySubstitution(generalSubstitution, specificSubstitution, substitutions, generalContext, specificContext);
 
 
-      if (substitutionUnified) {
+      if (substitutionUnifies) {
         specificContext.trace(`...unified the '${specificSubstitutionString}' substitution with the '${generalSubstitutionString}' substitution.`);
       }
 
-      substitutionUnified ?
+      substitutionUnifies ?
         substitutions.continue() :
           substitutions.rollback(specificContext);
 
-      substitutionResolved = substitutionUnified;  ///
+      substitutionResolved = substitutionUnifies;  ///
     }
 
     if (substitutionResolved) {
@@ -141,9 +141,9 @@ export default domAssigned(class StatementSubstitution extends Substitution {
     let specificSubstitution = null;
 
     const substitutions = Substitutions.fromNothing(),
-          statementUnified = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
+          statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
 
-    if (statementUnified) {
+    if (statementUnifies) {
       const substitutionsLength = substitutions.getLength();
 
       if (substitutionsLength === 1) {

package/src/dom/substitution/term.js

@@ -33,7 +33,7 @@ export default domAssigned(class TermSubstitution extends Substitution {
   }
 
   isTermEqualTo(term, context) {
-    term = stripBracketsFromTerm(term); ///
+    term = stripBracketsFromTerm(term, context); ///
 
     const termEqualTo = this.term.isEqualTo(term);
 
@@ -51,24 +51,6 @@ export default domAssigned(class TermSubstitution extends Substitution {
 
   matchName(name) { return this.variable.matchName(name); }
 
-  unifyWithEquivalence(equivalence) {
-    let unifiedWithEquivalence;
-
-    const termNode = this.term.getNode(),
-          equivalenceMatchesTermNode = equivalence.matchTermNode(termNode);
-
-    if (equivalenceMatchesTermNode) {
-      const variableNode = this.variable.getNode(),
-            equivalenceMatchesVariableNode = equivalence.matchVariableNode(variableNode);
-
-      if (equivalenceMatchesVariableNode) {
-          unifiedWithEquivalence = true;
-        }
-    }
-
-    return unifiedWithEquivalence;
-  }
-
   static fromStatementNode(statementNode, context) {
     let termSubstitution = null;
 

package/src/dom/substitution.js

@@ -135,13 +135,6 @@ export default class Substitution {
     return resolved;
   }
 
-  match(substitution) {
-    const equalTo = this.isEqualTo(substitution),
-          matches = equalTo;  ///
-
-    return matches;
-  }
-
   matchName(name) {
     const nameMatches = false;
 
@@ -153,10 +146,4 @@ export default class Substitution {
 
     return replacementNode;
   }
-
-  unifyWithEquivalence(equivalence) {
-    let unifiedWithEquivalence = false;
-
-    return unifiedWithEquivalence;
-  }
 }

package/src/dom/supposition.js

@@ -27,7 +27,7 @@ export default domAssigned(class Supposition {
   }
 
   verify(context) {
-    let verified = false;
+    let verifies = false;
 
     const suppositionString = this.string; ///
 
@@ -38,9 +38,9 @@ export default domAssigned(class Supposition {
     } else if (this.statement !== null) {
       const stated = true,
             assignments = [],
-            statementVerified = this.statement.verify(assignments, stated, context);
+            statementVerifies = this.statement.verify(assignments, stated, context);
 
-      if (statementVerified) {
+      if (statementVerifies) {
         const assignmentsAssigned = assignAssignments(assignments, context);
 
         if (assignmentsAssigned) {
@@ -50,30 +50,30 @@ export default domAssigned(class Supposition {
 
           context.addStepOrSubproof(stepOrSubproof);
 
-          verified = true;
+          verifies = true;
         }
       }
     } else if (this.procedureCall !== null) {
       const stated = true,
             assignments = null,
-            procedureCallVerified = this.procedureCall.verify(assignments, stated, context);
+            procedureCallVerifies = this.procedureCall.verify(assignments, stated, context);
 
-      if (procedureCallVerified) {
-        verified = true;
+      if (procedureCallVerifies) {
+        verifies = true;
       }
     } else {
       context.debug(`Unable to verify the '${suppositionString}' supposition because it is nonsense.`);
     }
 
-    if (verified) {
+    if (verifies) {
       context.debug(`...verified the '${suppositionString}' supposition.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   unifySupposition(supposition, substitutions, generalContext, specificContext) {
-    let suppositionUnified;
+    let suppositionUnifies;
 
     const context = specificContext,  ///
           specificSupposition = supposition,  ///
@@ -83,37 +83,37 @@ export default domAssigned(class Supposition {
     context.trace(`Unifying the '${specificSuppositionString}' supposition with the '${generalSuppositionString}' supposition...`);
 
     const statement = specificSupposition.getStatement(),
-          statementUnified = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+          statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
 
-    suppositionUnified = statementUnified;  ///
+    suppositionUnifies = statementUnifies;  ///
 
-    if (suppositionUnified) {
+    if (suppositionUnifies) {
       context.debug(`...unified the '${specificSuppositionString}' supposition with the '${generalSuppositionString}' supposition.`);
     }
 
-    return suppositionUnified;
+    return suppositionUnifies;
   }
 
   unifyIndependently(substitutions, context) {
-    let unifiedIndependently;
+    let unifiesIndependently;
 
     if (this.statement !== null) {
       const statementResolvedIndependently = this.statement.unifyIndependently(substitutions, context);
 
-      unifiedIndependently = statementResolvedIndependently;  ///
+      unifiesIndependently = statementResolvedIndependently;  ///
     }
 
     if (this.procedureCall !== null) {
       const procedureCallResolvedIndependently = this.procedureCall.unifyIndependently(substitutions, context);
 
-      unifiedIndependently = procedureCallResolvedIndependently;  ///
+      unifiesIndependently = procedureCallResolvedIndependently;  ///
     }
 
-    return unifiedIndependently;
+    return unifiesIndependently;
   }
 
   unifyStepOrSubproof(stepOrSubproof, substitutions, generalContext, specificContext) {
-    let stepOrSubproofUnified = false;
+    let stepOrSubproofUnifies = false;
 
     const stepOrSubProofStep = stepOrSubproof.isStep(),
           subproof = stepOrSubProofStep ?
@@ -126,41 +126,41 @@ export default domAssigned(class Supposition {
     substitutions.snapshot();
 
     if (subproof !== null) {
-      const subproofUnified = this.unifySubproof(subproof, substitutions, generalContext, specificContext);
+      const subproofUnifies = this.unifySubproof(subproof, substitutions, generalContext, specificContext);
 
-      stepOrSubproofUnified = subproofUnified; ///
+      stepOrSubproofUnifies = subproofUnifies; ///
     }
 
     if (step !== null) {
-      const statementUnified = this.unifyStep(step, substitutions, generalContext, specificContext);
+      const statementUnifies = this.unifyStep(step, substitutions, generalContext, specificContext);
 
-      stepOrSubproofUnified = statementUnified;  ///
+      stepOrSubproofUnifies = statementUnifies;  ///
     }
 
-    if (stepOrSubproofUnified) {
+    if (stepOrSubproofUnifies) {
       substitutions.resolve(generalContext, specificContext);
     }
 
-    stepOrSubproofUnified ?
+    stepOrSubproofUnifies ?
       substitutions.continue() :
         substitutions.rollback(specificContext);
 
-    return stepOrSubproofUnified;
+    return stepOrSubproofUnifies;
   }
 
   unifyStep(step, substitutions, generalContext, specificContext) {
-    let stepUnified;
+    let stepUnifies;
 
     const statement = step.getStatement(),
-          statementUnified = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+          statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
 
-    stepUnified = statementUnified;  ///
+    stepUnifies = statementUnifies;  ///
 
-    return stepUnified;
+    return stepUnifies;
   }
 
   unifySubproof(subproof, substitutions, generalContext, specificContext) {
-    let subproofUnified = false;
+    let subproofUnifies = false;
 
     const supposition = this, ///
           subproofString = subproof.getString(),
@@ -174,19 +174,19 @@ export default domAssigned(class Supposition {
             subproofAssertion = subproofAssertionFromStatement(this.statement, context);
 
       if (subproofAssertion !== null) {
-        subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);
+        subproofUnifies = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);
       }
     }
 
-    if (subproofUnified) {
+    if (subproofUnifies) {
       specificContext.debug(`...unified the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement.`);
     }
 
-    return subproofUnified;
+    return subproofUnifies;
   }
 
   unifyStatement(statement, substitutions, generalContext, specificContext) {
-    let statementUnified;
+    let statementUnifies;
 
     const supposition = this, ///
           statementString = statement.getString(),
@@ -195,14 +195,14 @@ export default domAssigned(class Supposition {
     specificContext.trace(`Unifying the '${statementString}' statement with the '${suppositionString}' supposition...`);
 
     if (this.statement !== null) {
-      statementUnified = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
+      statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
     }
 
-    if (statementUnified) {
+    if (statementUnifies) {
       specificContext.debug(`...unified the '${statementString}' statement with the '${suppositionString}' supposition.`);
     }
 
-    return statementUnified;
+    return statementUnifies;
   }
 
   toJSON() {

package/src/dom/term.js

@@ -122,30 +122,30 @@ export default domAssigned(class Term {
   }
 
   verify(context, verifyAhead) {
-    let verified;
+    let verifies;
 
     const termString = this.string;  ///
 
     context.trace(`Verifying the '${termString}' term...`);
 
-    verified = verifyMixins.some((verifyMixin) => {
+    verifies = verifyMixins.some((verifyMixin) => {
       const term = this, ///
-            verified = verifyMixin(term, context, verifyAhead);
+            verifies = verifyMixin(term, context, verifyAhead);
 
-      if (verified) {
+      if (verifies) {
         return true;
       }
     });
 
-    if (verified) {
+    if (verifies) {
       context.debug(`...verified the '${termString}' term.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   verifyGivenType(type, generalContext, specificContext) {
-    let verifiedGivenType;
+    let verifiesGivenType;
 
     const typeString = type.getString(),
           termString = this.getString();  ///
@@ -153,25 +153,25 @@ export default domAssigned(class Term {
     specificContext.trace(`Verifying the '${termString}' term given the '${typeString}' type...`);
 
     const context = specificContext, ///
-          verified = this.verify(context, () => {
-            let verifiedAhead;
+          verifies = this.verify(context, () => {
+            let verifiesAhead;
 
             const typeEqualToOrSubTypeOfGivenTypeType = this.type.isEqualToOrSubTypeOf(type);
 
             if (typeEqualToOrSubTypeOfGivenTypeType) {
-              verifiedAhead = true;
+              verifiesAhead = true;
             }
 
-            return verifiedAhead;
+            return verifiesAhead;
           });
 
-    verifiedGivenType = verified; ///
+    verifiesGivenType = verifies; ///
 
-    if (verifiedGivenType) {
+    if (verifiesGivenType) {
       specificContext.debug(`...verified the '${termString}' term given the '${typeString}' type.`);
     }
 
-    return verifiedGivenType;
+    return verifiesGivenType;
   }
 
   toJSON() {