occam-verify-cli 1.0.220 → 1.0.224

package/src/dom/reference.js

@@ -44,45 +44,45 @@ export default domAssigned(class Reference {
   matchMetavariableName(metavariableName) { return this.metavariable.matchMetavariableName(metavariableName); }
 
   verify(context) {
-    let verified = false;
+    let verifies = false;
 
     const referenceString = this.getString(); ///
 
     context.trace(`Verifying the '${referenceString}' reference...`);
 
-    if (!verified) {
-      const metavariableVerified = this.verifyMetavariable(context);
+    if (!verifies) {
+      const metavariableVerifies = this.verifyMetavariable(context);
 
-      verified = metavariableVerified; ///
+      verifies = metavariableVerifies; ///
     }
 
-    if (!verified) {
+    if (!verifies) {
       const reference = this, ///
             labelPresent = context.isLabelPresentByReference(reference);
 
-      verified = labelPresent;  ///
+      verifies = labelPresent;  ///
     }
 
-    if (verified) {
+    if (verifies) {
       context.debug(`...verified the '${referenceString}' reference.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   verifyMetavariable(context) {
-    let metavariableVerified;
+    let metavariableVerifies;
 
     const metaType = referenceMetaType, ///
-          metavariableVerifiedGivenMetaType = this.metavariable.verifyGivenMetaType(metaType, context);
+          metavariableVerifiesGivenMetaType = this.metavariable.verifyGivenMetaType(metaType, context);
 
-    metavariableVerified = metavariableVerifiedGivenMetaType; ///
+    metavariableVerifies = metavariableVerifiesGivenMetaType; ///
 
-    return metavariableVerified;
+    return metavariableVerifies;
   }
 
   unifyLabel(label, substitutions, context) {
-    let labelUnified;
+    let labelUnifies;
 
     const reference = this, ///
           labelString = label.getString(),
@@ -96,19 +96,19 @@ export default domAssigned(class Reference {
           labelMetavariable = label.getMetavariable(),
           generalMetavariable = this.metavariable,  ///
           specificMetavariable = labelMetavariable, ///
-          metavariableUnifiedIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, substitutions, generalContext, specificContext);
+          metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, substitutions, generalContext, specificContext);
 
-    labelUnified = metavariableUnifiedIntrinsically; ///
+    labelUnifies = metavariableUnifiesIntrinsically; ///
 
-    if (labelUnified) {
+    if (labelUnifies) {
       context.debug(`...unified the '${labelString}' label with the '${referenceString}' reference.`);
     }
 
-    return labelUnified;
+    return labelUnifies;
   }
 
   unifyMetavariable(metavariable, context) {
-    let metavariableUnified;
+    let metavariableUnifies;
 
     const reference = this, ///
           metavariableString = metavariable.getString(),
@@ -122,19 +122,19 @@ export default domAssigned(class Reference {
           specificContext = fileContext,  ///
           generalMetavariable = this.metavariable,  ///
           specificMetavariable = metavariable, ///
-          metavariableUnifiedIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, substitutions, generalContext, specificContext);
+          metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, substitutions, generalContext, specificContext);
 
-    metavariableUnified = metavariableUnifiedIntrinsically; ///
+    metavariableUnifies = metavariableUnifiesIntrinsically; ///
 
-    if (metavariableUnified) {
+    if (metavariableUnifies) {
       context.debug(`...unified the '${metavariableString}' metavariable with the '${referenceString}' reference.`);
     }
 
-    return metavariableUnified;
+    return metavariableUnifies;
   }
 
   unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context) {
-    let metaLemmaMetatheoremUnified;
+    let metaLemmaMetatheoremUnifies;
 
     const reference = this, ///
           referenceString = reference.getString(),
@@ -144,15 +144,15 @@ export default domAssigned(class Reference {
 
     const label = metaLemmaMetatheorem.getLabel(),
           substitutions = Substitutions.fromNothing(),
-          labelUnified = this.unifyLabel(label, substitutions, context);
+          labelUnifies = this.unifyLabel(label, substitutions, context);
 
-    metaLemmaMetatheoremUnified = labelUnified;  ///
+    metaLemmaMetatheoremUnifies = labelUnifies;  ///
 
-    if (metaLemmaMetatheoremUnified) {
+    if (metaLemmaMetatheoremUnifies) {
       context.trace(`...unified the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${referenceString}' reference.`);
     }
 
-    return metaLemmaMetatheoremUnified;
+    return metaLemmaMetatheoremUnifies;
   }
 
   toJSON() {

package/src/dom/rule.js

@@ -64,137 +64,145 @@ export default domAssigned(class Rule {
   }
 
   unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, context) {
-    let statementAndStepsOrSubproofsUnified = false;
+    let statementAndStepsOrSubproofsUnify = false;
 
     const localContext = LocalContext.fromFileContext(this.fileContext),
           generalContext = localContext, ///
           specificContext = context; ///
 
     const substitutions = Substitutions.fromNothing(),
-          statementUnifiedWithConclusion = this.unifyStatementWithConclusion(statement, substitutions, generalContext, specificContext);
+          statementUnifiesWithConclusion = this.unifyStatementWithConclusion(statement, substitutions, generalContext, specificContext);
 
-    if (statementUnifiedWithConclusion) {
-      const stepsOrSubproofsUnifiedWithPremises = this.unifyStepsOrSubproofsWithPremises(stepsOrSubproofs, substitutions, generalContext, specificContext);
+    if (statementUnifiesWithConclusion) {
+      const stepsOrSubproofsUnifyWithPremises = this.unifyStepsOrSubproofsWithPremises(stepsOrSubproofs, substitutions, generalContext, specificContext);
 
-      if (stepsOrSubproofsUnifiedWithPremises) {
+      if (stepsOrSubproofsUnifyWithPremises) {
         const substitutionsResolved = substitutions.areResolved();
 
-        statementAndStepsOrSubproofsUnified = substitutionsResolved; ///
+        if (substitutionsResolved) {
+          statementAndStepsOrSubproofsUnify = true;
+        }
       }
     }
 
-    return statementAndStepsOrSubproofsUnified;
+    return statementAndStepsOrSubproofsUnify;
   }
 
   unifyStatementWithConclusion(statement, substitutions, generalContext, specificContext) {
-    let statementUnifiedWithConclusion;
+    let statementUnifiesWithConclusion = false;
 
-    const statementUnified = this.conclusion.unifyStatement(statement, substitutions, generalContext, specificContext);
+    const statementUnifies = this.conclusion.unifyStatement(statement, substitutions, generalContext, specificContext);
 
-    statementUnifiedWithConclusion = statementUnified; ///
+    if (statementUnifies) {
+      statementUnifiesWithConclusion = true;
+    }
 
-    return statementUnifiedWithConclusion;
+    return statementUnifiesWithConclusion;
   }
 
   unifyStepsOrSubproofsWithPremises(stepsOrSubproofs, substitutions, generalContext, specificContext) {
     stepsOrSubproofs = reverse(stepsOrSubproofs); ///
 
-    const stepsOrSubproofsUnifiedWithPremises = backwardsEvery(this.premises, (premise) => {
-      const stepUnifiedWithPremise = this.unifyStepsOrSubproofsWithPremise(stepsOrSubproofs, premise, substitutions, generalContext, specificContext);
+    const stepsOrSubproofsUnifyWithPremises = backwardsEvery(this.premises, (premise) => {
+      const stepUnifiesWithPremise = this.unifyStepsOrSubproofsWithPremise(stepsOrSubproofs, premise, substitutions, generalContext, specificContext);
 
-      if (stepUnifiedWithPremise) {
+      if (stepUnifiesWithPremise) {
         return true;
       }
     });
 
-    return stepsOrSubproofsUnifiedWithPremises;
+    return stepsOrSubproofsUnifyWithPremises;
   }
 
   unifyStepsOrSubproofsWithPremise(stepsOrSubproofs, premise, substitutions, generalContext, specificContext) {
-    let stepsOrSubproofsUnifiedWithPremise  =false;
+    let stepsOrSubproofsUnifyWithPremise = false;
+
+    if (!stepsOrSubproofsUnifyWithPremise) {
+      const context = specificContext,  ///
+            premiseUnifiesIndependently = premise.unifyIndependently(substitutions, context);
 
-    const context = specificContext,  ///
-          premiseUnifiedIndependently = premise.unifyIndependently(substitutions, context);
+      if (premiseUnifiesIndependently) {
+        stepsOrSubproofsUnifyWithPremise = true;
+      }
+    }
 
-    if (premiseUnifiedIndependently) {
-      stepsOrSubproofsUnifiedWithPremise = true;
-    } else {
+    if (!stepsOrSubproofsUnifyWithPremise) {
       const stepOrSubproof = extract(stepsOrSubproofs, (stepOrSubproof) => {
-        const stepOrSubproofUnified = premise.unifyStepOrSubproof(stepOrSubproof, substitutions, generalContext, specificContext);
+        const stepOrSubproofUnifies = premise.unifyStepOrSubproof(stepOrSubproof, substitutions, generalContext, specificContext);
 
-        if (stepOrSubproofUnified) {
+        if (stepOrSubproofUnifies) {
           return true;
         }
       }) || null;
 
       if (stepOrSubproof !== null) {
-        stepsOrSubproofsUnifiedWithPremise = true;
+        stepsOrSubproofsUnifyWithPremise = true;
       }
     }
 
-    return stepsOrSubproofsUnifiedWithPremise;
+    return stepsOrSubproofsUnifyWithPremise;
   }
 
   verify() {
-    let verified = false;
+    let verifies = false;
 
     const ruleString = this.string; ///
 
     this.fileContext.trace(`Verifying the '${ruleString}' rule...`);
 
-    const labelsVerified = this.verifyLabels();
+    const labelsVerify = this.verifyLabels();
 
-    if (labelsVerified) {
+    if (labelsVerify) {
       const context = LocalContext.fromFileContext(this.fileContext),
-            premisesVerified = this.premises.every((premise) => {
-              const premiseVerified = premise.verify(context);
+            premisesVerify = this.premises.every((premise) => {
+              const premiseVerifies = premise.verify(context);
 
-              if (premiseVerified) {
+              if (premiseVerifies) {
                 return true;
               }
             });
 
-      if (premisesVerified) {
-        const conclusionVerified = this.conclusion.verify(context);
+      if (premisesVerify) {
+        const conclusionVerifies = this.conclusion.verify(context);
 
-        if (conclusionVerified) {
-          let proofVerified = true; ///
+        if (conclusionVerifies) {
+          let proofVerifies = true; ///
 
           if (this.proof !== null) {
             const substitutions = Substitutions.fromNothing();
 
-            proofVerified = this.proof.verify(substitutions, this.conclusion, context);
+            proofVerifies = this.proof.verify(substitutions, this.conclusion, context);
           }
 
-          if (proofVerified) {
+          if (proofVerifies) {
             const rule = this;  ///
 
             this.fileContext.addRule(rule);
 
-            verified = true;
+            verifies = true;
           }
         }
       }
     }
 
-    if (verified) {
+    if (verifies) {
       this.fileContext.debug(`...verified the '${ruleString}' rule.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   verifyLabels() {
-    const labelsVerified = this.labels.every((label) => {
+    const labelsVerify = this.labels.every((label) => {
       const nameOnly = true,
-            labelVerified = label.verify(nameOnly);
+            labelVerifies = label.verify(nameOnly);
 
-      if (labelVerified) {
+      if (labelVerifies) {
         return true;
       }
     });
 
-    return labelsVerified;
+    return labelsVerify;
   }
 
   toJSON() {
@@ -222,7 +230,7 @@ export default domAssigned(class Rule {
           labels = labelsFromJSON(json, fileContext),
           premises = premisesFromJSON(json, fileContext),
           conclusion = conclusionFromJSON(json, fileContext),
-          string = stringFromLabelsAndConclusion(labels, conclusion);
+          string = stringFromLabelsPremisesAndConclusion(labels, premises, conclusion);
 
     rule = new Rule(fileContext, string, labels, premises, conclusion, proof);
 
@@ -234,7 +242,7 @@ export default domAssigned(class Rule {
           labels = labelsFromRuleNode(ruleNode, fileContext),
           premises = premisesFromRuleNode(ruleNode, fileContext),
           conclusion = conclusionFromRuleNode(ruleNode, fileContext),
-          string = stringFromLabelsAndConclusion(labels, conclusion),
+          string = stringFromLabelsPremisesAndConclusion(labels, premises, conclusion),
           rule = new Rule(fileContext, string, labels, premises, conclusion, proof);
 
     return rule;
@@ -281,10 +289,25 @@ function conclusionFromRuleNode(ruleNode, fileContext) {
   return conclusion;
 }
 
-function stringFromLabelsAndConclusion(labels, conclusion) {
-  const conclusionString = conclusion.getString(),
+function premisesStringFromPremises(premises) {
+  const premisesString = premises.reduce((premisesString, premise) => {
+    const premiseString = premise.getString();
+
+    premisesString = (premisesString !== null) ?
+                       `${premisesString}, ${premiseString}` :
+                         premiseString;  ///
+
+    return premisesString;
+  }, null);
+
+  return premisesString;
+}
+
+function stringFromLabelsPremisesAndConclusion(labels, premises, conclusion) {
+  const premisesString = premisesStringFromPremises(premises),
+        conclusionString = conclusion.getString(),
         labelsString = labelsStringFromLabels(labels),
-        string = `${labelsString} :: ${conclusionString}`;
+        string = `${labelsString} :: [${premisesString}] ... ${conclusionString}`;
 
   return string;
 }

package/src/dom/signature.js

@@ -25,29 +25,29 @@ export default domAssigned(class Signature {
   }
 
   verify(context) {
-    let verified;
+    let verifies;
 
     const signatureString = this.string;
 
     context.trace(`Verifying the ${signatureString} signature...`);
 
-    verified = this.terms.every((term) => {
-      const termVerified = term.verify(context, () => {
-        const verifiedAhead = true;
+    verifies = this.terms.every((term) => {
+      const termVerifies = term.verify(context, () => {
+        const verifiesAhead = true;
 
-        return verifiedAhead;
+        return verifiesAhead;
       });
 
-      if (termVerified) {
+      if (termVerifies) {
         return true;
       }
     });
 
-    if (verified) {
+    if (verifies) {
       context.debug(`...verified the ${signatureString} signature.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   match(signature, substitutions, generalContext, specificContext) {
@@ -87,13 +87,13 @@ export default domAssigned(class Signature {
     return matches;
   }
 
-  matchSubstitutions(substitutions, context) {
-    let substitutionsMatch;
+  correlateSubstitutions(substitutions, context) {
+    let substitutionsCorrelates;
 
     const signatureString = this.string,
           substitutionsString = substitutions.asString();
 
-    context.trace(`Matching the '${substitutionsString}' substitutions against the ${signatureString} signature...`);
+    context.trace(`Correlating the '${substitutionsString}' substitutions against the ${signatureString} signature...`);
 
     const array = substitutions.getArray(),
           correlates = correlate(this.terms, array, (term, substitution) => {
@@ -105,13 +105,13 @@ export default domAssigned(class Signature {
             }
           });
 
-    substitutionsMatch = correlates;  ///
+    substitutionsCorrelates = correlates;  ///
 
-    if (substitutionsMatch) {
-      context.debug(`...matched the '${substitutionsString}' substitutions against the ${signatureString} signature.`);
+    if (substitutionsCorrelates) {
+      context.debug(`...correlated the '${substitutionsString}' substitutions against the ${signatureString} signature.`);
     }
 
-    return substitutionsMatch;
+    return substitutionsCorrelates;
   }
 
   toJSON() {

package/src/dom/statement.js

@@ -96,30 +96,30 @@ export default domAssigned(class Statement {
   }
 
   verify(assignments, stated, context) {
-    let verified;
+    let verifies;
 
     const statementString = this.string;  ///
 
     context.trace(`Verifying the '${statementString}' statement...`);
 
-    verified = verifyMixins.some((verifyMixin) => {
+    verifies = verifyMixins.some((verifyMixin) => {
       const statement = this, ///
-            verified = verifyMixin(statement, assignments, stated, context);
+            verifies = verifyMixin(statement, assignments, stated, context);
 
-      if (verified) {
+      if (verifies) {
         return true;
       }
     });
 
-    if (verified) {
+    if (verifies) {
       context.debug(`...verified the '${statementString}' statement.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   verifyGivenMetaType(metaType, assignments, stated, context) {
-    let verifiedGivenMetaType = false;
+    let verifiesGivenMetaType = false;
 
     const metaTypeString = metaType.getString(),
           statementString = this.string;  ///
@@ -129,20 +129,20 @@ export default domAssigned(class Statement {
     const metaTypeName = metaType.getName();
 
     if (metaTypeName === STATEMENT_META_TYPE_NAME) {
-      const verified = this.verify(assignments, stated, context)
+      const verifies = this.verify(assignments, stated, context)
 
-      verifiedGivenMetaType = verified; ///
+      verifiesGivenMetaType = verifies; ///
     }
 
-    if (verifiedGivenMetaType) {
+    if (verifiesGivenMetaType) {
       context.debug(`...verified the '${statementString}' statement given the '${metaTypeString}' meta-type.`);
     }
 
-    return verifiedGivenMetaType;
+    return verifiesGivenMetaType;
   }
 
   unifySubproof(subproof, substitutions, generalContext, specificContext) {
-    let subproofUnified = false;
+    let subproofUnifies = false;
 
     const context = specificContext,  ///
           statement = this, ///
@@ -157,26 +157,26 @@ export default domAssigned(class Statement {
       const subproofStatements = subproof.getStatements(),
             subproofAssertionStatements = subproofAssertion.getStatements();
 
-      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;
   }
 
   unifyStatement(statement, substitutions, generalContext, specificContext) {
-    let statementUnified;
+    let statementUnifies;
 
     const generalStatement = this,  ///
           specificStatement = statement, ///
@@ -185,17 +185,17 @@ export default domAssigned(class Statement {
 
     specificContext.trace(`Unifying the '${specificStatementString}' statement with the '${generalStatementString}' statement...`);
 
-    statementUnified = unifyStatement(generalStatement, specificStatement, substitutions, generalContext, specificContext);
+    statementUnifies = unifyStatement(generalStatement, specificStatement, substitutions, generalContext, specificContext);
 
-    if (statementUnified) {
+    if (statementUnifies) {
       specificContext.debug(`...unified the '${specificStatementString}' statement with the '${generalStatementString}' statement.`);
     }
 
-    return statementUnified;
+    return statementUnifies;
   }
 
   unifyIndependently(substitutions, context) {
-    let unifiedIndependently = false;
+    let unifiesIndependently = false;
 
     const statement = this, ///
           statementString = this.string;  ///
@@ -206,37 +206,37 @@ export default domAssigned(class Statement {
           containedAssertion = containedAssertionFromStatement(statement, context);
 
     if (definedAssertion !== null) {
-      const definedAssertionUnifiedIndependently = definedAssertion.unifyIndependently(substitutions, context);
+      const definedAssertionUnifiesIndependently = definedAssertion.unifyIndependently(substitutions, context);
 
-      unifiedIndependently = definedAssertionUnifiedIndependently; ///
+      unifiesIndependently = definedAssertionUnifiesIndependently; ///
     }
 
     if (containedAssertion !== null) {
-      const containedAssertionUnifiedIndependently = containedAssertion.unifyIndependently(substitutions, context);
+      const containedAssertionUnifiesIndependently = containedAssertion.unifyIndependently(substitutions, context);
 
-      unifiedIndependently = containedAssertionUnifiedIndependently; ///
+      unifiesIndependently = containedAssertionUnifiesIndependently; ///
     }
 
-    if (unifiedIndependently) {
+    if (unifiesIndependently) {
       context.debug(`...unified the '${statementString}' statement independently.`);
     }
 
-    return unifiedIndependently;
+    return unifiesIndependently;
   }
 
-  unifyWithStepsOrSubproofs(stepsOrSubproofs, context) {
-    let unifiedWithSteps;
+  equateWithStepsOrSubproofs(stepsOrSubproofs, context) {
+    let equatesWithStepsOrSubproofs;
 
-    unifiedWithSteps = backwardsSome(stepsOrSubproofs, (stepOrSubproof) => {
+    equatesWithStepsOrSubproofs = backwardsSome(stepsOrSubproofs, (stepOrSubproof) => {
       const statement = this, ///
-            statementUnified = stepOrSubproof.unifyStatement(statement, context);
+            statementUnifies = stepOrSubproof.equateWithStatement(statement, context);
 
-      if (statementUnified) {
+      if (statementUnifies) {
         return true;
       }
     });
 
-    return unifiedWithSteps;
+    return equatesWithStepsOrSubproofs;
   }
 
   toJSON() {