occam-verify-cli 1.0.404 → 1.0.414

package/src/ontology/substitution/statement.js

@@ -5,7 +5,7 @@ import Substitution from "../substitution";
 import StatementSubstitutionPartialContext from "../../context/partial/substitution/statement";
 
 import { define } from "../../ontology";
-import { unifySubstitution } from "../../utilities/unification";
+import { unifySubstitution } from "../../process/unify";
 import { stripBracketsFromStatement } from "../../utilities/brackets";
 import { statementFromJSON, statementToStatementJSON, metavariableFromJSON, metavariableToMetavariableJSON } from "../../utilities/json";
 
@@ -76,52 +76,6 @@ export default define(class StatementSubstitution extends Substitution {
 
   matchParameter(parameter) { return this.metavariable.matchParameter(parameter); }
 
-  resolve(substitutions, context) {
-    const substitutionString = this.string; ///
-
-    context.trace(`Resolving the ${substitutionString} substitution...`);
-
-    substitutions.snapshot();
-
-    const metavariable = this.getMetavariable(),
-          simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariable(metavariable);
-
-    if (simpleSubstitution !== null) {
-      let context;
-
-      context = this.getContext();
-
-      const substitution = simpleSubstitution.unifyStatement(this.statement, context);
-
-      if (substitution !== null) {
-        context = simpleSubstitution.getContext();
-
-        const terms = context.getTerms(),
-              frames = context.getFrames();
-
-        context = substitution.getContext();
-
-        context.addTerms(terms);
-
-        context.addFrames(frames);
-
-        const substitutionUnifies = this.unifySubstitution(substitution, substitutions, context);
-
-        if (substitutionUnifies) {
-          this.resolved = true;
-        }
-      }
-    }
-
-    this.resolved ?
-      substitutions.continue() :
-        substitutions.rollback(context);
-
-    if (this.resolved) {
-      context.debug(`...resolved the ${substitutionString} substitution.`);
-    }
-  }
-
   unifyStatement(statement, context) {
     let substitution = null;
 
@@ -173,12 +127,55 @@ export default define(class StatementSubstitution extends Substitution {
     return substitutionUnifies;
   }
 
+  resolve(substitutions, context) {
+    const substitutionString = this.string; ///
+
+    context.trace(`Resolving the ${substitutionString} substitution...`);
+
+    substitutions.snapshot();
+
+    const metavariable = this.getMetavariable(),
+          simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariable(metavariable);
+
+    if (simpleSubstitution !== null) {
+      let 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;
+        }
+      }
+    }
+
+    this.resolved ?
+      substitutions.continue() :
+        substitutions.rollback(context);
+
+    if (this.resolved) {
+      context.debug(`...resolved the '${substitutionString}' substitution.`);
+    }
+  }
+
   toJSON() {
     const metavariableJSON = metavariableToMetavariableJSON(this.metavariable),
           statementJSON = statementToStatementJSON(this.statement),
           metavariable = metavariableJSON,  ///
           statement = statementJSON,  ///
-          string = this.string,
+          string = this.string, ///
           json = {
             string,
             statement,

package/src/ontology/substitution/term.js

@@ -6,7 +6,6 @@ import TermSubstitutionPartialContext from "../../context/partial/substitution/t
 
 import { define } from "../../ontology";
 import { stripBracketsFromTerm } from "../../utilities/brackets";
-import { termVariableIdentifierFromTermNode } from "../../utilities/variable";
 
 
 export default define(class TermSubstitution extends Substitution {
@@ -33,9 +32,13 @@ export default define(class TermSubstitution extends Substitution {
   }
 
   isTrivial() {
-    const termString = this.term.getString(),
-          variableString = this.variable.getString(),
-          trivial = (termString === variableString);
+    let trivial = false;
+
+    const termEqualToVariable = this.term.isEqualToVariable(this.variable);
+
+    if (termEqualToVariable) {
+      trivial = true;
+    }
 
     return trivial;
   }
@@ -55,37 +58,34 @@ export default define(class TermSubstitution extends Substitution {
 
     const termSubstitutionString = this.string;  ///
 
-    context.trace(`Verifiying the '${termSubstitutionString}' term substitutin...`);
+    context.trace(`Verifiying the '${termSubstitutionString}' term substitution...`);
 
-    const termSimple = this.term.isSimple();
+    const termSingular = this.term.isSingular();
 
-    if (termSimple) {
-      if (this.variable === null) {
-        context.debug(`The specific term is not simple.`);
-      } else {
+    if (termSingular) {
+      if (this.variable !== null) {
         const variableIdentifier = this.variable.getIdentifier(),
               variablePresent = context.isVariablePresentByVariableIdentifier(variableIdentifier);
 
         if (variablePresent) {
           const termNode = this.term.getNode(),
-                termVariableIdentifier = termVariableIdentifierFromTermNode(termNode),
+                variableIdentifier = termNode.getVariableIdentifier(),
+                termVariableIdentifier = variableIdentifier,  ///
                 termVariablePresent = context.isVariablePresentByVariableIdentifier(termVariableIdentifier);
 
           if (termVariablePresent) {
             verifies = true;
           } else {
-            const variableString = variable.getString();
-
-            context.debug(`The '${variableString}' variable is not present.`);
+            context.debug(`The '${termSubstitutionString}' term substitution's general term's variable is not present.`);
           }
         } else {
-          const variableString = this.variable.getString();
-
-          context.debug(`The '${variableString}' variable is not present.`);
+          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.`);
       }
     } else {
-      context.debug(`The general term is not simple.`);
+      context.debug(`The '${termSubstitutionString}' term substitution's specific term is not singular.`);
     }
 
     if (verifies) {
@@ -93,7 +93,7 @@ export default define(class TermSubstitution extends Substitution {
 
       context.addSubstitution(substititoin);
 
-      context.debug(`...verified the '${termSubstitutionString}' term substitutin.`);
+      context.debug(`...verified the '${termSubstitutionString}' term substitution.`);
     }
 
     return verifies;

package/src/ontology/substitution.js

@@ -92,8 +92,9 @@ export default class Substitution {
   }
 
   isEqualTo(substitution) {
-    const substitutionString = substitution.getString(),
-          equalTo = (substitutionString === this.string);
+    const substitutionNode = substitution.getNode(),
+          matches = this.node.match(substitutionNode),
+          equalTo = matches;  ///
 
     return equalTo;
   }

package/src/ontology/substitutions.js

@@ -37,7 +37,7 @@ export default define(class Substitutions {
     compress(metavariables, (metavariableA, metavariableB) => {
       const metavariableAEqualToMetavariableB = metavariableB.isEqualTo(metavariableA);
 
-      if (metavariableAEqualToMetavariableB) {
+      if (!metavariableAEqualToMetavariableB) {
         return true;
       }
     });
@@ -198,7 +198,7 @@ export default define(class Substitutions {
 
     const substitutionString = substitution.getString();
 
-    context.trace(`Added the ${substitutionString} substitution.`);
+    context.trace(`Added the '${substitutionString}' substitution.`);
   }
 
   removeSubstitution(substitution, context) {
@@ -214,7 +214,7 @@ export default define(class Substitutions {
 
     const substitutionString = substitution.getString();
 
-    context.trace(`Removed the ${substitutionString} substitution.`);
+    context.trace(`Removed the '${substitutionString}' substitution.`);
   }
 
   correlateSubstitutions(substitutions) {

package/src/ontology/term.js

@@ -35,15 +35,36 @@ export default define(class Term {
     this.type = type;
   }
 
+  isSingular() { return this.node.isSingular(); }
+
+  isProvisional() { return this.type.isProvisional(); }
+
   matchTermNode(termNode) { return this.node.match(termNode); }
 
-  isSimple() { return this.node.isSimple();}
+  isEqualToVariable(variable) {
+    let variableNodeMathces = false;
 
-  isProvisional() { return this.type.isProvisional(); }
+    const singular = this.isSingular();
+
+    if (singular) {
+      const variableNode = variable.getNode(),
+            singularVariableNode = this.node.getSingularVariableNode(),
+            variableNodeA = variableNode, ///
+            variableNodeB = singularVariableNode, ///
+            matches = variableNodeA.match(variableNodeB);
+
+      if (matches) {
+        variableNodeMathces = true;
+      }
+    }
+
+    return variableNodeMathces;
+  }
 
   isEqualTo(term) {
-    const termString = term.getString(),
-          equalTo = (termString === this.string);
+    const termNode = term.getNode(),
+          matches = this.node.match(termNode),
+          equalTo = matches;  ///
 
     return equalTo;
   }
@@ -254,7 +275,7 @@ export function variablesFromTerm(term, context) {
   compress(variables, (variableA, variableB) => {
     const variableAEqualToVariableB = variableA.isEqualTo(variableB);
 
-    if (variableAEqualToVariableB) {
+    if (!variableAEqualToVariableB) {
       return true;
     }
   });

package/src/ontology/variable.js

@@ -42,8 +42,9 @@ export default define(class Variable {
   }
 
   isEqualTo(variable) {
-    const variableString = variable.getString(),
-          equalTo = (variableString === this.string);
+    const variableNode = variable.getNode(),
+          matches = this.node.match(variableNode),
+          equalTo = matches;  ///
 
     return equalTo;
   }

package/src/process/equate.js

@@ -0,0 +1,212 @@
+"use strict";
+
+import { nodeQuery } from "../utilities/query";
+import { terminalNodeMapFromNodes, areTerminalNodeMapsEqual } from "../utilities/pass";
+
+const termNodeQuery = nodeQuery("/term"),
+      nonTerminalNodeQuery = nodeQuery("/*");
+
+class Pass {
+  run(leftNode, rightNode, ...remainingArguments) {
+    let success;
+
+    const visited = this.visitNode(leftNode, rightNode, ...remainingArguments);
+
+    success = visited;  ///
+
+    return success;
+  }
+
+  descend(leftChildNodes, rightChildNodes, ...remainingArguments) {
+    let descended = false;
+
+    const leftChildNodesLength = leftChildNodes.length,
+          rightChildNodesLength = rightChildNodes.length;
+
+    if (leftChildNodesLength === rightChildNodesLength) {
+      const leftTerminalNodeMap = terminalNodeMapFromNodes(leftChildNodes),
+            rightTerminalNodeMap = terminalNodeMapFromNodes(rightChildNodes),
+            terminalNodeMapsEqual = areTerminalNodeMapsEqual(leftTerminalNodeMap, rightTerminalNodeMap);
+
+      if (terminalNodeMapsEqual) {
+        descended = leftChildNodes.every((leftChildNode, index) => {
+          const rightChildNode = rightChildNodes[index],
+                leftNode = leftChildNode, ///
+                rightNode = rightChildNode, ///
+                visited = this.visitNode(leftNode, rightNode, ...remainingArguments);
+
+          if (visited) {
+            return true;
+          }
+        });
+      }
+    }
+
+    return descended;
+  }
+
+  visitNode(leftNode, rightNode, ...remainingArguments) {
+    let visited = false;
+
+    const leftNodeTerminalNode = leftNode.isTerminalNode(),
+          rightNodeTerminalNode = rightNode.isTerminalNode(),
+          leftNodeNonTerminalNode = leftNode.isNonTerminalNode(),
+          rightNodeNonTerminalNode = rightNode.isNonTerminalNode();
+
+    if (false) {
+      ///
+    } else if (leftNodeTerminalNode && rightNodeTerminalNode) {
+      const leftTerminalNode = leftNode,  ///
+            rightTerminalNode = rightNode;  ///
+
+      visited = this.visitTerminalNode(leftTerminalNode, rightTerminalNode, ...remainingArguments);
+    } else if (leftNodeNonTerminalNode && rightNodeNonTerminalNode) {
+      const leftNonTerminalNode = leftNode,  ///
+            rightNonTerminalNode = rightNode; ///
+
+      visited = this.visitNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, ...remainingArguments);
+    }
+
+    return visited;
+  }
+
+  visitTerminalNode(leftTerminalNode, rightTerminalNode, ...remainingArguments) { ///
+    let visited;
+
+    visited = true;
+
+    return visited;
+  }
+
+  visitNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, ...remainingArguments) {
+    let visited = false;
+
+    let { maps } = this.constructor;
+
+    maps = [ ///
+      ...maps,
+      {
+        leftNodeQuery: nonTerminalNodeQuery,
+        rightNodeQuery: nonTerminalNodeQuery,
+        run: (leftNode, rightNode, ...remainingArguments) => {
+          let visited = false;
+
+          const leftNonTerminalNodeRuleName = leftNonTerminalNode.getRuleName(), ///
+                rightNonTerminalNodeRuleName = rightNonTerminalNode.getRuleName(); ///
+
+          if (leftNonTerminalNodeRuleName === rightNonTerminalNodeRuleName) {
+            const leftNonTerminalNodeChildNodes = leftNonTerminalNode.getChildNodes(),
+                  rightNonTerminalNodeChildNodes = rightNonTerminalNode.getChildNodes(),
+                  leftChildNodes = leftNonTerminalNodeChildNodes, ///
+                  rightChildNodes = rightNonTerminalNodeChildNodes, ///
+                  descended = this.descend(leftChildNodes, rightChildNodes, ...remainingArguments);
+
+            if (descended) {
+              visited = true;
+            }
+          }
+
+          return visited;
+        }
+      }
+    ]
+
+    maps.some((map) => {
+      const { leftNodeQuery, rightNodeQuery, run } = map;
+
+      const leftNode = leftNodeQuery(leftNonTerminalNode),  ///
+            rightNode = rightNodeQuery(rightNonTerminalNode);  ///
+
+      if ((leftNode !== null) && (rightNode !== null)) {
+        const success = run(leftNode, rightNode, ...remainingArguments);
+
+        visited = success;  ///
+
+        return true;
+      }
+    });
+
+    return visited;
+  }
+}
+
+class EquationalPass extends Pass {
+  static maps = [
+    {
+      leftNodeQuery: termNodeQuery,  ///
+      rightNodeQuery: termNodeQuery, ///
+      run: (leftTermNode, rightTermNode, context) => {
+        let success = false;
+
+        if (!success) {
+          const depth = Infinity,
+                leftTermNodeMatchesRightTermNode = leftTermNode.match(rightTermNode, depth);
+
+          if (leftTermNodeMatchesRightTermNode) {
+            success = true;
+          }
+        }
+
+        if (!success) {
+          const equivalences = context.getEquivalences(),
+                termNodes = [
+                  leftTermNode,
+                  rightTermNode
+                ],
+                equivalence = equivalences.findEquivalenceByTermNodes(termNodes);
+
+          if (equivalence !== null) {
+            success = true;
+          }
+        }
+
+        if (!success) {
+          const depth = 1,
+                leftTermNodeMatchesRightTermNode = leftTermNode.match(rightTermNode, depth);
+
+          if (leftTermNodeMatchesRightTermNode) {
+            const leftNonTerminalNode = leftTermNode, ///
+                  rightNonTerminalNode = rightTermNode, ///
+                  leftNonTerminalNodeChildNodes = leftNonTerminalNode.getChildNodes(),
+                  rightNonTerminalNodeChildNodes = rightNonTerminalNode.getChildNodes(),
+                  leftChildNodes = leftNonTerminalNodeChildNodes, ///
+                  rightChildNodes = rightNonTerminalNodeChildNodes, ///
+                  descended = equationalPass.descend(leftChildNodes, rightChildNodes, context);
+
+            if (descended) {
+              success = true;
+            }
+          }
+        }
+
+        return success;
+      }
+    }
+  ];
+}
+
+const equationalPass = new EquationalPass();
+
+export function equateTerms(leftTermNode, rightTermNode, context) {
+  let termsEquate;
+
+  const leftNode = leftTermNode, ///
+        rightNode = rightTermNode, ///
+        success = equationalPass.run(leftNode, rightNode, context);
+
+  termsEquate = success; ///
+
+  return termsEquate;
+}
+
+export function equateStatements(leftStatementNode, rightStatementNode, context) {
+  let statementsEquate;
+
+  const leftNode = leftStatementNode, ///
+        rightNode = rightStatementNode, ///
+        success = equationalPass.run(leftNode, rightNode, context);
+
+  statementsEquate = success; ///
+
+  return statementsEquate;
+}