occam-verify-cli 1.0.220 → 1.0.224

package/src/dom/assertion/satisfies.js

@@ -35,42 +35,38 @@ export default domAssigned(class SatisfiesAssertion {
     return this.reference;
   }
 
-  matchSubstitutions(substitutions, context) {
-    const substitutionsMatch = this.signature.matchSubstitutions(substitutions, context);
-
-    return substitutionsMatch;
-  }
+  correlateSubstitutions(substitutions, context) { return this.signature.correlateSubstitutions(substitutions, context); }
 
   verify(assignments, stated, context) {
-    let verified = false;
+    let verifies = false;
 
     const satisfiesAssertionString = this.string; ///
 
     context.trace(`Verifying the '${satisfiesAssertionString}' satisfies assertion...`);
 
-    const signatureVerified = this.verifySignature(assignments, stated, context);
+    const signatureVerifies = this.verifySignature(assignments, stated, context);
 
-    if (signatureVerified) {
-      const referenceVerified = this.verifyReference(assignments, stated, context);
+    if (signatureVerifies) {
+      const referenceVerifies = this.verifyReference(assignments, stated, context);
 
-      verified = referenceVerified; ///
+      verifies = referenceVerifies; ///
     }
 
-    if (verified) {
+    if (verifies) {
       context.debug(`...verified the '${satisfiesAssertionString}' satisfies assertion.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   verifySignature(assignments, stated, context) {
-    const signatureVerified = this.signature.verify(context);
+    const signatureVerifies = this.signature.verify(context);
 
-    return signatureVerified;
+    return signatureVerifies;
   }
 
   verifyReference(assignments, stated, context) {
-    let referenceVerified = false;
+    let referenceVerifies = false;
 
     const referenceString = this.reference.getString();
 
@@ -82,19 +78,19 @@ export default domAssigned(class SatisfiesAssertion {
       const axiomSatisfiable = axiom.isSatisfiable();
 
       if (axiomSatisfiable) {
-        referenceVerified = true;
+        referenceVerifies = true;
       }
     }
 
-    if (referenceVerified) {
+    if (referenceVerifies) {
       context.debug(`...verified the '${referenceString}' reference.`);
     }
 
-    return referenceVerified;
+    return referenceVerifies;
   }
 
   unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, context) {
-    let statementUnified = false;
+    let statementUnifies = false;
 
     const statementString = statement.getString(),
           satisfiesAssertionString = this.string; ///
@@ -118,24 +114,29 @@ export default domAssigned(class SatisfiesAssertion {
 
         substitutions = Substitutions.fromNothing();
 
-        statementUnified = axiom.unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, substitutions, context);
+        statementUnifies = axiom.unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, substitutions, context);
 
-        if (statementUnified) {
+        if (statementUnifies) {
           const substitutionsA = substitutions, ///
-                substitutionsMatch = substitutionsB.matchSubstitutions(substitutionsA);
+                substitutionsMatch = substitutionsA.correlateSubstitutions(substitutionsB);
 
           if (!substitutionsMatch) {
-            statementUnified = false;
+            const substitutionsAString = substitutionsA.asString(),
+                  substitutionsBString = substitutionsB.asString();
+
+            context.trace(`THe signature's ${substitutionsBString} substitutions do not correlate with the unification's ${substitutionsAString} substitutions.`);
+
+            statementUnifies = false;
           }
         }
       }
     }
 
-    if (statementUnified) {
+    if (statementUnifies) {
       context.debug(`...unified the '${statementString}' statement with the '${satisfiesAssertionString}' satisfies assertion.`);
     }
 
-    return statementUnified;
+    return statementUnifies;
   }
 
   static name = "SatisfiesAssertion";

package/src/dom/assertion/subproof.js

@@ -29,7 +29,7 @@ export default domAssigned(class SubproofAssertion {
   }
 
   unifySubproof(subproof, substitutions, generalContext, specificContext) {
-    let subproofUnified;
+    let subproofUnifies;
 
     const subproofString = subproof.getString(),
           subproofAssertionString = this.string;  ///
@@ -39,39 +39,39 @@ export default domAssigned(class SubproofAssertion {
     const subproofStatements = subproof.getStatements(),
           subproofAssertionStatements = this.statements;  ///
 
-    subproofUnified = match(subproofAssertionStatements, subproofStatements, (subproofAssertionStatement, subproofStatement) => {
+    subproofUnifies = match(subproofAssertionStatements, subproofStatements, (subproofAssertionStatement, subproofStatement) => {
       const generalStatement = subproofAssertionStatement,  ///
             specificStatement = subproofStatement,  ///
-            statementUnified = unifyStatement(generalStatement, specificStatement, substitutions, generalContext, specificContext);
+            statementUnifies = unifyStatement(generalStatement, specificStatement, substitutions, generalContext, specificContext);
 
-      if (statementUnified) {
+      if (statementUnifies) {
         return true;
       }
     });
 
-    if (subproofUnified) {
+    if (subproofUnifies) {
       specificContext.debug(`...unified the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion.`);
     }
 
-    return subproofUnified;
+    return subproofUnifies;
   }
 
   verify(assignments, stated, context) {
-    let verified;
+    let verifies;
 
     const subproofAssertionString = this.string;  ///
 
     context.trace(`Verifying the '${subproofAssertionString}' subproof assertion...`);
 
-    const statementsVerified = this.verifyStatements(assignments, stated, context);
+    const statementsVerify = this.verifyStatements(assignments, stated, context);
 
-    verified = statementsVerified;  ///
+    verifies = statementsVerify;  ///
 
-    if (verified) {
+    if (verifies) {
       context.debug(`...verified the '${subproofAssertionString}' subproof assertion.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   verifyStatements(assignments, stated, context) {
@@ -79,15 +79,15 @@ export default domAssigned(class SubproofAssertion {
 
     assignments = null; ///
 
-    const statementsVerified = this.statements.map((statement) => {
-      const statementVerified = statement.verify(assignments, stated, context);
+    const statementsVerify = this.statements.map((statement) => {
+      const statementVerifies = statement.verify(assignments, stated, context);
 
-      if (statementVerified) {
+      if (statementVerifies) {
         return true;
       }
     });
 
-    return statementsVerified;
+    return statementsVerify;
   }
 
   static name = "SubproofAssertion";

package/src/dom/assertion/type.js

@@ -25,42 +25,44 @@ export default domAssigned(class TypeAssertion {
   }
 
   verify(assignments, stated, context) {
-    let verified = false;
+    let verifies = false;
 
     let typeAssertionString = this.string;  ///
 
     context.trace(`Verifying the '${typeAssertionString}' type assertion...`);
 
-    const typeVerified = this.verifyType(context);
+    const typeVerifies = this.verifyType(context);
 
-    if (typeVerified) {
-      let verifiedWhenStated = false,
-          verifiedWhenDerived = false;
+    if (typeVerifies) {
+      let verifiesWhenStated = false,
+          verifiesWhenDerived = false;
 
       if (stated) {
-        verifiedWhenStated = this.verifyWhenStated(assignments, context);
+        verifiesWhenStated = this.verifyWhenStated(assignments, context);
       } else {
-        verifiedWhenDerived = this.verifyWhenDerived(context);
+        verifiesWhenDerived = this.verifyWhenDerived(context);
       }
 
-      verified = verifiedWhenStated || verifiedWhenDerived;
+      if (verifiesWhenStated || verifiesWhenDerived) {
+        verifies = true;
+      }
     }
 
-    if (verified) {
+    if (verifies) {
       if (stated) {
         this.assign(assignments, context);
       }
     }
 
-    if (verified) {
+    if (verifies) {
       context.debug(`...verified the '${typeAssertionString}' type assertion.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   verifyType(context) {
-    let typeVerified;
+    let typeVerifies;
 
     const typeString = this.type.getString();
 
@@ -71,58 +73,58 @@ export default domAssigned(class TypeAssertion {
     if (type !== null) {
       this.type = type;
 
-      typeVerified = true;
+      typeVerifies = true;
     } else {
       context.debug(`The '${typeString}' type is not present.`);
     }
 
-    if (typeVerified) {
+    if (typeVerifies) {
       context.debug(`...verified the '${typeString}' type.`);
     }
 
-    return typeVerified;
+    return typeVerifies;
   }
 
   verifyWhenStated(assignments, context) {
-    let verifiedWhenStated = false;
+    let verifiesWhenStated = false;
 
     const typeAssertionString = this.string; ///
 
     context.trace(`Verifying the '${typeAssertionString}' stated type assertion...`);
 
-    const termVerified = this.term.verify(context, () => {
-      let verifiedAhead;
+    const termVerifies = this.term.verify(context, () => {
+      let verifiesAhead;
 
       const termType = this.term.getType(),
             typeEqualToOrSubTypeOfTermType = this.type.isEqualToOrSubTypeOf(termType);
 
       if (typeEqualToOrSubTypeOfTermType) {
-        verifiedAhead = true;
+        verifiesAhead = true;
       }
 
-      return verifiedAhead;
+      return verifiesAhead;
     });
 
-    if (termVerified) {
-      verifiedWhenStated = true;
+    if (termVerifies) {
+      verifiesWhenStated = true;
     }
 
-    if (verifiedWhenStated) {
+    if (verifiesWhenStated) {
       context.debug(`...verified the '${typeAssertionString}' stated type assertion.`);
     }
 
-    return verifiedWhenStated;
+    return verifiesWhenStated;
   }
 
   verifyWhenDerived(context) {
-    let verifiedWhenDerived;
+    let verifiesWhenDerived;
 
     const typeAssertionString = this.string; ///
 
     context.trace(`Verifying the '${typeAssertionString}' derived type assertion...`);
 
-    const termVerified = this.term.verify(context, () => {
-      let verifiedAhead = false;
+    const termVerifies = this.term.verify(context, () => {
+      let verifiesAhead = false;
 
       const termType = this.term.getType(),
             termTypeProvisional = termType.isProvisional();
@@ -130,19 +132,19 @@ export default domAssigned(class TypeAssertion {
       if (!termTypeProvisional) {
         const typeEqualToOrSuperTypeOfTermType = this.type.isEqualToOrSuperTypeOf(termType);
 
-        verifiedAhead = typeEqualToOrSuperTypeOfTermType; ///
+        verifiesAhead = typeEqualToOrSuperTypeOfTermType; ///
       }
 
-      return verifiedAhead;
+      return verifiesAhead;
     });
 
-    verifiedWhenDerived = termVerified; ///
+    verifiesWhenDerived = termVerifies; ///
 
-    if (verifiedWhenDerived) {
+    if (verifiesWhenDerived) {
       context.debug(`...verified the '${typeAssertionString}' derived type assertion.`);
     }
 
-    return verifiedWhenDerived;
+    return verifiesWhenDerived;
   }
 
   assign(assignments, context) {

package/src/dom/axiom.js

@@ -14,7 +14,7 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
   }
 
   verify() {
-    let verified;
+    let verifies;
 
     const axiom = this, ///
           axiomString = axiom.getString(),
@@ -22,13 +22,13 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
 
     fileContext.trace(`Verifying the '${axiomString}' axiom...`);
 
-    const signatureVerified = this.verifySignature();
+    const signatureVerifies = this.verifySignature();
 
-    if (signatureVerified) {
-      verified = super.verify();
+    if (signatureVerifies) {
+      verifies = super.verify();
     }
 
-    if (verified) {
+    if (verifies) {
       const axiom = this; ///
 
       fileContext.addAxiom(axiom);
@@ -36,11 +36,11 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
       fileContext.debug(`...verified the '${axiomString}' axiom.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   verifySignature() {
-    let signatureVerified = true;
+    let signatureVerifies = true;
 
     const satisfiable = this.isSatisfiable();
 
@@ -50,10 +50,10 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
             localContext = LocalContext.fromFileContext(fileContext),
             context = localContext; ///
 
-      signatureVerified = signature.verify(context);
+      signatureVerifies = signature.verify(context);
     }
 
-    return signatureVerified;
+    return signatureVerifies;
   }
 
   matchSignature(signature, substitutions, context) {
@@ -79,31 +79,30 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
     return signatureMatches;
   }
 
-  unifyStep(step, substitutions, generalContext, specificContext) {
-    let stepUnified = false;
+  unifyStep(step, substitutions, context) {
+    let stepUnifies = false;
 
-    const context = specificContext,  ///
-          stepString = step.getString(),
+    const stepString = step.getString(),
           axiomString = this.string;  ///
 
     context.trace(`Unifying the '${stepString}' step with the '${axiomString}' axiom...`);
 
     const statement = step.getStatement(),
-          statementUnified = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+          statementUnifies = this.unifyStatement(statement, substitutions, context);
 
-    if (statementUnified) {
-      stepUnified = true;
+    if (statementUnifies) {
+      stepUnifies = true;
     }
 
-    if (stepUnified) {
+    if (stepUnifies) {
       context.debug(`...unified the '${stepString}' step with the '${axiomString}' axiom.`);
     }
 
-    return stepUnified;
+    return stepUnifies;
   }
 
   unifyLastStep(lastStep, substitutions, generalContext, specificContext) {
-    let lastStepUnified = false;
+    let lastStepUnifies = false;
 
     const context = specificContext,  ///
           axiomString = this.string,  ///
@@ -111,50 +110,53 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
 
     context.trace(`Unifying the '${lastStepString}' last step with the '${axiomString}' axiom...`)
 
-    const step = lastStep,  ///
-          stepUnified = this.unifyStep(step, substitutions, generalContext, specificContext);
+    const statement = lastStep.getStatement(),
+          statementUnifies = this.unifyStatementWithDeduction(statement, substitutions, generalContext, specificContext);
 
-    if (stepUnified) {
-      lastStepUnified = true;
+    if (statementUnifies) {
+      lastStepUnifies = true;
     }
 
-    if (lastStepUnified) {
+    if (lastStepUnifies) {
       context.debug(`...unified the '${lastStepString}' last step with the '${axiomString}' axiom.`)
     }
 
-    return lastStepUnified;
+    return lastStepUnifies;
   }
 
-  unifySubproof(subproof, substitutions, generalContext, specificContext) {
-    let subproofUnified = false;
+  unifySubproof(subproof, substitutions, context) {
+    let subproofUnifies = false;
 
-    const context = specificContext,  ///
-          axiomString = this.string,  ///
+    const axiomString = this.string,  ///
           subproofString = subproof.getString();
 
     context.trace(`Unifying the '${subproofString}' subproof with the '${axiomString}' axiom...`);
 
     const lastStep = subproof.getLastStep(),
-          lastStepUnified = this.unifyLastStep(lastStep, substitutions, generalContext, specificContext);
+          fileContext = this.getFileContext(),
+          localContext = LocalContext.fromFileContext(fileContext),
+          generalContext = localContext,  ///
+          specificContext = context,  ///
+          lastStepUnifies = this.unifyLastStep(lastStep, substitutions, generalContext, specificContext);
 
-    if (lastStepUnified) {
+    if (lastStepUnifies) {
       const suppositions = subproof.getSuppositions(),
-            suppositionsUnified = this.unifySuppositions(suppositions, substitutions, generalContext, specificContext);
+            suppositionsUnify = this.unifySuppositions(suppositions, substitutions, generalContext, specificContext);
 
-      if (suppositionsUnified) {
-        subproofUnified = true;
+      if (suppositionsUnify) {
+        subproofUnifies = true;
       }
     }
 
-    if (subproofUnified) {
+    if (subproofUnifies) {
       context.debug(`...unified the '${subproofString}' subproof with the '${axiomString}' axiom.`);
     }
 
-    return subproofUnified;
+    return subproofUnifies;
   }
 
   unifyDeduction(deduction, substitutions, generalContext, specificContext) {
-    let deductionUnified;
+    let deductionUnifies;
 
     const specificDeduction = deduction;  ///
 
@@ -164,13 +166,13 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
 
     deduction = specificDeduction;  ///
 
-    deductionUnified = generalDeduction.unifyDeduction(deduction, substitutions, generalContext, specificContext);
+    deductionUnifies = generalDeduction.unifyDeduction(deduction, substitutions, generalContext, specificContext);
 
-    return deductionUnified;
+    return deductionUnifies;
   }
 
   unifySupposition(supposition, index, substitutions, generalContext, specificContext) {
-    let suppositionUnified;
+    let suppositionUnifies;
 
     const specificSupposition = supposition;  ///
 
@@ -180,13 +182,13 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
 
     supposition = specificSupposition;  ///
 
-    suppositionUnified = generalSupposition.unifySupposition(supposition, substitutions, generalContext, specificContext);
+    suppositionUnifies = generalSupposition.unifySupposition(supposition, substitutions, generalContext, specificContext);
 
-    return suppositionUnified;
+    return suppositionUnifies;
   }
 
   unifySuppositions(suppositions, substitutions, generalContext, specificContext) {
-    let suppositionsUnified = false;
+    let suppositionsUnify = false;
 
     const specificSuppositions = suppositions;  ///
 
@@ -200,23 +202,23 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
       suppositions = specificSuppositions;  ///
 
       const suppositionsMatch = suppositions.every((supposition, index) => {
-        const suppositionUnified = this.unifySupposition(supposition, index, substitutions, generalContext, specificContext);
+        const suppositionUnifies = this.unifySupposition(supposition, index, substitutions, generalContext, specificContext);
 
-        if (suppositionUnified) {
+        if (suppositionUnifies) {
           return true;
         }
       });
 
       if (suppositionsMatch) {
-        suppositionsUnified = true;
+        suppositionsUnify = true;
       }
     }
 
-    return suppositionsUnified;
+    return suppositionsUnify;
   }
 
   unifyAxiomLemmaTheoremConjecture(axiomLemmaTheoremConjecture, substitutions, context) {
-    let axiomLemmaTheoremConjectureUnified = false;
+    let axiomLemmaTheoremConjectureUnifies = false;
 
     const axiomString = this.getString(),
           axiomLemmaTheoremConjectureString = axiomLemmaTheoremConjecture.getString();
@@ -227,20 +229,20 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
           fileContext = this.getFileContext(),
           generalContext = fileContext, ///
           specificContext = context,  ///
-          deductionUnified = this.unifyDeduction(deduction, substitutions, generalContext, specificContext);
+          deductionUnifies = this.unifyDeduction(deduction, substitutions, generalContext, specificContext);
 
-    if (deductionUnified) {
+    if (deductionUnifies) {
       const suppositions = axiomLemmaTheoremConjecture.getSuppositions(),
-            suppositionsUnified = this.unifySuppositions(suppositions, substitutions, generalContext, specificContext);
+            suppositionsUnify = this.unifySuppositions(suppositions, substitutions, generalContext, specificContext);
 
-      axiomLemmaTheoremConjectureUnified = suppositionsUnified; ///
+      axiomLemmaTheoremConjectureUnifies = suppositionsUnify; ///
     }
 
-    if (axiomLemmaTheoremConjectureUnified) {
+    if (axiomLemmaTheoremConjectureUnifies) {
       context.debug(`...unified the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture with the '${axiomString}' axiom.`);
     }
 
-    return axiomLemmaTheoremConjectureUnified;
+    return axiomLemmaTheoremConjectureUnifies;
   }
 
   static name = "Axiom";

package/src/dom/combinator/bracketed.js

@@ -8,19 +8,19 @@ import { domAssigned } from "../../dom";
 
 export default domAssigned(class BracketedCombinator extends Combinator {
   unifyStatement(statement, assignments, stated, context) {
-    let statementUnified;
+    let statementUnifies;
 
     const statementString = statement.getString();
 
     context.trace(`Unifying the '${statementString}' statement with the bracketed combinator...`);
 
-    statementUnified = super.unifyStatement(statement, assignments, stated, context);
+    statementUnifies = super.unifyStatement(statement, assignments, stated, context);
 
-    if (statementUnified) {
+    if (statementUnifies) {
       context.debug(`...unified the '${statementString}' statement with the bracketed combinator.`);
     }
 
-    return statementUnified;
+    return statementUnifies;
   }
 
   static fromNothing() {

package/src/dom/combinator.js

@@ -24,7 +24,7 @@ export default domAssigned(class Combinator {
   }
 
   unifyStatement(statement, assignments, stated, context) {
-    let statementUnified;
+    let statementUnifies;
 
     const combinator = this,  ///
           statementString = statement.getString(),
@@ -32,15 +32,15 @@ export default domAssigned(class Combinator {
 
     context.trace(`Unifying the '${statementString}' statement with the '${combinatorString}' combinator...`);
 
-    const statementUnifiedWithCombinator = unifyStatementWithCombinator(statement, combinator, assignments, stated, context);
+    const statementUnifiesWithCombinator = unifyStatementWithCombinator(statement, combinator, assignments, stated, context);
 
-    statementUnified = statementUnifiedWithCombinator; ///
+    statementUnifies = statementUnifiesWithCombinator; ///
 
-    if (statementUnified) {
+    if (statementUnifies) {
       context.debug(`...unified the '${statementString}' statement with the '${combinatorString}' combinator.`);
     }
 
-    return statementUnified;
+    return statementUnifies;
   }
 
   toJSON() {