occam-verify-cli 1.0.438 → 1.0.448

package/src/element/rule.js

@@ -42,16 +42,16 @@ export default define(class Rule extends Element {
     return this.conclusion;
   }
 
-  matchMetavariableName(metavariableName) {
-    const metavariableNameMatches = this.labels.some((label) => {
-      const metavariableNameMatches = label.matchMetavariableName(metavariableName);
+  compareMetavariableName(metavariableName) {
+    const comparesToMetavariableName = this.labels.some((label) => {
+      const labelComparesToMetavariableName = label.compareMetavariableName(metavariableName);
 
-      if (metavariableNameMatches) {
+      if (labelComparesToMetavariableName) {
         return true;
       }
     });
 
-    return metavariableNameMatches;
+    return comparesToMetavariableName;
   }
 
   verify() {
@@ -74,16 +74,17 @@ export default define(class Rule extends Element {
 
       context = localContext; ///
 
-      const premisesValidate = this.validatePremises(context);
+      const premisesVerify = this.verifyPremises(context);
 
-      if (premisesValidate) {
+      if (premisesVerify) {
         const conclusionVerifies = this.verifyConclusion(context);
 
         if (conclusionVerifies) {
           const proofVerifies = this.verifyProof(context);
 
           if (proofVerifies) {
-            const rule = this;  ///
+            const rule = this,  ///
+                  context = this.getContext();
 
             context.addRule(rule);
 
@@ -113,22 +114,22 @@ export default define(class Rule extends Element {
     return labelsVerify;
   }
 
-  validatePremises(context) {
-    const premisesValidate = this.premises.every((premise) => {
-      const premiseValidates = this.validatePremise(premise, context);
+  verifyPremises(context) {
+    const premisesVerify = this.premises.every((premise) => {
+      const premiseVerifies = this.verifyPremise(premise, context);
 
-      if (premiseValidates) {
+      if (premiseVerifies) {
         return true;
       }
     });
 
-    return premisesValidate;
+    return premisesVerify;
   }
 
-  validatePremise(premise, context) {
-    const premiseValidates = premise.validate(context);
+  verifyPremise(premise, context) {
+    const premiseVerifies = premise.verify(context);
 
-    return premiseValidates;
+    return premiseVerifies;
   }
 
   verifyConclusion(context) {
@@ -164,68 +165,68 @@ export default define(class Rule extends Element {
     return statementUnifiesWithConclusion;
   }
 
-  unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, context) {
-    let statementAndStepsOrSubproofsUnify = false;
+  unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, context) {
+    let statementAndSubproofOrProofAssertionsUnify = false;
 
     const { Substitutions } = elements,
           substitutions = Substitutions.fromNothing(),
           statementUnifiesWithConclusion = this.unifyStatementWithConclusion(statement, substitutions, context);
 
     if (statementUnifiesWithConclusion) {
-      const stepsOrSubproofsUnifiesWithPremises = this.unifyStepsOrSubproofsWithPremises(stepsOrSubproofs, substitutions, context);
+      const subproofOrProofAssertionsUnifiesWithPremises = this.unifySubproofOrProofAssertionsWithPremises(subproofOrProofAssertions, substitutions, context);
 
-      if (stepsOrSubproofsUnifiesWithPremises) {
+      if (subproofOrProofAssertionsUnifiesWithPremises) {
         const substitutionsResolved = substitutions.areResolved();
 
         if (substitutionsResolved) {
-          statementAndStepsOrSubproofsUnify = true;
+          statementAndSubproofOrProofAssertionsUnify = true;
         }
       }
     }
 
-    return statementAndStepsOrSubproofsUnify;
+    return statementAndSubproofOrProofAssertionsUnify;
   }
 
-  unifyStepsOrSubproofsWithPremise(stepsOrSubproofs, premise, substitutions, context) {
-    let stepsOrSubproofsUnifiesWithPremise = false;
+  unifySubproofOrProofAssertionsWithPremise(subproofOrProofAssertions, premise, substitutions, context) {
+    let subproofOrProofAssertionsUnifiesWithPremise = false;
 
-    if (!stepsOrSubproofsUnifiesWithPremise) {
+    if (!subproofOrProofAssertionsUnifiesWithPremise) {
       const premiseUnifiesIndependently = premise.unifyIndependently(substitutions, context);
 
       if (premiseUnifiesIndependently) {
-        stepsOrSubproofsUnifiesWithPremise = true;
+        subproofOrProofAssertionsUnifiesWithPremise = true;
       }
     }
 
-    if (!stepsOrSubproofsUnifiesWithPremise) {
-      const stepOrSubproof = extract(stepsOrSubproofs, (stepOrSubproof) => {
-        const stepOrSubproofUnifies = premise.unifyStepOrSubproof(stepOrSubproof, substitutions, context);
+    if (!subproofOrProofAssertionsUnifiesWithPremise) {
+      const subproofOrProofAssertion = extract(subproofOrProofAssertions, (subproofOrProofAssertion) => {
+        const subproofOrProofAssertionUnifies = premise.unifySubproofOrProofAssertion(subproofOrProofAssertion, substitutions, context);
 
-        if (stepOrSubproofUnifies) {
+        if (subproofOrProofAssertionUnifies) {
           return true;
         }
       }) || null;
 
-      if (stepOrSubproof !== null) {
-        stepsOrSubproofsUnifiesWithPremise = true;
+      if (subproofOrProofAssertion !== null) {
+        subproofOrProofAssertionsUnifiesWithPremise = true;
       }
     }
 
-    return stepsOrSubproofsUnifiesWithPremise;
+    return subproofOrProofAssertionsUnifiesWithPremise;
   }
 
-  unifyStepsOrSubproofsWithPremises(stepsOrSubproofs, substitutions, context) {
-    stepsOrSubproofs = reverse(stepsOrSubproofs); ///
+  unifySubproofOrProofAssertionsWithPremises(subproofOrProofAssertions, substitutions, context) {
+    subproofOrProofAssertions = reverse(subproofOrProofAssertions); ///
 
-    const stepsOrSubproofsUnifiesWithPremises = backwardsEvery(this.premises, (premise) => {
-      const stepUnifiesWithPremise = this.unifyStepsOrSubproofsWithPremise(stepsOrSubproofs, premise, substitutions, context);
+    const subproofOrProofAssertionsUnifiesWithPremises = backwardsEvery(this.premises, (premise) => {
+      const stepUnifiesWithPremise = this.unifySubproofOrProofAssertionsWithPremise(subproofOrProofAssertions, premise, substitutions, context);
 
       if (stepUnifiesWithPremise) {
         return true;
       }
     });
 
-    return stepsOrSubproofsUnifiesWithPremises;
+    return subproofOrProofAssertionsUnifiesWithPremises;
   }
 
   toJSON() {

package/src/element/signature.js

@@ -27,7 +27,7 @@ export default define(class Signature extends Element {
 
     const signatureString = this.string;  ///
 
-    context.trace(`Verifying the ${signatureString} signature...`);
+    context.trace(`Verifying the '${signatureString}' signature...`);
 
     verifies = this.terms.every((term) => {
       const termVerifies = term.verify(context, () => {
@@ -42,13 +42,13 @@ export default define(class Signature extends Element {
     });
 
     if (verifies) {
-      context.debug(`...verified the ${signatureString} signature.`);
+      context.debug(`...verified the '${signatureString}' signature.`);
     }
 
     return verifies;
   }
 
-  match(signature, substitutions, generalContext, specificContext) {
+  compare(signature, substitutions, generalContext, specificContext) {
     const terms = signature.getTerms(),
           termsA = this.terms,  ///
           termsB = terms, ///
@@ -74,9 +74,10 @@ export default define(class Signature extends Element {
                 return true;
               }
             }
-          });
+          }),
+          compares = matches; ///
 
-    return matches;
+    return compares;
   }
 
   compareSubstitutions(substitutions, context) {
@@ -85,7 +86,7 @@ export default define(class Signature extends Element {
     const signatureString = this.string,  ///
           substitutionsString = substitutions.asString();
 
-    context.trace(`Comparing the '${substitutionsString}' substitutions against the ${signatureString} signature...`);
+    context.trace(`Comparing the '${substitutionsString}' substitutions against the '${signatureString}' signature...`);
 
     const array = substitutions.getArray(),
           compares = compare(this.terms, array, (term, substitution) => {
@@ -102,7 +103,7 @@ export default define(class Signature extends Element {
     }
 
     if (substitutionsCompares) {
-      context.debug(`...compared the '${substitutionsString}' substitutions against the ${signatureString} signature.`);
+      context.debug(`...compared the '${substitutionsString}' substitutions against the '${signatureString}' signature.`);
     }
 
     return substitutionsCompares;
@@ -114,7 +115,7 @@ export default define(class Signature extends Element {
     const signatureString = this.string,  ///
           substitutionsString = substitutions.asString();
 
-    context.trace(`Correlating 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) => {
@@ -131,7 +132,7 @@ export default define(class Signature extends Element {
     }
 
     if (substitutionsCorrelates) {
-      context.debug(`...correlated the '${substitutionsString}' substitutions against the ${signatureString} signature.`);
+      context.debug(`...correlated the '${substitutionsString}' substitutions against the '${signatureString}' signature.`);
     }
 
     return substitutionsCorrelates;

package/src/element/statement.js

@@ -3,10 +3,10 @@
 import { arrayUtilities } from "necessary";
 
 import Element from "../element";
-import validateMixins from "../mixins/statement/validate";
 
 import { define } from "../elements";
 import { unifyStatement } from "../process/unify";
+import { validateStatements } from "../utilities/validation";
 import { instantiateStatement } from "../process/instantiate";
 import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 
@@ -47,14 +47,13 @@ export default define(class Statement extends Element {
 
     context.trace(`Is the '${termString}' term contained in the '${statementString}' statement...`, node);
 
-    const termNode = term.getNode(),
-          statementNode = node, ///
+    const statementNode = node, ///
           statementNodeTermNodes = statementNode.getTermNodes();
 
     termContained = statementNodeTermNodes.some((statementNodeTermNode) => {  ///
-      const termNodeMatchesStatementNodeTermNode = termNode.match(statementNodeTermNode);
+      const statementNodeTermNodeMatches = term.matchNode(statementNodeTermNode);
 
-      if (termNodeMatchesStatementNodeTermNode) {
+      if (statementNodeTermNodeMatches) {
         return true;
       }
     });
@@ -75,14 +74,13 @@ export default define(class Statement extends Element {
 
     context.trace(`Is the '${frameString}' frame contained in the '${statementString}' statement...`, node);
 
-    const frameNode = frame.getNode(),
-          statementNode = node,
+    const statementNode = node,
           statementNodeFrameNodes = statementNode.getFrameNodes();
 
     frameContained = statementNodeFrameNodes.some((statementNodeFrameNode) => {  ///
-      const frameNodeMatchesStatementNodeFrameNode = frameNode.match(statementNodeFrameNode);
+      const statementNodeFrameNodeMatches = frame.matchNode(statementNodeFrameNode);
 
-      if (frameNodeMatchesStatementNodeFrameNode) {
+      if (statementNodeFrameNodeMatches) {
         return true;
       }
     });
@@ -124,11 +122,11 @@ export default define(class Statement extends Element {
 
     context.trace(`Validating the '${statementString}' statement...`, node);
 
-    validates = validateMixins.some((validateMixin) => {
+    validates = validateStatements.some((validateStatement) => {
       const statement = this, ///
-            validates = validateMixin(statement, assignments, stated, context);
+            statementValidates = validateStatement(statement, assignments, stated, context);
 
-      if (validates) {
+      if (statementValidates) {
         return true;
       }
     });
@@ -256,19 +254,19 @@ export default define(class Statement extends Element {
     return unifiesIndependently;
   }
 
-  equateWithStepsOrSubproofs(stepsOrSubproofs, context) {
-    let equatesWithStepsOrSubproofs;
+  compareSubproofOrProofAssertions(subproofOrProofAssertions, context) {
+    let comparesToSubproofOrProofAssertions;
 
-    equatesWithStepsOrSubproofs = backwardsSome(stepsOrSubproofs, (stepOrSubproof) => {
+    comparesToSubproofOrProofAssertions = backwardsSome(subproofOrProofAssertions, (subproofOrProofAssertion) => {
       const statement = this, ///
-            statementUnifies = stepOrSubproof.equateWithStatement(statement, context);
+            subproofOrProofAssertionComparesToStatement = subproofOrProofAssertion.compareStatement(statement, context);
 
-      if (statementUnifies) {
+      if (subproofOrProofAssertionComparesToStatement) {
         return true;
       }
     });
 
-    return equatesWithStepsOrSubproofs;
+    return comparesToSubproofOrProofAssertions;
   }
 
   toJSON() {

package/src/element/step.js

@@ -1,27 +1,21 @@
 "use strict";
 
-import Element from "../element";
 import elements from "../elements";
-import unifyMixins from "../mixins/step/unify";
+import ProofAssertion from "./proofAssertion";
 import TemporaryContext from "../context/temporary";
 
 import { define } from "../elements";
-import { equateStatements } from "../process/equate";
+import { unifyStatements } from "../utilities/unification";
 import { propertyAssertionFromStatement } from "../utilities/statement";
 
-export default define(class Step extends Element {
+export default define(class Step extends ProofAssertion {
   constructor(context, string, node, statement, reference, satisfiesAssertion) {
-    super(context, string, node);
+    super(context, string, node, statement);
 
-    this.statement = statement;
     this.reference = reference;
     this.satisfiesAssertion = satisfiesAssertion;
   }
 
-  getStatement() {
-    return this.statement;
-  }
-
   getReference() {
     return this.reference;
   }
@@ -49,112 +43,118 @@ export default define(class Step extends Element {
     return stated;
   }
 
-  isStep() {
-    const step = true;
-
-    return step;
-  }
+  compareTermAndPropertyRelation(term, propertyRelation, context) {
+    let comparesToTermAndPropertyRelation = false;
 
-  matchTermAndPropertyRelation(term, propertyRelation, context) {
-    let termAndPropertyRelationMatch = false;
-
-    const propertyAssertion = propertyAssertionFromStatement(this.statement, context);
+    const statement = this.getStatement(),
+          propertyAssertion = propertyAssertionFromStatement(statement, context);
 
     if (propertyAssertion !== null) {
-      termAndPropertyRelationMatch = propertyAssertion.matchTermAndPropertyRelation(term, propertyRelation, context);
+      comparesToTermAndPropertyRelation = propertyAssertion.compareTermAndPropertyRelation(term, propertyRelation, context);
     }
 
-    return termAndPropertyRelationMatch;
+    return comparesToTermAndPropertyRelation;
   }
 
-  validate(substitutions, assignments, context) {
-    let validates = false;
+  verify(substitutions, assignments, context) {
+    let verifies = false;
 
     const temporaryContext = TemporaryContext.fromNothing(context);
 
     context = temporaryContext; ///
 
-    const stepString = this.string; ///
+    const node = this.getNode(),
+          stepString = this.getString(); ///
 
-    context.trace(`Validating the '${stepString}' step...`, this.node);
+    context.trace(`Verifying the '${stepString}' step...`, node);
 
-    if (this.statement !== null) {
-      const stated = this.isStated(),
-            statementVerifies = this.statement.validate(assignments, stated, context);
+    const statement = this.getStatement();
 
-      if (statementVerifies) {
-        const qualified = this.isQualified(),
-              satisfied = this.isSatisfied();
+    if (statement === null) {
+      context.debug(`Unable to verify the '${stepString}' step because it is nonsense.`, node);
+    } else {
+      const referenceVerifies = this.verifyReference(context);
 
-        if (false) {
-          ///
-        } else if (qualified) {
-          const referenceVerifies = this.reference.validate(context);
+      if (referenceVerifies) {
+        const satisfiesAssertioVeriries = this.verifySatisfiesAssertion(context);
 
-          if (referenceVerifies) {
-            validates = true;
-          }
-        } else if (satisfied) {
-          const stated = true,
-                assignments = null,
-                satisfiesAssertionVerifies = this.satisfiesAssertion.validate(assignments, stated, context);
+        if (satisfiesAssertioVeriries) {
+          const stated = this.isStated(),
+                statementValidates = statement.validate(assignments, stated, context);
 
-          if (satisfiesAssertionVerifies) {
-            validates = true;
+          if (statementValidates) {
+            const statementUnifies = unifyStatements.some((unifyStatement) => {
+              const statementUnifies = unifyStatement(statement, this.reference, this.satisfiesAssertion, substitutions, context);
+
+              if (statementUnifies) {
+                return true;
+              }
+            });
+
+            if (statementUnifies) {
+              const subproofOrProofAssertion = this;  ///
+
+              context.addSubproofOrProofAssertion(subproofOrProofAssertion);
+
+              this.setContext(context);
+
+              verifies = true;
+            }
           }
-        } else {
-          validates = true;
         }
       }
-    } else {
-      context.debug(`Cannot validate the '${stepString}' step because it is nonsense.`, this.node);
     }
 
-    if (validates) {
-      this.context = context;
-
-      context.debug(`...verified the '${stepString}' step.`, this.node);
+    if (verifies) {
+      context.debug(`...verified the '${stepString}' step.`, node);
     }
 
-    return validates;
+    return verifies;
   }
 
-  unify(substitutions, context) {
-    let unifies;
-
-    context = this.context;
-
-    const stepString = this.string;  ///
+  verifyReference(context) {
+    let referenceVeriries;
 
-    context.trace(`Unifying the '${stepString}' step...`, this.node);
+    const node = this.getNode(),
+          stepString = this.getString();  ///
 
-    unifies = unifyMixins.some((unifyMixin) => {
-      const unifies = unifyMixin(this.statement, this.reference, this.satisfiesAssertion, substitutions, context);
+    context.trace(`Verifying the '${stepString}' step's reference... `, node);
 
-      if (unifies) {
-        return true;
-      }
-    });
+    if (this.reference !== null) {
+      referenceVeriries = this.reference.verify(context);
+    } else {
+      referenceVeriries = true;
+    }
 
-    if (unifies) {
-      context.debug(`...unified the '${stepString}' step.`, this.node);
+    if (referenceVeriries) {
+      context.debug(`...verified the '${stepString}' step's reference. `, node);
     }
 
-    return unifies;
+    return referenceVeriries;
   }
 
-  equateWithStatement(statement, context) {
-    let statementEquates;
+  verifySatisfiesAssertion(context) {
+    let satisfiesAssertionVerifies;
 
-    const leftStatement = statement,  ///
-          rightStatement = this.statement,  ///
-          leftStatementNode = leftStatement.getNode(),
-          rightStatementNode = rightStatement.getNode(),
-          statementsEquate = equateStatements(leftStatementNode, rightStatementNode, context);
+    const node = this.getNode(),
+          stepString = this.getString();  ///
 
-    statementEquates = statementsEquate;  ///
+    context.trace(`Verifying the '${stepString}' step's satisfies assertion... `, node);
+
+    if (this.satisfiesAssertion !== null) {
+      const stated = true,
+            assignments = null;
+
+      satisfiesAssertionVerifies = this.satisfiesAssertion.validate(assignments, stated, context);
+    } else {
+      satisfiesAssertionVerifies = true;
+    }
+
+    if (satisfiesAssertionVerifies) {
+      context.debug(`...verified the '${stepString}' step's satisfies assertion. `, node);
+    }
 
-    return statementEquates;
+    return satisfiesAssertionVerifies;
   }
 
   unifyWithSatisfiesAssertion(satisfiesAssertion, context) {

package/src/element/subDerivation.js

@@ -10,41 +10,37 @@ import { define } from "../elements";
 const { last } = arrayUtilities;
 
 export default define(class SubDerivation extends Element {
-  constructor(context, string, node, stepsOrSubproofs) {
+  constructor(context, string, node, subproofOrProofAssertions) {
     super(context, string, node);
 
-    this.stepsOrSubproofs = stepsOrSubproofs;
+    this.subproofOrProofAssertions = subproofOrProofAssertions;
   }
 
-  getStepsOrSubproofs() {
-    return this.stepsOrSubproofs;
+  getSubproofOrProofAssertions() {
+    return this.subproofOrProofAssertions;
   }
 
-  getLastStep() {
-    const lastStepOrSubproof = last(this.stepsOrSubproofs),
-          lastStep = lastStepOrSubproof;  ///
+  getLastProofAssertion() {
+    const lastSubproofOrProofAssertion = last(this.subproofOrProofAssertions),
+          lastProofAssertion = lastSubproofOrProofAssertion;  ///
 
-    return lastStep;
+    return lastProofAssertion;
   }
 
   verify(substitutions, context) {
     let verifies;
 
-    verifies = this.stepsOrSubproofs.every((stepOrSubproof) => { ///
+    verifies = this.subproofOrProofAssertions.every((subproofOrProofAssertion) => { ///
       const assignments = [],
-            stepOrSubproofValidates = stepOrSubproof.validate(substitutions, assignments, context);
+            subproofOrProofAssertionVarifies = subproofOrProofAssertion.verify(substitutions, assignments, context);
 
-      if (stepOrSubproofValidates) {
-        const stepOrSubproofUnifies = stepOrSubproof.unify(substitutions, context);
+      if (subproofOrProofAssertionVarifies) {
+        const assignmentsAssigned = assignAssignments(assignments, context);
 
-        if (stepOrSubproofUnifies) {
-          const assignmentsAssigned = assignAssignments(assignments, context);
+        if (assignmentsAssigned) {
+          context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
-          if (assignmentsAssigned) {
-            context.addStepOrSubproof(stepOrSubproof);
-
-            return true;
-          }
+          return true;
         }
       }
     });

package/src/element/subproof.js

@@ -22,40 +22,32 @@ export default define(class Subproof extends Element {
     return this.subDerivation;
   }
 
-  getLastStep() { return this.subDerivation.getLastStep(); }
+  getLastProofAssertion() { return this.subDerivation.getLastProofAssertion(); }
 
   getStatements() {
-    const lastStep = this.getLastStep(),
+    const lastProofAssertion = this.getLastProofAssertion(),
           suppositionStatements = this.suppositions.map((supposition) => {
             const suppositionStatement = supposition.getStatement();
 
             return suppositionStatement;
           }),
-          lastStepStatement = lastStep.getStatement(),
+          lastProofAssertionStatement = lastProofAssertion.getStatement(),
           statements = [
             ...suppositionStatements,
-            lastStepStatement
+            lastProofAssertionStatement
           ];
 
     return statements;
   }
 
-  isStep() {
-    const sStep = false;
+  isProofAssertion() {
+    const proofAssertion = false;
 
-    return sStep;
-  }
-
-  unify(substitutions, context) {
-    let unifies;
-
-    unifies = true; ///
-
-    return unifies;
+    return proofAssertion;
   }
 
   verify(substitutions, assignments, context) {
-    let subproofVerifies = false;
+    let verifies = false;
 
     const localContext = LocalContext.fromNothing(context);  ///
 
@@ -73,14 +65,14 @@ export default define(class Subproof extends Element {
       const subDerivationVerifies = this.subDerivation.verify(substitutions, context);
 
       if (subDerivationVerifies) {
-        subproofVerifies = true;
+        verifies = true;
       }
     }
 
-    return subproofVerifies;
+    return verifies;
   }
 
-  equateWithStatement(statement, context) {
+  compareStatement(statement, context) {
     const statementUnifies = false;
 
     return statementUnifies;