occam-verify-cli 1.0.388 → 1.0.404

package/src/ontology/substitution/statement.js

@@ -1,7 +1,7 @@
 "use strict";
 
+import ontology from "../../ontology";
 import Substitution from "../substitution";
-import Substitutions from "../../substitutions";
 import StatementSubstitutionPartialContext from "../../context/partial/substitution/statement";
 
 import { define } from "../../ontology";
@@ -10,8 +10,8 @@ import { stripBracketsFromStatement } from "../../utilities/brackets";
 import { statementFromJSON, statementToStatementJSON, metavariableFromJSON, metavariableToMetavariableJSON } from "../../utilities/json";
 
 export default define(class StatementSubstitution extends Substitution {
-  constructor(string, node, tokens, resolved, statement, metavariable, substitution) {
-    super(string, node, tokens);
+  constructor(context, string, node, tokens, resolved, statement, metavariable, substitution) {
+    super(context, string, node, tokens);
 
     this.resolved = resolved;
     this.statement = statement;
@@ -35,112 +35,103 @@ export default define(class StatementSubstitution extends Substitution {
     return this.substitution;
   }
 
-  isStatementEqualTo(statement, context) {
+  getReplacementNode() {
+    const statementNode = this.statement.getNode(),
+          replacementNode = statementNode; ///
+
+    return replacementNode;
+  }
+
+  isSimple() {
+    const simple = (this.substitution === null);
+
+    return simple;
+  }
+
+  isStatementEqualToStatement(statement, context) {
     statement = stripBracketsFromStatement(statement, context); ///
 
-    const statementEqualTo = this.statement.isEqualTo(statement);
+    const statementEqualToStatement = this.statement.isEqualTo(statement);
 
-    return statementEqualTo;
+    return statementEqualToStatement;
   }
 
-  isMetavariableEqualTo(metavariable) { return this.metavariable.isEqualTo(metavariable); }
+  isMetavariableEqualToMetavariable(metavariable) { return this.metavariable.isEqualTo(metavariable); }
 
-  isSubstitutionEqualTo(substitution) {
-    let substitutionEqualTo;
+  isSubstitutionEqualToSubstitution(substitution) {
+    let substitutionEqualToSubstitution;
 
-    if (false) {
-      ///
-    } else if ((substitution === null) && (this.substitution === null)) {
-      substitutionEqualTo = true;
-    } else if ((substitution !== null) && (this.substitution === null)) {
-      substitutionEqualTo = false;
-    } else if ((substitution === null) && (this.substitution !== null)) {
-      substitutionEqualTo = false;
+    if (this.substitution === null) {
+      substitutionEqualToSubstitution = (substitution === null);
     } else {
-      substitutionEqualTo = this.substitution.isEqualTo(substitution);
+      if (substitution === null) {
+        substitutionEqualToSubstitution = false;
+      } else {
+        substitutionEqualToSubstitution = this.substitution.isEqualTo(substitution);
+      }
     }
 
-    return substitutionEqualTo;
-  }
-
-  isSimple() {
-    const simple = (this.substitution === null);
-
-    return simple;
+    return substitutionEqualToSubstitution;
   }
 
   matchParameter(parameter) { return this.metavariable.matchParameter(parameter); }
 
-  getReplacementNode() {
-    const statementNode = this.statement.getNode(),
-          replacementNode = statementNode; ///
+  resolve(substitutions, context) {
+    const substitutionString = this.string; ///
 
-    return replacementNode;
-  }
+    context.trace(`Resolving the ${substitutionString} substitution...`);
 
-  resolve(substitutions, generalContext, specificContext) {
-    const substitutionString = this.string; ///
+    substitutions.snapshot();
 
     const metavariable = this.getMetavariable(),
           simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariable(metavariable);
 
     if (simpleSubstitution !== null) {
-      specificContext.trace(`Resolving the ${substitutionString} substitution...`);
+      let context;
 
-      const substitution = simpleSubstitution,  ///
-            substitutionResolved = substitution.resolveSubstitution(this.substitution, this.statement, substitutions, generalContext, specificContext);
+      context = this.getContext();
 
-      this.resolved = substitutionResolved; ///
+      const substitution = simpleSubstitution.unifyStatement(this.statement, context);
 
-      if (this.resolved) {
-        specificContext.debug(`...resolved the ${substitutionString} substitution.`);
-      }
-    }
-  }
-
-  resolveSubstitution(substitution, statement, substitutions, generalContext, specificContext) {
-    let substitutionResolved = false;
-
-    const substitutionString = substitution.getString();
+      if (substitution !== null) {
+        context = simpleSubstitution.getContext();
 
-    specificContext.trace(`Resolving the ${substitutionString} substitution...`);
+        const terms = context.getTerms(),
+              frames = context.getFrames();
 
-    const generalSubstitution = substitution, ///
-          specificSubstitution = this.unifyStatement(statement, specificContext, specificContext);  ///
+        context = substitution.getContext();
 
-    if (specificSubstitution !== null) {
-      substitutions.snapshot();
+        context.addTerms(terms);
 
-      const generalSubstitutionString = generalSubstitution.getString(),
-            specificSubstitutionString = specificSubstitution.getString();
+        context.addFrames(frames);
 
-      specificContext.trace(`Unifying the '${specificSubstitutionString}' substitution with the '${generalSubstitutionString}' substitution...`);
+        const substitutionUnifies = this.unifySubstitution(substitution, substitutions, context);
 
-      const substitutionUnifies = unifySubstitution(generalSubstitution, specificSubstitution, substitutions, generalContext, specificContext);
-
-
-      if (substitutionUnifies) {
-        specificContext.trace(`...unified the '${specificSubstitutionString}' substitution with the '${generalSubstitutionString}' substitution.`);
+        if (substitutionUnifies) {
+          this.resolved = true;
+        }
       }
+    }
 
-      substitutionUnifies ?
-        substitutions.continue() :
-          substitutions.rollback(specificContext);
+    this.resolved ?
+      substitutions.continue() :
+        substitutions.rollback(context);
 
-      substitutionResolved = substitutionUnifies;  ///
+    if (this.resolved) {
+      context.debug(`...resolved the ${substitutionString} substitution.`);
     }
+  }
 
-    if (substitutionResolved) {
-      specificContext.debug(`...resolved the ${substitutionString} substitution.`);
-    }
+  unifyStatement(statement, context) {
+    let substitution = null;
 
-    return substitutionResolved;
-  }
+    const { Substitutions } = ontology,
+          substitutions = Substitutions.fromNothing(),
+          specificContext = context; ///
 
-  unifyStatement(statement, generalContext, specificContext) {
-    let specificSubstitution = null;
+    context = this.getContext();
 
-    const substitutions = Substitutions.fromNothing(),
+    const generalContext = context, ///
           statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
 
     if (statementUnifies) {
@@ -149,11 +140,37 @@ export default define(class StatementSubstitution extends Substitution {
       if (substitutionsNonTrivialLength === 1) {
         const firstSubstitution = substitutions.getFirstSubstitution();
 
-        specificSubstitution = firstSubstitution; ///
+        substitution = firstSubstitution; ///
       }
     }
 
-    return specificSubstitution;
+    return substitution;
+  }
+
+  unifySubstitution(substitution, substitutions, context) {
+    const generalSubstitution = this.substitution,  ///
+          specificSubstitution = substitution,  ///
+          generalSubstitutionString = generalSubstitution.getString(),
+          specificSubstitutionString = specificSubstitution.getString();
+
+    context.trace(`Unifying the '${specificSubstitutionString}' substitution with the '${generalSubstitutionString}' substitution...`);
+
+    let substitutionContext;
+
+    substitutionContext = this.substitution.getContext();
+
+    const generalContext = substitutionContext; ///
+
+    substitutionContext = substitution.getContext();
+
+    const specificContext = substitutionContext,  ///
+          substitutionUnifies = unifySubstitution(generalSubstitution, specificSubstitution, substitutions, generalContext, specificContext);
+
+    if (substitutionUnifies) {
+      context.trace(`...unified the '${specificSubstitutionString}' substitution with the '${generalSubstitutionString}' substitution.`);
+    }
+
+    return substitutionUnifies;
   }
 
   toJSON() {
@@ -171,6 +188,8 @@ export default define(class StatementSubstitution extends Substitution {
     return json;
   }
 
+  static name = "StatementSubstitution";
+
   static fromJSON(json, context) {
     const { string } = json,
           lexer = context.getLexer(),
@@ -182,7 +201,7 @@ export default define(class StatementSubstitution extends Substitution {
           statement = statementFromJSON(json, context),
           metavariable = metavariableFromJSON(json, context),
           substitution = null,  ///
-          statementSubstitution = new StatementSubstitution(string, node, tokens, resolved, statement, metavariable, substitution);
+          statementSubstitution = new StatementSubstitution(context, string, node, tokens, resolved, statement, metavariable, substitution);
 
     return statementSubstitution;
   }
@@ -198,7 +217,7 @@ export default define(class StatementSubstitution extends Substitution {
           tokens = statementSubstitutionPartialContext.getTokens(),
           resolved = true,
           substitution = null,
-          statementSubstitution = new StatementSubstitution(string, node, tokens, resolved, statement, metavariable, substitution);
+          statementSubstitution = new StatementSubstitution(context, string, node, tokens, resolved, statement, metavariable, substitution);
 
     return statementSubstitution;
   }
@@ -213,7 +232,7 @@ export default define(class StatementSubstitution extends Substitution {
           node = statementSubstitutionPartialContext.getNode(),
           tokens = statementSubstitutionPartialContext.getTokens(),
           resolved = false,
-          statementSubstitution = new StatementSubstitution(string, node, tokens, resolved, statement, metavariable, substitution);
+          statementSubstitution = new StatementSubstitution(context, string, node, tokens, resolved, statement, metavariable, substitution);
 
     return statementSubstitution;
   }

package/src/ontology/substitution/term.js

@@ -6,11 +6,12 @@ import TermSubstitutionPartialContext from "../../context/partial/substitution/t
 
 import { define } from "../../ontology";
 import { stripBracketsFromTerm } from "../../utilities/brackets";
-import { stripBracketsFromTermNode } from "../../utilities/brackets";
+import { termVariableIdentifierFromTermNode } from "../../utilities/variable";
+
 
 export default define(class TermSubstitution extends Substitution {
-  constructor(string, node, tokens, term, variable) {
-    super(string, node, tokens);
+  constructor(context, string, node, tokens, term, variable) {
+    super(context, string, node, tokens);
 
     this.term = term;
     this.variable = variable;
@@ -24,6 +25,13 @@ export default define(class TermSubstitution extends Substitution {
     return this.variable;
   }
 
+  getReplacementNode() {
+    const termNode = this.term.getNode(),
+          replacementNode = termNode; ///
+
+    return replacementNode;
+  }
+
   isTrivial() {
     const termString = this.term.getString(),
           variableString = this.variable.getString(),
@@ -32,68 +40,100 @@ export default define(class TermSubstitution extends Substitution {
     return trivial;
   }
 
-  isTermEqualTo(term, context) {
+  isTermEqualToTerm(term, context) {
     term = stripBracketsFromTerm(term, context); ///
 
-    const termEqualTo = this.term.isEqualTo(term);
+    const termEqualToTerm = this.term.isEqualTo(term);
 
-    return termEqualTo;
+    return termEqualToTerm;
   }
 
-  isVariableEqualTo(variable) { return this.variable.isEqualTo(variable); }
-
   matchParameter(parameter) { return this.variable.matchParameter(parameter); }
 
-  getReplacementNode() {
-    const termNode = this.term.getNode(),
-          replacementNode = termNode; ///
+  verify(context) {
+    let verifies = false;
 
-    return replacementNode;
+    const termSubstitutionString = this.string;  ///
+
+    context.trace(`Verifiying the '${termSubstitutionString}' term substitutin...`);
+
+    const termSimple = this.term.isSimple();
+
+    if (termSimple) {
+      if (this.variable === null) {
+        context.debug(`The specific term is not simple.`);
+      } else {
+        const variableIdentifier = this.variable.getIdentifier(),
+              variablePresent = context.isVariablePresentByVariableIdentifier(variableIdentifier);
+
+        if (variablePresent) {
+          const termNode = this.term.getNode(),
+                termVariableIdentifier = termVariableIdentifierFromTermNode(termNode),
+                termVariablePresent = context.isVariablePresentByVariableIdentifier(termVariableIdentifier);
+
+          if (termVariablePresent) {
+            verifies = true;
+          } else {
+            const variableString = variable.getString();
+
+            context.debug(`The '${variableString}' variable is not present.`);
+          }
+        } else {
+          const variableString = this.variable.getString();
+
+          context.debug(`The '${variableString}' variable is not present.`);
+        }
+      }
+    } else {
+      context.debug(`The general term is not simple.`);
+    }
+
+    if (verifies) {
+      const substititoin = this;  ///
+
+      context.addSubstitution(substititoin);
+
+      context.debug(`...verified the '${termSubstitutionString}' term substitutin.`);
+    }
+
+    return verifies;
   }
 
-  static fromStatementNode(statementNode, context) {
+  static name = "TermSubstitution";
+
+  static fromStatement(statement, context) {
     let termSubstitution = null;
 
-    const termSubstitutionNode = statementNode.getTermSubstitutionNode();
+    const statementNode = statement.getNode(),
+          termSubstitutionNode = statementNode.getTermSubstitutionNode();
 
     if (termSubstitutionNode !== null) {
-      const lastTermNode = termSubstitutionNode.getLastTermNode(),
+      const { Term, Variable } = ontology,
             firstTermNode = termSubstitutionNode.getFirstTermNode(),
-            singularVariableNode = lastTermNode.getSingularVariableNode(lastTermNode);
-
-      if (singularVariableNode !== null) {
-        const { Term, Variable } = ontology,
-              termNode = firstTermNode, ///
-              variableNode = singularVariableNode,  ///
-              term = Term.fromTermNode(termNode, context),
-              variable = Variable.fromVariableNode(variableNode, context),
-              node = termSubstitutionNode,  ///
-              tokens = context.nodeAsTokens(node),
-              string = stringFromTermAndVariable(term, variable);
-
-        termSubstitution = new TermSubstitution(string, node, tokens, term, variable);
-      }
+            lastVariableNode = termSubstitutionNode.getLastVariableNode(),
+            termNode = firstTermNode, ///
+            variableNode = lastVariableNode,  ///
+            term = Term.fromTermNode(termNode, context),
+            variable = Variable.fromVariableNode(variableNode, context),
+            node = termSubstitutionNode,  ///
+            tokens = context.nodeAsTokens(node),
+            string = stringFromTermAndVariable(term, variable);
+
+      termSubstitution = new TermSubstitution(context, string, node, tokens, term, variable);
     }
 
     return termSubstitution;
   }
 
   static fromTernAndVariable(term, variable, context) {
-    let termNode = term.getNode();
-
-    termNode = stripBracketsFromTermNode(termNode); ///
-
-    const { Term } = ontology;
-
-    term = Term.fromTermNode(termNode, context);
-
-    const string = stringFromTermAndVariable(term, variable),
-          lexer = context.getLexer(),
+    const lexer = context.getLexer(),
           parser = context.getParser(),
+          string = stringFromTermAndVariable(term, variable),
           termSubstitutionPartialContext = TermSubstitutionPartialContext.fromStringLexerAndParser(string, lexer, parser),
           node = termSubstitutionPartialContext.getNode(),
-          tokens = termSubstitutionPartialContext.getTokens(),
-          termSubstitution = new TermSubstitution(string, node, tokens, term, variable);
+          tokens = termSubstitutionPartialContext.getTokens();
+
+    const termSubstitution = new TermSubstitution(context, string, node, tokens, term, variable);
 
     return termSubstitution;
   }

package/src/ontology/substitution.js

@@ -1,12 +1,17 @@
 "use strict";
 
 export default class Substitution {
-  constructor(string, node, tokens) {
+  constructor(context, string, node, tokens) {
+    this.context = context;
     this.string = string;
     this.node = node;
     this.tokens = tokens;
   }
 
+  getContext() {
+    return this.context;
+  }
+
   getString() {
     return this.string;
   }
@@ -61,6 +66,12 @@ export default class Substitution {
     return substitution;
   }
 
+  getReplacementNode() {
+    const replacementNode = null;
+
+    return replacementNode;
+  }
+
   isSimple() {
     const simple = true;
 
@@ -87,52 +98,40 @@ export default class Substitution {
     return equalTo;
   }
 
-  isTermEqualTo(term) {
-    const termEqualTo = false;
-
-    return termEqualTo;
-  }
-
-  isFrameEqualTo(frame) {
-    const frameEqualTo = false;
-
-    return frameEqualTo;
-  }
-
-  isVariableEqualTo(variable) {
-    const variableEqualTo = false;
+  isTermEqualToTerm(term, context) {
+    const termEqualToTerm = false;
 
-    return variableEqualTo;
+    return termEqualToTerm;
   }
 
-  isReferenceEqualTo(reference) {
-    const referenceEqualTo = false;
+  isFrameEqualToFrame(frame) {
+    const frameEqualToFrame = false;
 
-    return referenceEqualTo;
+    return frameEqualToFrame;
   }
 
-  isStatementEqualTo(statement) {
-    const statementEqualTo = false;
+  isReferenceEqualToReference(reference, context) {
+    const referenceEqualToReference = false;
 
-    return statementEqualTo;
+    return referenceEqualToReference;
   }
 
-  isMetavariableEqualTo(metavariable) {
-    const metavariableEqualTo = false;
+  isStatementEqualToStatement(statement, context) {
+    const statementEqualToStatement = false;
 
-    return metavariableEqualTo;
+    return statementEqualToStatement;
   }
 
-  isSubstitutionEqualTo(substitution) {
-    const substitutionEqualTo = (substitution === null);
+  isMetavariableEqualToMetavariable(metavariable) {
+    const metavariableEqualToMetavariable = false;
 
-    return substitutionEqualTo;
+    return metavariableEqualToMetavariable;
   }
 
-  resolve(substitutions, context) {
-    const resolved = true;
+  isSubstitutionEqualToSubstitution(substitution) {
+    const substitutionEqualToSubstitution = (substitution === null);
 
-    return resolved;
+    return substitutionEqualToSubstitution;
   }
 
   matchParameter(parameter) {
@@ -141,9 +140,11 @@ export default class Substitution {
     return parameterMatches;
   }
 
-  getReplacementNode() {
-    const replacementNode = null;
+  matchSubstitutionNode(substitutionNode) { return this.node.match(substitutionNode); }
 
-    return replacementNode;
+  resolve(substitutions, context) {
+    const resolved = true;
+
+    return resolved;
   }
 }