occam-verify-cli 0.0.1066 → 0.0.1068

package/src/substitution/statementForMetavariable.js

@@ -2,36 +2,49 @@
 
 import shim from "../shim";
 import Substitution from "../substitution";
-import TermForVariableSubstitution from "../substitution/termForVariable";
-import FrameForMetavariableSubstitution from "../substitution/frameForMetavariable";
+import LocalContext from "../context/local";
+import Substitutions from "../substitutions";
+import metaLevelUnifier from "../unifier/metaLevel";
 
 import { stripBracketsFromStatement } from "../utilities/brackets";
 
 export default class StatementForMetavariableSubstitution extends Substitution {
-  constructor(string, statementNode, metavariableNode, substitution) {
+  constructor(string, statement, metavariable, substitution) {
     super(string);
 
-    this.statementNode = statementNode;
-    this.metavariableNode = metavariableNode;
+    this.statement = statement;
+    this.metavariable = metavariable;
     this.substitution = substitution;
   }
 
-  getStatementNode() {
-    return this.statementNode;
+  getStatement() {
+    return this.statement;
   }
 
-  getMetavariableNode() {
-    return this.metavariableNode;
+  getMetavariable() {
+    return this.metavariable;
   }
 
   getSubstitution() {
     return this.substitution;
   }
 
-  getNode() {
-    const node = this.statementNode;  ///
+  getStatementNode() {
+    const statementNode = this.statement.getNode();
 
-    return node;
+    return statementNode;
+  }
+
+  getMetavariableNode() {
+    const metavariableNode = this.metavariable.getNode();
+
+    return metavariableNode;
+  }
+
+  getMetavariableName() {
+    const metavariableName = this.metavariable.getName();
+
+    return metavariableName;
   }
 
   isSimple() {
@@ -40,89 +53,148 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return simple;
   }
 
-  matchStatementNode(statementNode) {
-    statementNode = stripBracketsFromStatement(statementNode); ///
+  resolve(substitutions, localContextA, localContextB) {
+    let resolved = false;
 
-    const statementNodeMatches = this.statementNode.match(statementNode);
+    const substitutionString = this.string;
 
-    return statementNodeMatches;
-  }
+    localContextB.trace(`Resolving the ${substitutionString} substitution...`);
+
+    const metavariableName = this.getMetavariableName(),
+          simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariableName(metavariableName);
 
-  matchMetavariableNode(metavariableNode) {
-    const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
+    if (simpleSubstitution !== null) {
+      const substitution = simpleSubstitution,  ///
+            substitutionResolved = substitution.resolveSubstitution(this.substitution, this.statement, substitutions, localContextA, localContextB);
+
+      resolved = substitutionResolved; ///
+    }
 
-    return metavariableNodeMatches;
+    if (resolved) {
+      localContextB.debug(`...resolved the ${substitutionString} substitution.`);
+    }
+
+    return resolved;
   }
 
-  static fromStatementAndMetavariable(statement, metavariable, localContext) {
-    let statementNode = statement.getNode();
+  resolveSubstitution(substitution, statement, substitutions, localContextA, localContextB) {
+    let substitutionResolved = false;
 
-    statementNode = stripBracketsFromStatement(statementNode); ///
+    const substitutionString = substitution.getString();
 
-    const { Statement } = shim;
+    localContextB.trace(`Resolving the ${substitutionString} substitution...`);
 
-    statement = Statement.fromStatementNode(statementNode, localContext); ///
+    const substitutionA = substitution; ///
 
-    const string = stringFromStatementAndMetavariable(statement, metavariable),
-          substitution = null,
-          metavariableNode = metavariable.getNode(),
-          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, statementNode, metavariableNode, substitution);
+    substitution = this.unifyStatement(statement, localContextA, localContextB);
 
-    return statementForMetavariableSubstitution;
+    if (substitution !== null) {
+      substitutions.snapshot();
+
+      const substitutionTokens = substitution.getSubstitutionTokens(),
+            tokens = substitutionTokens;  ///
+
+      localContextB = LocalContext.fromLocalContextAndTokens(localContextB, tokens);  ///
+
+      const substitutionB = substitution, ///
+            nodeA = substitutionA.getSubstitutionNode(),  ///
+            nodeB = substitutionB.getSubstitutionNode(),  ///
+            unifiedAtMetaLevel = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+
+      unifiedAtMetaLevel ?
+        substitutions.continue() :
+          substitutions.rollback(localContextB);
+
+      substitutionResolved = unifiedAtMetaLevel;  ///
+    }
+
+    if (substitutionResolved) {
+      localContextB.debug(`...resolved the ${substitutionString} substitution.`);
+    }
+
+    return substitutionResolved;
   }
 
-  static fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext) {
-    let statementNode = statement.getNode();
+  unifyStatement(statement, localContextA, localContextB) {
+    let substitution = null;
 
-    statementNode = stripBracketsFromStatement(statementNode); ///
+    localContextA = localContextB;  ///
 
-    const { Statement } = shim;
+    const substitutions = Substitutions.fromNothing(),
+          statementUnified = this.statement.unifyStatement(statement, substitutions, localContextA, localContextB);
 
-    statement = Statement.fromStatementNode(statementNode, localContext); ///
+    if (statementUnified) {
+      const substitutionsLength = substitutions.getLength();
 
-    const metavariableNode = metavariable.getNode(),
-          string = stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution);
+      if (substitutionsLength === 1) {
+        const firstSubstitution = substitutions.getFirstSubstitution();
 
-    substitution = substitutionFromSubstitution(substitution, localContext);
+        substitution = firstSubstitution; ///
 
-    const statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, statementNode, metavariableNode, substitution);
+        substitution.setSubstitutionTokens();
 
-    return statementForMetavariableSubstitution;
+        substitution.setSubstitutionNode();
+      }
+    }
+
+    return substitution;
   }
-}
 
-function substitutionFromSubstitution(substitution, localContext) {
-  if (substitution === null) {
-    const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitution(substitution, localContext);
+  matchStatementNode(statementNode) {
+    statementNode = stripBracketsFromStatement(statementNode); ///
 
-    if (termForVariableSubstitution !== null) {
-      substitution = termForVariableSubstitution; ///
-    }
+    const statementNodeMatches = this.statement.matchStatementNode(statementNode);
+
+    return statementNodeMatches;
   }
 
-  if (substitution === null) {
-    const frameForMetavariableSubstitution = FrameForMetavariableSubstitution.fromSubstitution(substitution, localContext);
+  matchMetavariableName(metavariableName) { return this.metavariable.matchMetavariableName(metavariableName); }
+
+  matchSubstitutionNode(substitutionNode) {
+    let substitutionNodeMatches;
 
-    if (frameForMetavariableSubstitution !== null) {
-      substitution = frameForMetavariableSubstitution;  ///
+    if ((substitutionNode === null) && (this.substitution === null)) {
+      substitutionNodeMatches = true;
+    } else if ((substitutionNode === null) && (this.substitution !== null)) {
+      substitutionNodeMatches = false;
+    } else if ((substitutionNode !== null) && (this.substitution === null)) {
+      substitutionNodeMatches = false;
+    } else {
+      substitutionNodeMatches = this.substitution.matchSubstitutionNode(substitutionNode);
     }
+
+    return substitutionNodeMatches;
   }
 
-  return substitution;
-}
+  matchMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode) {
+    const metavariableNameMatches = this.matchMetavariableName(metavariableName),
+          substitutionNodeMatches = this.matchSubstitutionNode(substitutionNode),
+          metavariableNameAndSubstitutionNodeMatches = (metavariableNameMatches && substitutionNodeMatches);
 
-function stringFromStatementAndMetavariable(statement, metavariable) {
-  const statementString = statement.getString(),
-        metavariableString = metavariable.getString(),
-        string = `[${statementString} for ${metavariableString}]`;
+    return metavariableNameAndSubstitutionNodeMatches;
+  }
 
-  return string;
+  static fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext) {
+    let statementNode = statement.getNode();
+
+    statementNode = stripBracketsFromStatement(statementNode); ///
+
+    const { Statement } = shim;
+
+    statement = Statement.fromStatementNode(statementNode, localContext);
+
+    const string = stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext),
+          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, statement, metavariable, substitution);
+
+    return statementForMetavariableSubstitution;
+  }
 }
 
-function stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution) {
+function stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext) {
   let string;
 
-  const statementString = statement.getString(),
+  const statementNode = statement.getNode(),
+        statementString = localContext.nodeAsString(statementNode),
         metavariableString = metavariable.getString();
 
   if (substitution === null) {
@@ -134,4 +206,4 @@ function stringFromStatementMetavariableAndSubstitution(statement, metavariable,
   }
 
   return string;
-}
+}

package/src/substitution/termForVariable.js

@@ -5,18 +5,23 @@ import Substitution from "../substitution";
 
 import { nodeQuery } from "../utilities/query";
 import { stripBracketsFromTerm } from "../utilities/brackets";
+import { variableNameFromVariableNode } from "../utilities/name";
+import { substitutionNodeFromSubstitutionTokens } from "../utilities/node";
+import { substitutionTokensFromSubstitutionString } from "../utilities/tokens";
 
-const substitutionNodeQuery = nodeQuery("/statement/substitution"),
-      termVariableNodeQuery = nodeQuery("/term/variable!"),
-      substitutionTermNodeQuery = nodeQuery("/substitution/term!"),
-      substitutionsVariableNodeQuery = nodeQuery("/substitution/variable!");
+const termNodeQuery = nodeQuery("/substitution/term[0]"),
+      variableNodeQuery = nodeQuery("/substitution/term[1]/variable!"),
+      termVariableNodeQuery = nodeQuery("/term/variable"),
+      substitutionNodeQuery = nodeQuery("/statement/substitution");
 
 export default class TermForVariableSubstitution extends Substitution {
-  constructor(string, termNode, variableNode) {
+  constructor(string, termNode, variableNode, substitutionNode, substitutionTokens) {
     super(string);
 
     this.termNode = termNode;
     this.variableNode = variableNode;
+    this.substitutionNode = substitutionNode;
+    this.substitutionTokens = substitutionTokens;
   }
 
   getTermNode() {
@@ -27,29 +32,45 @@ export default class TermForVariableSubstitution extends Substitution {
     return this.variableNode;
   }
 
-  transformed(substitutions) {
-    let transformedSubstitution = null;
+  getSubstitutionNode() {
+    return this.substitutionNode;
+  }
 
-    const transformedTermNode = transformTermNode(this.termNode, substitutions),
-          transformedVariableNode = transformVariableNode(this.variableNode, substitutions);
+  getSubstitutionTokens() {
+    return this.substitutionTokens;
+  }
 
-    if ((transformedTermNode !== null) && (transformedVariableNode !== null)) {
-      const termNode = transformedTermNode, ///
-            variableNode = transformedVariableNode, ///
-            termForVariableSubstitution = new TermForVariableSubstitution(termNode, variableNode);
+  getVariableName() {
+    const variableName = variableNameFromVariableNode(this.variableNode);
 
-      transformedSubstitution = termForVariableSubstitution;  ///
-    }
+    return variableName;
+  }
+
+  setSubstitutionNode() {
+    this.substitutionNode = substitutionNodeFromSubstitutionTokens(this.substitutionTokens);
+  }
+
+  setSubstitutionTokens() {
+    const termVariableNode = termVariableNodeQuery(this.termNode),
+          termVariableName = variableNameFromVariableNode(termVariableNode),
+          variableName = variableNameFromVariableNode(this.variableNode),
+          substitutionString = `[${termVariableName} for ${variableName}]`;
 
-    return transformedSubstitution;
+    this.substitutionTokens = substitutionTokensFromSubstitutionString(substitutionString);
   }
 
   isEqualTo(substitution) {
+    let equalTo = false;
+
     const termNode = substitution.getTermNode(),
-          variableNode = substitution.getVariableNode(),
-          termNodeMatches = this.matchTermNode(termNode),
-          variableNodeMatches = this.matchVariableNode(variableNode),
-          equalTo = (termNodeMatches && variableNodeMatches);
+          variableNode = substitution.getVariableNode();
+
+    if ((termNode !== null) && (variableNode !== null)) {
+      const termNodeMatches = this.matchTermNode(termNode),
+            variableNodeMatches = this.matchVariableNode(variableNode);
+
+      equalTo = (termNodeMatches && variableNodeMatches);
+    }
 
     return equalTo;
   }
@@ -62,10 +83,34 @@ export default class TermForVariableSubstitution extends Substitution {
     return termNodeMatches;
   }
 
-  matchVariableNode(variableNode) {
-    const variableNodeMatches = this.variableNode.match(variableNode);
+  matchVariableName(variableName) {
+    let variableNameMatches;
+
+    const variableNameA = variableName; ///
+
+    variableName = variableNameFromVariableNode(this.variableNode);
+
+    const variableNameB = variableName; ///
+
+    variableNameMatches = (variableNameA === variableNameB);
+
+    return variableNameMatches;
+  }
+
+  matchSubstitutionNode(substitutionNode) {
+    let substitutionNodeMatches;
+
+    if ((substitutionNode === null) && (this.substitutionNode === null)) {
+      substitutionNodeMatches = true;
+    } else if ((substitutionNode === null) && (this.substitutionNode !== null)) {
+      substitutionNodeMatches = false;
+    } else if ((substitutionNode !== null) && (this.substitutionNode === null)) {
+      substitutionNodeMatches = false;
+    } else {
+      substitutionNodeMatches = this.substitutionNode.match(substitutionNode);
+    }
 
-    return variableNodeMatches;
+    return substitutionNodeMatches;
   }
 
   unifyWithEquivalence(equivalence, substitutions, localContextA, localContextB) {
@@ -84,122 +129,47 @@ export default class TermForVariableSubstitution extends Substitution {
     return unifiedWithEquivalence;
   }
 
-  static fromSubstitution(substitution, localContext) {
-    let termForVariableSubstitution = null;
-
-    const substitutionNode = substitution.getNode();
-
-    let substitutionTermNode = substitutionTermNodeQuery(substitutionNode);
-
-    if (substitutionTermNode !== null) {
-      let termNode;
-
-      const substitutionVariableNode = substitutionsVariableNodeQuery(substitutionNode),
-            variableNode = substitutionVariableNode;  ///
-
-      termNode = substitutionTermNode;  ///
-
-      termNode = stripBracketsFromTerm(termNode); ///
-
-      const { Term, Variable } = shim,
-            term = Term.fromTermNode(termNode, localContext),
-            variable = Variable.fromVariableNode(variableNode, localContext),
-            string = stringFromTermAndVariable(term, variable);
-
-      termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode);
-    }
-
-    return termForVariableSubstitution;
-  }
-
   static fromStatementNode(statementNode, localContext) {
     let termForVariableSubstitution = null;
 
     const substitutionNode = substitutionNodeQuery(statementNode);
 
     if (substitutionNode !== null) {
-      let substitutionTermNode = substitutionTermNodeQuery(substitutionNode);
-
-      if (substitutionTermNode !== null) {
-        let termNode;
-
-        const substitutionVariableNode = substitutionsVariableNodeQuery(substitutionNode),
-              variableNode = substitutionVariableNode;  ///
-
-        termNode = substitutionTermNode;  ///
+      const termNode = termNodeQuery(substitutionNode),
+            variableNode = variableNodeQuery(substitutionNode);
 
+      if ((termNode !== null) && (variableNode !== null)) {
         const { Term, Variable } = shim,
               term = Term.fromTermNode(termNode, localContext),
               variable = Variable.fromVariableNode(variableNode, localContext),
-              string = stringFromTermAndVariable(term, variable);
+              string = stringFromTermAndVariable(term, variable, localContext),
+              substitutionTokens = localContext.nodeAsTokens(substitutionNode);
 
-        termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode);
+        termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode, substitutionNode, substitutionTokens);
       }
     }
 
     return termForVariableSubstitution;
   }
 
-  static fromTernAndVariable(term, variable) {
+  static fromTernAndVariable(term, variable, localContext) {
     let termNode = term.getNode();
 
     termNode = stripBracketsFromTerm(termNode); ///
 
-    const variableNode = variable.getNode(),
-          string = stringFromTermAndVariable(term, variable),
-          termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode);
+    const string = stringFromTermAndVariable(term, variable, localContext),
+          variableNode = variable.getNode(),
+          substitutionNode = null,
+          substitutionTokens = null,
+          termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode, substitutionNode, substitutionTokens);
 
     return termForVariableSubstitution;
   }
 }
 
-function transformTermNode(termNode, substitutions) {
-  let transformedTermNode = null;
-
-  const termVariableNode = termVariableNodeQuery(termNode);
-
-  if (termVariableNode !== null) {
-    const variableNode = termVariableNode;  ///
-
-    substitutions.someSubstitution((substitution) => {
-      const substitutionMatchesVariableNode = substitution.matchVariableNode(variableNode);
-
-      if (substitutionMatchesVariableNode) {
-        const termNode = substitution.getTermNode();
-
-        transformedTermNode = termNode; ////
-
-        return true;
-      }
-    });
-  }
-
-  return transformedTermNode;
-}
-
-function transformVariableNode(variableNode, substitutions) {
-  let transformedVariableNode = null;
-
-  substitutions.someSubstitution((substitution) => {
-    const variableNodeMatches = substitution.matchVariableNode(variableNode);
-
-    if (variableNodeMatches) {
-      const termNode = substitution.getTermNode(),
-            termVariableNode = termVariableNodeQuery(termNode);
-
-      if (termVariableNode !== null) {
-        transformedVariableNode = termVariableNode;  ///
-
-        return true;
-      }
-    }
-  });
-
-  return transformedVariableNode;
-}
-
-function stringFromTermAndVariable(term, variable) {
-  const termString = term.getString(),
+function stringFromTermAndVariable(term, variable, localContext) {
+  const termNode = term.getNode(),
+        termString = localContext.nodeAsString(termNode),
         variableString = variable.getString(),
         string = `[${termString} for ${variableString}]`;
 

package/src/substitution.js

@@ -9,36 +9,53 @@ export default class Substitution {
     return this.string;
   }
 
-  isSimple() {
-    const simple = true;
+  getTermNode() {
+    const termNode = null;
 
-    return simple;
+    return termNode;
   }
 
-  isComplex() {
-    const simple = this.isSimple(),
-          complex = !simple;
+  getFrameNode() {
+    const frameNode = null;
 
-    return complex;
+    return frameNode;
   }
 
-  isResolved() {
-    const simple = this.isSimple(),
-          resolved = simple; ///
+  getStatementNode() {
+    const statementNode = null;
 
-    return resolved;
+    return statementNode;
+  }
+
+  getSubstitutionNode() {
+    const substitutionNode = null;
+
+    return substitutionNode;
+  }
+
+  getVariableName() {
+    const variableName = null;
+
+    return variableName;
+  }
+
+  getMetavariableName() {
+    const metavariableName = null;
+
+    return metavariableName;
   }
 
-  getVariableNode() {
-    const variableNode = null;
+  isSimple() {
+    const simple = true;
 
-    return variableNode;
+    return simple;
   }
 
-  getMetavariableNode() {
-    const metavariableNode = null;
+  isComplex() {
+    const simple = this.isSimple(),
+          complex = !simple;
 
-    return metavariableNode;
+    return complex;
   }
 
   isEqualTo(substitution) {
@@ -47,16 +64,22 @@ export default class Substitution {
     return equalTo;
   }
 
+  resolve(substitutions, localContext) {
+    const resolved = true;
+
+    return resolved;
+  }
+
   matchTermNode(termNode) {
     const termNodeMatches = false;
 
     return termNodeMatches;
   }
 
-  matchVariableNode(variableNode) {
-    const variableNodeMatches = false;
+  matchFrameNode(frameNode) {
+    const frameNodeMatches = false;
 
-    return variableNodeMatches;
+    return frameNodeMatches;
   }
 
   matchStatementNode(statementNode) {
@@ -65,16 +88,22 @@ export default class Substitution {
     return statementNodeMatches;
   }
 
-  matchMetavariableNode(metavariableNode) {
-    const metavariableNodeMatches = false;
+  matchVariableName(variableName) {
+    const variableNameMatches = false;
+
+    return variableNameMatches;
+  }
+
+  matchMetavariableName(metavariableName) {
+    const metavariableNameMatches = false;
 
-    return metavariableNodeMatches;
+    return metavariableNameMatches;
   }
 
-  matchMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
-    const metavariableNodeAndSubstitutionNodeMatches = false;
+  matchMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode) {
+    const metavariableNameAndSubstitutionNodeMatches = false;
 
-    return metavariableNodeAndSubstitutionNodeMatches;
+    return metavariableNameAndSubstitutionNodeMatches;
   }
 
   unifyWithEquivalence(equivalence, substitutions, localContextA, localContextB) {