occam-verify-cli 1.0.437 → 1.0.444

package/src/element/statement.js

@@ -3,10 +3,10 @@
 import { arrayUtilities } from "necessary";
 
 import Element from "../element";
-import verifyMixins from "../mixins/statement/verify";
 
 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";
 
@@ -23,36 +23,43 @@ export default define(class Statement extends Element {
     const singular = this.isSingular();
 
     if (singular) {
-      metavariableName = this.node.getMetavariableName();
+      const node = this.getNode();
+
+      metavariableName = node.getMetavariableName();
     }
 
     return metavariableName;
   }
 
-  isSingular() { return this.node.isSingular(); }
+  isSingular() {
+    const node = this.getNode(),
+          singular = node.isSingular();
+
+    return singular;
+  }
 
   isTermContained(term, context) {
     let termContained;
 
-    const termString = term.getString(),
-          statementString = this.string;  ///
+    const node = this.getNode(),
+          termString = term.getString(),
+          statementString = this.getString();  ///
 
-    context.trace(`Is the '${termString}' term contained in the '${statementString}' statement...`, this.node);
+    context.trace(`Is the '${termString}' term contained in the '${statementString}' statement...`, node);
 
-    const termNode = term.getNode(),
-          statementNode = this.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;
       }
     });
 
     if (termContained) {
-      context.debug(`...the '${termString}' term is contained in the '${statementString}' statement.`, this.node);
+      context.debug(`...the '${termString}' term is contained in the '${statementString}' statement.`, node);
     }
 
     return termContained;
@@ -61,25 +68,25 @@ export default define(class Statement extends Element {
   isFrameContained(frame, context) {
     let frameContained;
 
-    const frameString = frame.getString(),
-          statementString = this.string;  ///
+    const node = this.getNode(),
+          frameString = frame.getString(),
+          statementString = this.getString();  ///
 
-    context.trace(`Is the '${frameString}' frame contained in the '${statementString}' statement...`, this.node);
+    context.trace(`Is the '${frameString}' frame contained in the '${statementString}' statement...`, node);
 
-    const frameNode = frame.getNode(),
-          statementNode = this.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;
       }
     });
 
     if (frameContained) {
-      context.debug(`...the '${frameString}' frame is contained in the '${statementString}' statement.`, this.node);
+      context.debug(`...the '${frameString}' frame is contained in the '${statementString}' statement.`, node);
     }
 
     return frameContained;
@@ -91,8 +98,9 @@ export default define(class Statement extends Element {
     const singular = this.isSingular();
 
     if (singular) {
-      const metavariableA = metavariable, ///
-            singularMetavariableNode = this.node.getSingularMetavariableNode(),
+      const node = this.getNode(),
+            metavariableA = metavariable, ///
+            singularMetavariableNode = node.getSingularMetavariableNode(),
             metavariableName = singularMetavariableNode.getMetavariableName();
 
       metavariable = context.findMetavariableByMetavariableName(metavariableName)
@@ -106,63 +114,64 @@ export default define(class Statement extends Element {
     return metavariableEqualToMetavariable;
   }
 
-  matchStatementNode(statementNode) { return this.node.match(statementNode); }
-
-  verify(assignments, stated, context) {
-    let verifies;
+  validate(assignments, stated, context) {
+    let validates;
 
-    const statementString = this.string;  ///
+    const node = this.getNode(),
+          statementString = this.getString();  ///
 
-    context.trace(`Verifying the '${statementString}' statement...`, this.node);
+    context.trace(`Validating the '${statementString}' statement...`, node);
 
-    verifies = verifyMixins.some((verifyMixin) => {
+    validates = validateStatements.some((validateStatement) => {
       const statement = this, ///
-            verifies = verifyMixin(statement, assignments, stated, context);
+            statementValidates = validateStatement(statement, assignments, stated, context);
 
-      if (verifies) {
+      if (statementValidates) {
         return true;
       }
     });
 
-    if (verifies) {
+    if (validates) {
       const statement = this; ///
 
       context.addStatement(statement);
 
-      context.debug(`...verified the '${statementString}' statement.`, this.node);
+      context.debug(`...validated the '${statementString}' statement.`, node);
     }
 
-    return verifies;
+    return validates;
   }
 
-  verifyGivenMetaType(metaType, assignments, stated, context) {
-    let verifiesGivenMetaType = false;
+  validateGivenMetaType(metaType, assignments, stated, context) {
+    let validatesGivenMetaType = false;
 
-    const metaTypeString = metaType.getString(),
-          statementString = this.string;  ///
+    const node = this.getNode(),
+          metaTypeString = metaType.getString(),
+          statementString = this.getString();  ///
 
-    context.trace(`Verifying the '${statementString}' statement given the '${metaTypeString}' meta-type...`, this.node);
+    context.trace(`Validating the '${statementString}' statement given the '${metaTypeString}' meta-type...`, node);
 
     const metaTypeName = metaType.getName();
 
     if (metaTypeName === STATEMENT_META_TYPE_NAME) {
-      const verifies = this.verify(assignments, stated, context)
+      const validates = this.validate(assignments, stated, context)
 
-      verifiesGivenMetaType = verifies; ///
+      validatesGivenMetaType = validates; ///
     }
 
-    if (verifiesGivenMetaType) {
-      context.debug(`...verified the '${statementString}' statement given the '${metaTypeString}' meta-type.`, this.node);
+    if (validatesGivenMetaType) {
+      context.debug(`...validated the '${statementString}' statement given the '${metaTypeString}' meta-type.`, node);
     }
 
-    return verifiesGivenMetaType;
+    return validatesGivenMetaType;
   }
 
   unifySubproof(subproof, substitutions, generalContext, specificContext) {
     let subproofUnifies = false;
 
-    const context = specificContext,  ///
-          statementNode = this.node,
+    const node = this.getNode(),
+          context = specificContext,  ///
+          statementNode = node,
           subproofAssertionNode = statementNode.getSubproofAssertionNode(),
           assertionNode = subproofAssertionNode;  ///
 
@@ -219,11 +228,12 @@ export default define(class Statement extends Element {
     let unifiesIndependently = false;
 
     const context = specificContext,  ///
-          statementString = this.string;  ///
+          statementString = this.getString();  ///
 
     context.trace(`Unifying the '${statementString}' statement independently...`);
 
-    const statementNode = this.node,
+    const node = this.getNode(),
+          statementNode = node, ///
           definedAssertionNode = statementNode.getDefinedAssertionNode(),
           containedAssertionNode = statementNode.getContainedAssertionNode();
 
@@ -244,23 +254,23 @@ export default define(class Statement extends Element {
     return unifiesIndependently;
   }
 
-  equateWithStepsOrSubproofs(stepsOrSubproofs, context) {
-    let equatesWithStepsOrSubproofs;
+  compareStepsOrSubproofs(stepsOrSubproofs, context) {
+    let comparesToStepsOrSubproofs;
 
-    equatesWithStepsOrSubproofs = backwardsSome(stepsOrSubproofs, (stepOrSubproof) => {
+    comparesToStepsOrSubproofs = backwardsSome(stepsOrSubproofs, (stepOrSubproof) => {
       const statement = this, ///
-            statementUnifies = stepOrSubproof.equateWithStatement(statement, context);
+            stepOrSubproofComparesToStatement = stepOrSubproof.compareStatement(statement, context);
 
-      if (statementUnifies) {
+      if (stepOrSubproofComparesToStatement) {
         return true;
       }
     });
 
-    return equatesWithStepsOrSubproofs;
+    return comparesToStepsOrSubproofs;
   }
 
   toJSON() {
-    const string = this.string, ///
+    const string = this.getString(),
           json = {
             string
           };
@@ -273,8 +283,11 @@ export default define(class Statement extends Element {
   static fromJSON(json, context) {
     const { string } = json,
           statmentNode = instantiateStatement(string, context),
-          node = statmentNode,  ///,
-          statement = new Statement(string, node);
+          node = statmentNode;  ///,
+
+    context = null;
+
+    const statement = new Statement(context, string, node);
 
     return statement;
   }

package/src/element/step.js

@@ -2,11 +2,13 @@
 
 import Element from "../element";
 import elements from "../elements";
-import unifyMixins from "../mixins/step/unify";
 import TemporaryContext from "../context/temporary";
 
 import { define } from "../elements";
+import { instantiateStep } from "../process/instantiate";
+import { unifyStatements } from "../utilities/unification";
 import { equateStatements } from "../process/equate";
+import { stepFromStepNode } from "../utilities/element";
 import { propertyAssertionFromStatement } from "../utilities/statement";
 
 export default define(class Step extends Element {
@@ -55,16 +57,16 @@ export default define(class Step extends Element {
     return step;
   }
 
-  matchTermAndPropertyRelation(term, propertyRelation, context) {
-    let termAndPropertyRelationMatch = false;
+  compareTermAndPropertyRelation(term, propertyRelation, context) {
+    let comparesToTermAndPropertyRelation = false;
 
     const propertyAssertion = propertyAssertionFromStatement(this.statement, context);
 
     if (propertyAssertion !== null) {
-      termAndPropertyRelationMatch = propertyAssertion.matchTermAndPropertyRelation(term, propertyRelation, context);
+      comparesToTermAndPropertyRelation = propertyAssertion.compareTermAndPropertyRelation(term, propertyRelation, context);
     }
 
-    return termAndPropertyRelationMatch;
+    return comparesToTermAndPropertyRelation;
   }
 
   verify(substitutions, assignments, context) {
@@ -74,77 +76,102 @@ export default define(class Step extends Element {
 
     context = temporaryContext; ///
 
-    const stepString = this.string; ///
+    const node = this.getNode(),
+          stepString = this.getString(); ///
 
-    context.trace(`Verifying the '${stepString}' step...`, this.node);
+    context.trace(`Verifying the '${stepString}' step...`, node);
 
-    if (this.statement !== null) {
-      const stated = this.isStated(),
-            statementVerifies = this.statement.verify(assignments, stated, context);
+    if (this.statement === null) {
+      context.debug(`Unable to verify the '${stepString}' step because it is nonsense.`, node);
+    } else {
+      const referenceVerifies = this.verifyReference(context);
 
-      if (statementVerifies) {
-        const qualified = this.isQualified(),
-              satisfied = this.isSatisfied();
+      if (referenceVerifies) {
+        const satisfiesAssertioVeriries = this.verifySatisfiesAssertion(context);
 
-        if (false) {
-          ///
-        } else if (qualified) {
-          const referenceVerifies = this.reference.verify(context);
+        if (satisfiesAssertioVeriries) {
+          const stated = this.isStated(),
+                statementValidates = this.statement.validate(assignments, stated, context);
 
-          if (referenceVerifies) {
-            verifies = true;
-          }
-        } else if (satisfied) {
-          const stated = true,
-                assignments = null,
-                satisfiesAssertionVerifies = this.satisfiesAssertion.verify(assignments, stated, context);
+          if (statementValidates) {
+            const statementUnifies = unifyStatements.some((unifyStatement) => {
+              const statementUnifies = unifyStatement(this.statement, this.reference, this.satisfiesAssertion, substitutions, context);
+
+              if (statementUnifies) {
+                return true;
+              }
+            });
+
+            if (statementUnifies) {
+              const { Step } = elements,
+                    step = Step.fromStatement(this.statement, context),
+                    stepOrSubproof = step;  ///
+
+              context.addStepOrSubproof(stepOrSubproof);
+
+              this.setContext(context);
 
-          if (satisfiesAssertionVerifies) {
-            verifies = true;
+              verifies = true;
+            }
           }
-        } else {
-          verifies = true;
         }
       }
-    } else {
-      context.debug(`Cannot verify the '${stepString}' step because it is nonsense.`, this.node);
     }
 
     if (verifies) {
-      this.context = context;
-
-      context.debug(`...verified the '${stepString}' step.`, this.node);
+      context.debug(`...verified the '${stepString}' step.`, node);
     }
 
     return verifies;
   }
 
-  unify(substitutions, context) {
-    let unifies;
+  verifyReference(context) {
+    let referenceVeriries;
 
-    context = this.context;
+    const node = this.getNode(),
+          stepString = this.getString();  ///
 
-    const stepString = this.string;  ///
+    context.trace(`Verifying the '${stepString}' step's reference... `, node);
 
-    context.trace(`Unifying the '${stepString}' step...`, this.node);
+    if (this.reference !== null) {
+      referenceVeriries = this.reference.verify(context);
+    } else {
+      referenceVeriries = true;
+    }
 
-    unifies = unifyMixins.some((unifyMixin) => {
-      const unifies = unifyMixin(this.statement, this.reference, this.satisfiesAssertion, substitutions, context);
+    if (referenceVeriries) {
+      context.debug(`...verified the '${stepString}' step's reference. `, node);
+    }
 
-      if (unifies) {
-        return true;
-      }
-    });
+    return referenceVeriries;
+  }
+
+  verifySatisfiesAssertion(context) {
+    let satisfiesAssertionVerifies;
+
+    const node = this.getNode(),
+          stepString = this.getString();  ///
 
-    if (unifies) {
-      context.debug(`...unified the '${stepString}' step.`, this.node);
+    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;
     }
 
-    return unifies;
+    if (satisfiesAssertionVerifies) {
+      context.debug(`...verified the '${stepString}' step's satisfies assertion. `, node);
+    }
+
+    return satisfiesAssertionVerifies;
   }
 
-  equateWithStatement(statement, context) {
-    let statementEquates;
+  compareStatment(statement, context) {
+    let comparesToStatement;
 
     const leftStatement = statement,  ///
           rightStatement = this.statement,  ///
@@ -152,9 +179,9 @@ export default define(class Step extends Element {
           rightStatementNode = rightStatement.getNode(),
           statementsEquate = equateStatements(leftStatementNode, rightStatementNode, context);
 
-    statementEquates = statementsEquate;  ///
+    comparesToStatement = statementsEquate;  ///
 
-    return statementEquates;
+    return comparesToStatement;
   }
 
   unifyWithSatisfiesAssertion(satisfiesAssertion, context) {
@@ -191,4 +218,15 @@ export default define(class Step extends Element {
   }
 
   static name = "Step";
+
+  static fromStatement(statement, context) {
+    const statementString = statement.getString(),
+          stepString = statementString, ///
+          string = `${stepString}
+`,
+          stepNode = instantiateStep(string, context),
+          step = stepFromStepNode(stepNode, context);
+
+    return step;;
+  }
 });

package/src/element/subDerivation.js

@@ -32,19 +32,15 @@ export default define(class SubDerivation extends Element {
 
     verifies = this.stepsOrSubproofs.every((stepOrSubproof) => { ///
       const assignments = [],
-            stepOrSubproofVerifies = stepOrSubproof.verify(substitutions, assignments, context);
+            stepOrSubproofVarifies = stepOrSubproof.verify(substitutions, assignments, context);
 
-      if (stepOrSubproofVerifies) {
-        const stepOrSubproofUnifies = stepOrSubproof.unify(substitutions, context);
+      if (stepOrSubproofVarifies) {
+        const assignmentsAssigned = assignAssignments(assignments, context);
 
-        if (stepOrSubproofUnifies) {
-          const assignmentsAssigned = assignAssignments(assignments, context);
+        if (assignmentsAssigned) {
+          context.addStepOrSubproof(stepOrSubproof);
 
-          if (assignmentsAssigned) {
-            context.addStepOrSubproof(stepOrSubproof);
-
-            return true;
-          }
+          return true;
         }
       }
     });

package/src/element/subproof.js

@@ -46,16 +46,8 @@ export default define(class Subproof extends Element {
     return sStep;
   }
 
-  unify(substitutions, context) {
-    let unifies;
-
-    unifies = true; ///
-
-    return unifies;
-  }
-
   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;

package/src/element/substitution/frame.js

@@ -33,8 +33,6 @@ export default define(class FrameSubstitution extends Substitution {
 
   isMetavariableEqualToMetavariable(metavariable) { return this.metavariable.isEqualTo(metavariable); }
 
-  matchParameter(parameter) { return this.metavariable.matchParameter(parameter); }
-
   verify(context) {
     let verifies = false;
 

package/src/element/substitution/reference.js

@@ -22,11 +22,7 @@ export default define(class ReferenceSubstitution extends Substitution {
     return this.metavariable;
   }
 
-  isReferenceEqualToReference(reference) {
-    const referenceEqualToReference = this.reference.isEqualTo(reference);
-
-    return referenceEqualToReference;
-  }
+  isReferenceEqualToReference(reference) { return this.reference.isEqualTo(reference); }
 
   static name = "ReferenceSubstitution";
 

package/src/element/substitution/statement.js

@@ -43,18 +43,16 @@ export default define(class StatementSubstitution extends Substitution {
     return replacementNode;
   }
 
-  isSimple() {
-    const simple = (this.substitution === null);
-
-    return simple;
+  setStatement(statement) {
+    this.statement = statement;
   }
 
-  isStatementEqualToStatement(statement, context) {
-    statement = stripBracketsFromStatement(statement, context); ///
-
-    const statementEqualToStatement = this.statement.isEqualTo(statement);
+  setMetavariable(metavariable) {
+    this.metavariable = metavariable;
+  }
 
-    return statementEqualToStatement;
+  setSubstitution(substitution) {
+    this.substitution = substitution;
   }
 
   isMetavariableEqualToMetavariable(metavariable) { return this.metavariable.isEqualTo(metavariable); }
@@ -75,7 +73,19 @@ export default define(class StatementSubstitution extends Substitution {
     return substitutionEqualToSubstitution;
   }
 
-  matchParameter(parameter) { return this.metavariable.matchParameter(parameter); }
+  isStatementEqualToStatement(statement, context) {
+    statement = stripBracketsFromStatement(statement, context); ///
+
+    const statementEqualToStatement = this.statement.isEqualTo(statement);
+
+    return statementEqualToStatement;
+  }
+
+  isSimple() {
+    const simple = (this.substitution === null);
+
+    return simple;
+  }
 
   unifyStatement(statement, context) {
     let substitution = null;
@@ -205,8 +215,17 @@ export default define(class StatementSubstitution extends Substitution {
     statement = stripBracketsFromStatement(statement, context); ///
 
     const string = stringFromStatementAndMetavariable(statement, metavariable),
-          statementSubstitutionNode = instantiateStatementSubstitution(string, context),
-          statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context);
+          statementSubstitutionNode = instantiateStatementSubstitution(string, context);
+
+    context = {
+      nodeAsString: () => string
+    };
+
+    const statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context);
+
+    statementSubstitution.setStatement(statement);
+
+    statementSubstitution.setMetavariable(metavariable);
 
     return statementSubstitution;
   }
@@ -215,8 +234,19 @@ export default define(class StatementSubstitution extends Substitution {
     statement = stripBracketsFromStatement(statement, context); ///
 
     const string = stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context),
-          statementSubstitutionNode = instantiateStatementSubstitution(string, context),
-          statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, substitution, context);
+          statementSubstitutionNode = instantiateStatementSubstitution(string, context);
+
+    context = {
+      nodeAsString: () => string
+    };
+
+    const statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context);
+
+    statementSubstitution.setStatement(statement);
+
+    statementSubstitution.setMetavariable(metavariable);
+
+    statementSubstitution.setSubstitution(substitution);
 
     return statementSubstitution;
   }