occam-verify-cli 1.0.448 → 1.0.472

package/src/element/substitution/statement.js

@@ -4,100 +4,190 @@ import elements from "../../elements";
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
+import { literally } from "../../utilities/context";
 import { unifySubstitution } from "../../process/unify";
 import { stripBracketsFromStatement } from "../../utilities/brackets";
 import { instantiateStatementSubstitution } from "../../process/instantiate";
 import { statementSubstitutionFromStatementSubstitutionNode } from "../../utilities/element";
-import { statementFromJSON, statementToStatementJSON, metavariableFromJSON, metavariableToMetavariableJSON } from "../../utilities/json";
+import { statementToStatementJSON, metavariableToMetavariableJSON } from "../../utilities/json";
+import { statementSubstitutionStringFromStatementAndMetavariable, statementSubstitutionStringFromStatementMetavariableAndSubstitution } from "../../utilities/string";
 
 export default define(class StatementSubstitution extends Substitution {
-  constructor(context, string, node, resolved, statement, metavariable, substitution) {
+  constructor(context, string, node, resolved, substitution, targetStatement, replacementStatement) {
     super(context, string, node);
 
     this.resolved = resolved;
-    this.statement = statement;
-    this.metavariable = metavariable;
     this.substitution = substitution;
+    this.targetStatement = targetStatement;
+    this.replacementStatement = replacementStatement;
   }
 
   isResolved() {
     return this.resolved;
   }
 
-  getStatement() {
-    return this.statement;
+  getSubstitution() {
+    return this.substitution;
   }
 
-  getMetavariable() {
-    return this.metavariable;
+  getTargetStatement() {
+    return this.targetStatement;
   }
 
-  getSubstitution() {
-    return this.substitution;
+  getReplacementStatement() {
+    return this.replacementStatement;
+  }
+
+  getTargetNode() {
+    const targetStatementNode = this.targetStatement.getNode(),
+          targetNode = targetStatementNode; ///
+
+    return targetNode;
   }
 
   getReplacementNode() {
-    const statementNode = this.statement.getNode(),
-          replacementNode = statementNode; ///
+    const replacementStatementNode = this.replacementStatement.getNode(),
+          replacementNode = replacementStatementNode; ///
 
     return replacementNode;
   }
 
-  setStatement(statement) {
-    this.statement = statement;
+  isSimple() {
+    const simple = (this.substitution === null);
+
+    return simple;
   }
 
-  setMetavariable(metavariable) {
-    this.metavariable = metavariable;
+  compareStatement(statement, context) {
+    statement = stripBracketsFromStatement(statement, context); ///
+
+    const replacementStatementEqualToStatement = this.replacementStatement.isEqualTo(statement),
+          comparesToStatement = replacementStatementEqualToStatement;  ///
+
+    return comparesToStatement;
   }
 
-  setSubstitution(substitution) {
-    this.substitution = substitution;
+  compareParameter(parameter) {
+    const targetStatementComparesToParameter = this.targetStatement.compareParameter(parameter),
+          comparesToParameter = targetStatementComparesToParameter;  ///
+
+    return comparesToParameter;
   }
 
-  isMetavariableEqualToMetavariable(metavariable) { return this.metavariable.isEqualTo(metavariable); }
+  compareSubstitution(substitution) {
+    let comparesToSubstitution = false;
 
-  isSubstitutionEqualToSubstitution(substitution) {
-    let substitutionEqualToSubstitution;
+    if (false) {
+      ///
+    } else if ((this.substitution === null) && (substitution === null)){
+      comparesToSubstitution = true;
+    } else if ((this.substitution !== null) && (substitution !== null)){
+      const substitutionEqualToSubstituion = this.substitution.isEqualTo(substitution);
 
-    if (this.substitution === null) {
-      substitutionEqualToSubstitution = (substitution === null);
-    } else {
-      if (substitution === null) {
-        substitutionEqualToSubstitution = false;
-      } else {
-        substitutionEqualToSubstitution = this.substitution.isEqualTo(substitution);
+      if (substitutionEqualToSubstituion) {
+        comparesToSubstitution = true;
       }
     }
 
-    return substitutionEqualToSubstitution;
+    return comparesToSubstitution;
   }
 
-  isStatementEqualToStatement(statement, context) {
-    statement = stripBracketsFromStatement(statement, context); ///
+  validate(context) {
+    let validates = false;
+
+    const statementSubstitutionString = this.getString();  ///
+
+    context.trace(`Validating the '${statementSubstitutionString}' statement substitution...`);
+
+    const targetStatementValidates = this.validateTargetStatement(context);
 
-    const statementEqualToStatement = this.statement.isEqualTo(statement);
+    if (targetStatementValidates) {
+      const replacementStatementValidates = this.validateReplacementStatement(context);
 
-    return statementEqualToStatement;
+      if (replacementStatementValidates) {
+        validates = true;
+      }
+    }
+
+    if (validates) {
+      const substititoin = this;  ///
+
+      context.addSubstitution(substititoin);
+
+      context.debug(`...validated the '${statementSubstitutionString}' statement substitution.`);
+    }
+
+    return validates;
   }
 
-  isSimple() {
-    const simple = (this.substitution === null);
+  validateTargetStatement(context) {
+    let targetStatementValidates = false;
 
-    return simple;
+    const targetStatementString = this.targetStatement.getString(),
+          statementSubstitutionString = this.getString();  ///
+
+    context.trace(`Validating the '${statementSubstitutionString}' statement subtitution's '${targetStatementString}' target statement...`);
+
+    const targetStatementSingular = this.targetStatement.isSingular();
+
+    if (targetStatementSingular) {
+      const stated = true,
+            assignments = null;
+
+      targetStatementValidates = this.targetStatement.validate(assignments, stated, context);
+    } else {
+      context.debug(`The '${statementSubstitutionString}' statement subtitution's '${targetStatementString}' target statement is not singular.`);
+    }
+
+    if (targetStatementValidates) {
+      context.debug(`...validated the '${statementSubstitutionString}' statement subtitution's '${targetStatementString}' target statement...`);
+    }
+
+    return targetStatementValidates;
+  }
+
+  validateReplacementStatement(context) {
+    let replacementStatementValidates;
+
+    const replacementStatementString = this.replacementStatement.getString(),
+          statementSubstitutionString = this.getString();  ///
+
+    context.trace(`Validating the '${statementSubstitutionString}' statement subtitution's '${replacementStatementString}' replacement statement...`);
+
+    const stated = true,
+          assignments = null;
+
+    replacementStatementValidates = this.replacementStatement.validate(assignments, stated, context);
+
+    if (replacementStatementValidates) {
+      context.debug(`...validated the '${statementSubstitutionString}' statement subtitution's '${replacementStatementString}' replacement statement...`);
+    }
+
+    return replacementStatementValidates;
   }
 
   unifyStatement(statement, context) {
-    let substitution = null;
+    let statementUnifies = false;
 
-    const { Substitutions } = elements,
-          substitutions = Substitutions.fromNothing(),
-          specificContext = context; ///
+    const statementString = statement.getString(),
+          statementSubstitutionString = this.getString();
+
+    context.trace(`Unifying the '${statementString}' statement with the '${statementSubstitutionString}' statement substiution's statement...`);
+
+    const specificContext = context; ///
 
     context = this.getContext();
 
-    const generalContext = context, ///
-          statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
+    const generalContext = context; ///
+
+    context = specificContext;  ///
+
+    const { Substitutions } = elements,
+          substitutions = Substitutions.fromNothing(context);
+
+    statementUnifies = this.replacementStatement.unifyStatement(statement, substitutions, generalContext, specificContext);
+
+    let substitution = null;
 
     if (statementUnifies) {
       const substitutionsNonTrivialLength = substitutions.getNonTrivialLength();
@@ -106,9 +196,15 @@ export default define(class StatementSubstitution extends Substitution {
         const firstSubstitution = substitutions.getFirstSubstitution();
 
         substitution = firstSubstitution; ///
+      } else {
+        statementUnifies = false;
       }
     }
 
+    if (statementUnifies) {
+      context.trace(`...unified the '${statementString}' statement with the '${statementSubstitutionString}' statement substiution's statement.`);
+    }
+
     return substitution;
   }
 
@@ -139,41 +235,28 @@ export default define(class StatementSubstitution extends Substitution {
   }
 
   resolve(substitutions, context) {
-    const substitutionString = this.string; ///
+    context = this.getContext();
+
+    const substitutionString = this.getString(); ///
 
     context.trace(`Resolving the ${substitutionString} substitution...`);
 
-    substitutions.snapshot();
+    substitutions.snapshot(context);
 
     const metavariable = this.getMetavariable(),
-          simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariable(metavariable);
+          simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariable(metavariable),
+          substitution = simpleSubstitution.unifyStatement(this.replacementStatement, context);
 
-    if (simpleSubstitution !== null) {
-      let context;
+    if (substitution !== null) {
+      const substitutionUnifies = this.unifySubstitution(substitution, substitutions, context);
 
-      context = this.getContext();
-
-      const substitution = simpleSubstitution.unifyStatement(this.statement, context);
-
-      if (substitution !== null) {
-        context = simpleSubstitution.getContext();
-
-        const simpleContext = context;  ///
-
-        context = substitution.getContext();
-
-        context.merge(simpleContext);
-
-        const substitutionUnifies = this.unifySubstitution(substitution, substitutions, context);
-
-        if (substitutionUnifies) {
-          this.resolved = true;
-        }
+      if (substitutionUnifies) {
+        this.resolved = true;
       }
     }
 
     this.resolved ?
-      substitutions.continue() :
+      substitutions.continue(context) :
         substitutions.rollback(context);
 
     if (this.resolved) {
@@ -182,11 +265,11 @@ export default define(class StatementSubstitution extends Substitution {
   }
 
   toJSON() {
-    const metavariableJSON = metavariableToMetavariableJSON(this.metavariable),
-          statementJSON = statementToStatementJSON(this.statement),
+    const metavariableJSON = metavariableToMetavariableJSON(this.targetStatement),
+          statementJSON = statementToStatementJSON(this.replacementStatement),
           metavariable = metavariableJSON,  ///
           statement = statementJSON,  ///
-          string = this.string, ///
+          string = this.getString(), ///
           json = {
             string,
             statement,
@@ -199,80 +282,36 @@ export default define(class StatementSubstitution extends Substitution {
   static name = "StatementSubstitution";
 
   static fromJSON(json, context) {
-    const { string } = json,
-          statementSubstitutionNode = instantiateStatementSubstitution(string, context),
-          node = statementSubstitutionNode,
-          resolved = true,
-          statement = statementFromJSON(json, context),
-          metavariable = metavariableFromJSON(json, context),
-          substitution = null,  ///
-          statementSubstitution = new StatementSubstitution(context, string, node, resolved, statement, metavariable, substitution);
-
-    return statementSubstitution;
+    ///
   }
 
   static fromStatementAndMetavariable(statement, metavariable, context) {
     statement = stripBracketsFromStatement(statement, context); ///
 
-    const string = stringFromStatementAndMetavariable(statement, metavariable),
-          statementSubstitutionNode = instantiateStatementSubstitution(string, context);
-
-    context = {
-      nodeAsString: () => string
-    };
-
-    const statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context);
+    return literally((context) => {
+      const statementSubstitutionString = statementSubstitutionStringFromStatementAndMetavariable(statement, metavariable, context),
+            string = statementSubstitutionString, ///
+            statementSubstitutionNode = instantiateStatementSubstitution(string, context),
+            statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context);
 
-    statementSubstitution.setStatement(statement);
+      statementSubstitution.validate(context);
 
-    statementSubstitution.setMetavariable(metavariable);
-
-    return statementSubstitution;
+      return statementSubstitution;
+    }, context);
   }
 
   static fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context) {
     statement = stripBracketsFromStatement(statement, context); ///
 
-    const string = stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context),
-          statementSubstitutionNode = instantiateStatementSubstitution(string, context);
-
-    context = {
-      nodeAsString: () => string
-    };
+    return literally((context) => {
+      const statementSubstitutionString = statementSubstitutionStringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution),
+            string = statementSubstitutionString, ///
+            statementSubstitutionNode = instantiateStatementSubstitution(string, context),
+            statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, substitution, context);
 
-    const statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context);
+      statementSubstitution.validate(context);
 
-    statementSubstitution.setStatement(statement);
-
-    statementSubstitution.setMetavariable(metavariable);
-
-    statementSubstitution.setSubstitution(substitution);
-
-    return statementSubstitution;
+      return statementSubstitution;
+    }, context);
   }
 });
-
-function stringFromStatementAndMetavariable(statement, metavariable) {
-  const statementString = statement.getString(),
-        metavariableString = metavariable.getString(),
-        string = `[${statementString} for ${metavariableString}]`;
-
-  return string;
-}
-
-function stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution) {
-  let string;
-
-  const statementString = statement.getString(),
-        metavariableString = metavariable.getString();
-
-  if (substitution === null) {
-    string = `[${statementString} for ${metavariableString}]`;
-  } else {
-    const substitutionString = substitution.getString();
-
-    string = `[${statementString} for ${metavariableString}${substitutionString}]`;
-  }
-
-  return string;
-}

package/src/element/substitution/term.js

@@ -3,97 +3,139 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
+import { literally } from "../../utilities/context";
 import { stripBracketsFromTerm } from "../../utilities/brackets";
 import { instantiateTermSubstitution } from "../../process/instantiate";
+import { termSubstitutionStringFromTermAndVariable } from "../../utilities/string";
 import { termSubstitutionFromStatementNode, termSubstitutionFromTermSubstitutionNode } from "../../utilities/element";
 
 export default define(class TermSubstitution extends Substitution {
-  constructor(context, string, node, term, variable) {
+  constructor(context, string, node, targetTerm, replacementTerm) {
     super(context, string, node);
 
-    this.term = term;
-    this.variable = variable;
+    this.targetTerm = targetTerm;
+    this.replacementTerm = replacementTerm;
   }
 
-  getTerm() {
-    return this.term;
+  getTargetTerm() {
+    return this.targetTerm;
   }
 
-  getVariable() {
-    return this.variable;
+  getReplacementTerm() {
+    return this.replacementTerm;
+  }
+
+  getTargetNode() {
+    const targetTermNode = this.targetTerm.getNode(),
+          tergetNode = targetTermNode; ///
+
+    return tergetNode;
   }
 
   getReplacementNode() {
-    const termNode = this.term.getNode(),
-          replacementNode = termNode; ///
+    const replacementTermNode = this.replacementTerm.getNode(),
+          replacementNode = replacementTermNode; ///
 
     return replacementNode;
   }
 
-  isTermEqualToTerm(term, context) {
+  isTrivial() {
+    const targetTermEqualToReplacementTerm = this.targetTerm.isEqualTo(this.replacementTerm),
+          trivial = targetTermEqualToReplacementTerm; ///
+
+    return trivial;
+  }
+
+  compareTerm(term, context) {
     term = stripBracketsFromTerm(term, context); ///
 
-    const termEqualToTerm = this.term.isEqualTo(term);
+    const termEqualToReplacementTerm = this.replacementTerm.isEqualTo(term),
+          comparedToTerm = termEqualToReplacementTerm; ///
 
-    return termEqualToTerm;
+    return comparedToTerm;
   }
 
-  isTrivial() {
-    let trivial = false;
+  compareParameter(parameter) {
+    const targetTermComparesToParameter = this.targetTerm.compareParameter(parameter),
+          comparesToParameter = targetTermComparesToParameter;  ///
+
+    return comparesToParameter;
+  }
+
+  validate(context) {
+    let validates = false;
+
+    const termSubstitutionString = this.getString();  ///
+
+    context.trace(`Validating the '${termSubstitutionString}' term substitution...`);
+
+    const targetTermValidates = this.validateTargetTerm(context);
 
-    const termComparesToVaraible = this.term.compareVariable(this.variable);
+    if (targetTermValidates) {
+      const replacementTermValidates = this.validateReplacementTerm(context);
 
-    if (termComparesToVaraible) {
-      trivial = true;
+      if (replacementTermValidates) {
+        validates = true;
+      }
     }
 
-    return trivial;
-  }
+    if (validates) {
+      const substititoin = this;  ///
+
+      context.addSubstitution(substititoin);
 
-  verify(context) {
-    let verifies = false;
+      context.debug(`...validated the '${termSubstitutionString}' term substitution.`);
+    }
 
-    const termSubstitutionString = this.string;  ///
+    return validates;
+  }
 
-    context.trace(`Verifiying the '${termSubstitutionString}' term substitution...`);
+  validateTargetTerm(context) {
+    let targetTermValidates = false;
 
-    const termSingular = this.term.isSingular();
+    const targetTermString = this.targetTerm.getString(),
+          termSubstitutionString = this.getString();  ///
 
-    if (termSingular) {
-      if (this.variable !== null) {
-        const variableIdentifier = this.variable.getIdentifier(),
-              variablePresent = context.isVariablePresentByVariableIdentifier(variableIdentifier);
+    context.trace(`Validating the '${termSubstitutionString}' term subtitution's '${targetTermString}' target term...`);
 
-        if (variablePresent) {
-          const termNode = this.term.getNode(),
-                variableIdentifier = termNode.getVariableIdentifier(),
-                termVariableIdentifier = variableIdentifier,  ///
-                termVariablePresent = context.isVariablePresentByVariableIdentifier(termVariableIdentifier);
+    const targetTermSingular = this.targetTerm.isSingular();
 
-          if (termVariablePresent) {
-            verifies = true;
-          } else {
-            context.debug(`The '${termSubstitutionString}' term substitution's general term's variable is not present.`);
-          }
-        } else {
-          context.debug(`The '${termSubstitutionString}' term substitution's specific term's variable is not present.`);
-        }
-      } else {
-        context.debug(`The '${termSubstitutionString}' term substitution's general term is not singular.`);
-      }
+    if (targetTermSingular) {
+      targetTermValidates = this.targetTerm.validate(context, () => {
+        const verifiesAhead = true;
+
+        return verifiesAhead;
+      });
     } else {
-      context.debug(`The '${termSubstitutionString}' term substitution's specific term is not singular.`);
+      context.debug(`The '${termSubstitutionString}' term subtitution's '${targetTermString}' target term is not singular.`);
     }
 
-    if (verifies) {
-      const substititoin = this;  ///
+    if (targetTermValidates) {
+      context.debug(`...validated the '${termSubstitutionString}' term subtitution's '${targetTermString}' target term...`);
+    }
 
-      context.addSubstitution(substititoin);
+    return targetTermValidates;
+  }
+
+  validateReplacementTerm(context) {
+    let replacementTermValidates;
 
-      context.debug(`...verified the '${termSubstitutionString}' term substitution.`);
+    const replacementTermString = this.replacementTerm.getString(),
+          termSubstitutionString = this.getString();  ///
+
+    context.trace(`Validating the '${termSubstitutionString}' term subtitution's '${replacementTermString}' replacement term...`);
+
+    replacementTermValidates = this.replacementTerm.validate(context, () => {
+      const validatesAhead = true;
+
+      return validatesAhead;
+    });
+
+    if (replacementTermValidates) {
+      context.debug(`...validated the '${termSubstitutionString}' term subtitution's '${replacementTermString}' replacement term...`);
     }
 
-    return verifies;
+    return replacementTermValidates;
   }
 
   static name = "TermSubstitution";
@@ -105,19 +147,18 @@ export default define(class TermSubstitution extends Substitution {
     return termSubstitution;
   }
 
-  static fromTermAndMetavariable(term, metavariable, context) {
-    const string = stringFromTermAndVariable(term, metavariable),
-          termSubstitutionNode = instantiateTermSubstitution(string, context),
-          termSubstitution = termSubstitutionFromTermSubstitutionNode(termSubstitutionNode, context);
+  static fromTermAndVariable(term, variable, context) {
+    term = stripBracketsFromTerm(term, context); ///
+
+    return literally((context) => {
+      const termSubstitutionString = termSubstitutionStringFromTermAndVariable(term, variable),
+            string = termSubstitutionString,  ///
+            termSubstitutionNode = instantiateTermSubstitution(string, context),
+            termSubstitution = termSubstitutionFromTermSubstitutionNode(termSubstitutionNode, context);
 
-    return termSubstitution;
+      termSubstitution.validate(context);
+
+      return termSubstitution;
+    }, context);
   }
 });
-
-function stringFromTermAndVariable(term, variable) {
-  const termString = term.getString(),
-        variableString = variable.getString(),
-        string = `[${termString} for ${variableString}]`;
-
-  return string;
-}