occam-verify-cli 0.0.1067 → 0.0.1069

package/src/substitution/statementForMetavariable.js

@@ -2,9 +2,12 @@
 
 import shim from "../shim";
 import Substitution from "../substitution";
+import LocalContext from "../context/local";
 import Substitutions from "../substitutions";
+import metaLevelUnifier from "../unifier/metaLevel";
 
-import { stripBracketsFromStatement } from "../utilities/brackets";
+import { stripBracketsFromStatementNode } from "../utilities/brackets";
+import { statementFromJSON, statementToStatementJSON, metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
 
 export default class StatementForMetavariableSubstitution extends Substitution {
   constructor(string, statement, metavariable, substitution) {
@@ -27,16 +30,10 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return this.substitution;
   }
 
-  getStatementNode() {
-    const statementNode = this.statement.getNode();
+  getMetavariableName() {
+    const metavariableName = this.metavariable.getName();
 
-    return statementNode;
-  }
-
-  getMetavariableNode() {
-    const metavariableNode = this.metavariable.getNode();
-
-    return metavariableNode;
+    return metavariableName;
   }
 
   isSimple() {
@@ -45,79 +42,93 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return simple;
   }
 
-  resolve(substitutions, localContext) {
+  resolve(substitutions, localContextA, localContextB) {
     let resolved = false;
 
     const substitutionString = this.string;
 
-    localContext.trace(`Resolving the ${substitutionString} substitution...`);
+    localContextB.trace(`Resolving the ${substitutionString} substitution...`);
 
-    const metavariableNode = this.getMetavariableNode(),
-          simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariableNode(metavariableNode);
+    const metavariableName = this.getMetavariableName(),
+          simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariableName(metavariableName);
 
     if (simpleSubstitution !== null) {
       const substitution = simpleSubstitution,  ///
-            substitutionResolved = substitution.resolveSubstitution(this.substitution, this.statement, substitutions, localContext);
+            substitutionResolved = substitution.resolveSubstitution(this.substitution, this.statement, substitutions, localContextA, localContextB);
 
       resolved = substitutionResolved; ///
     }
 
     if (resolved) {
-      localContext.debug(`...resolved the ${substitutionString} substitution.`);
+      localContextB.debug(`...resolved the ${substitutionString} substitution.`);
     }
 
     return resolved;
   }
 
-  resolveSubstitution(substitution, statement, substitutions, localContext) {
+  resolveSubstitution(substitution, statement, substitutions, localContextA, localContextB) {
     let substitutionResolved = false;
 
     const substitutionString = substitution.getString();
 
-    localContext.trace(`Resolving the ${substitutionString} substitution...`);
+    localContextB.trace(`Resolving the ${substitutionString} substitution...`);
 
-    const transformedSubstitution = substitution.transformed(substitutions, localContext);
+    const substitutionA = substitution, ///
+          substitutionB = this.unifyStatement(statement, localContextB, localContextB);  ///
 
-    if (transformedSubstitution !== null) {
-      const transformedSubstitutionString = transformedSubstitution.getString();
+    if (substitutionB !== null) {
+      localContextA = localContextFromLocalContextAndSubstitution(localContextA, substitutionA);  ///
 
-      localContext.trace(`Transformed the substitution to ${transformedSubstitutionString}...`);
+      localContextB = localContextFromLocalContextAndSubstitution(localContextB, substitutionB);  ///
 
-      substitutions = Substitutions.fromNothing();  ///
+      substitutions.snapshot();
 
-      const localContextA = localContext, ///
-            localContextB = localContext, ///
-            statementUnified = this.statement.unifyStatement(statement, substitutions, localContextA, localContextB);
+      const nodeA = substitutionA.getSubstitutionNode(),  ///
+            nodeB = substitutionB.getSubstitutionNode(),  ///
+            unifiedAtMetaLevel = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
 
-      if (statementUnified) {
-        const substitutionsLength = substitutions.getLength();
+      unifiedAtMetaLevel ?
+        substitutions.continue() :
+          substitutions.rollback(localContextB);
 
-        if (substitutionsLength === 1) {
-          const firstSubstitution = substitutions.getFirstSubstitution(),
-                substitution = firstSubstitution, ///
-                substitutionEqualToTransformedSubstitution = substitution.isEqualTo(transformedSubstitution);
-
-          substitutionResolved = substitutionEqualToTransformedSubstitution;  ///
-        }
-      }
+      substitutionResolved = unifiedAtMetaLevel;  ///
     }
 
     if (substitutionResolved) {
-      localContext.debug(`...resolved the ${substitutionString} substitution.`);
+      localContextB.debug(`...resolved the ${substitutionString} substitution.`);
     }
 
     return substitutionResolved;
   }
 
+  unifyStatement(statement, localContextA, localContextB) {
+    let substitution = null;
+
+    const substitutions = Substitutions.fromNothing(),
+          statementUnified = this.statement.unifyStatement(statement, substitutions, localContextA, localContextB);
+
+    if (statementUnified) {
+      const substitutionsLength = substitutions.getLength();
+
+      if (substitutionsLength === 1) {
+        const firstSubstitution = substitutions.getFirstSubstitution();
+
+        substitution = firstSubstitution; ///
+      }
+    }
+
+    return substitution;
+  }
+
   matchStatementNode(statementNode) {
-    statementNode = stripBracketsFromStatement(statementNode); ///
+    statementNode = stripBracketsFromStatementNode(statementNode); ///
 
     const statementNodeMatches = this.statement.matchStatementNode(statementNode);
 
     return statementNodeMatches;
   }
 
-  matchMetavariableNode(metavariableNode) { return this.metavariable.matchMetavariableNode(metavariableNode); }
+  matchMetavariableName(metavariableName) { return this.metavariable.matchMetavariableName(metavariableName); }
 
   matchSubstitutionNode(substitutionNode) {
     let substitutionNodeMatches;
@@ -135,18 +146,59 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return substitutionNodeMatches;
   }
 
-  matchMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
-    const metavariableNodeMatches = this.matchMetavariableNode(metavariableNode),
+  matchMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode) {
+    const metavariableNameMatches = this.matchMetavariableName(metavariableName),
           substitutionNodeMatches = this.matchSubstitutionNode(substitutionNode),
-          metavariableNodeAndSubstitutionNodeMatches = (metavariableNodeMatches && substitutionNodeMatches);
+          metavariableNameAndSubstitutionNodeMatches = (metavariableNameMatches && substitutionNodeMatches);
+
+    return metavariableNameAndSubstitutionNodeMatches;
+  }
 
-    return metavariableNodeAndSubstitutionNodeMatches;
+  toJSON() {
+    const metavariableJSON = metavariableToMetavariableJSON(this.metavariable),
+          statementJSON = statementToStatementJSON(this.statement),
+          metavariable = metavariableJSON,  ///
+          statement = statementJSON,  ///
+          string = this.string,
+          json = {
+            string,
+            statement,
+            metavariable
+          };
+
+    return json;
+  }
+
+  static fromJSON(json, fileContext) {
+    const { string } = json,
+          statement = statementFromJSON(json, fileContext),
+          metavariable = metavariableFromJSON(json, fileContext),
+          substitution = null,  ///
+          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, statement, metavariable, substitution);
+
+    return statementForMetavariableSubstitution;
+  }
+
+  static fromStatementAndMetavariable(statement, metavariable, localContext) {
+    let statementNode = statement.getNode();
+
+    statementNode = stripBracketsFromStatementNode(statementNode); ///
+
+    const { Statement } = shim;
+
+    statement = Statement.fromStatementNode(statementNode, localContext);
+
+    const substitution = null,
+          string = stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext),
+          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, statement, metavariable, substitution);
+
+    return statementForMetavariableSubstitution;
   }
 
   static fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext) {
     let statementNode = statement.getNode();
 
-    statementNode = stripBracketsFromStatement(statementNode); ///
+    statementNode = stripBracketsFromStatementNode(statementNode); ///
 
     const { Statement } = shim;
 
@@ -159,6 +211,18 @@ export default class StatementForMetavariableSubstitution extends Substitution {
   }
 }
 
+function localContextFromLocalContextAndSubstitution(localContext, substitution) {
+  substitution.setSubstitutionNodeAndTokens(localContext);
+
+  const substitutionTokens = substitution.getSubstitutionTokens(),
+        context = localContext, ///
+        tokens = substitutionTokens; ///
+
+  localContext = LocalContext.fromContextAndTokens(context, tokens); ///
+
+  return localContext;
+}
+
 function stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext) {
   let string;
 
@@ -175,4 +239,4 @@ function stringFromStatementMetavariableAndSubstitution(statement, metavariable,
   }
 
   return string;
-}
+}

package/src/substitution/termForVariable.js

@@ -4,63 +4,74 @@ import shim from "../shim";
 import Substitution from "../substitution";
 
 import { nodeQuery } from "../utilities/query";
-import { stripBracketsFromTerm } from "../utilities/brackets";
+import { stripBracketsFromTermNode } from "../utilities/brackets";
+import { substitutionNodeFromUnqualifiedStatementNode,
+         unqualifiedStatementStringFromSubstitutionString,
+         unqualifiedStatementNodeFromUnqualifiedStatementTokens } from "../utilities/node";
+import { unqualifiedStatementTokensFromUnqualifiedStatementString,
+         substitutionTokensFromUnqualifiedStatementTokensAndSubstitutionNode } 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!"),
+      substitutionNodeQuery = nodeQuery("/statement/substitution");
 
 export default class TermForVariableSubstitution extends Substitution {
-  constructor(string, termNode, variableNode, substitutionNode) {
+  constructor(string, term, variable, substitutionNode, substitutionTokens) {
     super(string);
 
-    this.termNode = termNode;
-    this.variableNode = variableNode;
+    this.term = term;
+    this.variable = variable;
     this.substitutionNode = substitutionNode;
+    this.substitutionTokens = substitutionTokens;
   }
 
-  getTermNode() {
-    return this.termNode;
+  getTerm() {
+    return this.term;
   }
 
-  getVariableNode() {
-    return this.variableNode;
+  getVariable() {
+    return this.variable;
   }
 
   getSubstitutionNode() {
     return this.substitutionNode;
   }
 
-  transformed(substitutions, localContext) {
-    let transformedSubstitution = null;
+  getSubstitutionTokens() {
+    return this.substitutionTokens;
+  }
+
+  getSubstitutionString() {
+    const termString = this.term.getString(),
+          variableString = this.variable.getString(),
+          substitutionString = `[${termString} for ${variableString}]`;
 
-    const transformedTermNode = transformTermNode(this.termNode, substitutions),
-          transformedVariableNode = transformVariableNode(this.variableNode, substitutions);
+    return substitutionString;
+  }
 
-    if ((transformedTermNode !== null) && (transformedVariableNode !== null)) {
-      const termNode = transformedTermNode, ///
-            variableNode = transformedVariableNode, ///
-            termString = localContext.nodeAsString(termNode),
-            variableString = localContext.nodeAsString(variableNode),
-            string = `[${termString} for ${variableString}]`,
-            substitutionNode = null,
-            termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode, substitutionNode);
+  setSubstitutionNodeAndTokens(localContext) {
+    const lexer = localContext.getLexer(),
+          parser = localContext.getParser(),
+          substitutionString = this.getSubstitutionString(),
+          unqualifiedStatementString = unqualifiedStatementStringFromSubstitutionString(substitutionString),
+          unqualifiedStatementTokens = unqualifiedStatementTokensFromUnqualifiedStatementString(unqualifiedStatementString, lexer),
+          unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser);
 
-      transformedSubstitution = termForVariableSubstitution;  ///
-    }
+    this.substitutionNode = substitutionNodeFromUnqualifiedStatementNode(unqualifiedStatementNode);
 
-    return transformedSubstitution;
+    this.substitutionTokens = substitutionTokensFromUnqualifiedStatementTokensAndSubstitutionNode(unqualifiedStatementTokens, this.substitutionNode);
   }
 
   isEqualTo(substitution) {
     let equalTo = false;
 
-    const termNode = substitution.getTermNode(),
-          variableNode = substitution.getVariableNode();
+    const term = substitution.getTerm(),
+          variable = substitution.getVariable();
 
-    if ((termNode !== null) && (variableNode !== null)) {
-      const termNodeMatches = this.matchTermNode(termNode),
+    if ((term !== null) && (variable !== null)) {
+      const termNode = term.getNode(),
+            variableNode = variable.getNode(),
+            termNodeMatches = this.matchTermNode(termNode),
             variableNodeMatches = this.matchVariableNode(variableNode);
 
       equalTo = (termNodeMatches && variableNodeMatches);
@@ -70,21 +81,39 @@ export default class TermForVariableSubstitution extends Substitution {
   }
 
   matchTermNode(termNode) {
-    termNode = stripBracketsFromTerm(termNode); ///
+    termNode = stripBracketsFromTermNode(termNode); ///
 
-    const termNodeMatches = this.termNode.match(termNode);
+    const termNodeMatches = this.term.matchTermNode(termNode);
 
     return termNodeMatches;
   }
 
-  matchVariableNode(variableNode) {
-    const variableNodeMatches = this.variableNode.match(variableNode);
+  matchVariableName(variableName) {
+    let variableNameMatches;
+
+    const variableNameA = variableName; ///
+
+    variableName = this.variable.getName();
+
+    const variableNameB = variableName; ///
+
+    variableNameMatches = (variableNameA === variableNameB);
 
-    return variableNodeMatches;
+    return variableNameMatches;
   }
 
   matchSubstitutionNode(substitutionNode) {
-    const substitutionNodeMatches = this.substitutionNode.match(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 substitutionNodeMatches;
   }
@@ -92,10 +121,12 @@ export default class TermForVariableSubstitution extends Substitution {
   unifyWithEquivalence(equivalence, substitutions, localContextA, localContextB) {
     let unifiedWithEquivalence;
 
-    const equivalenceMatchesTermNode = equivalence.matchTermNode(this.termNode);
+    const termNode = this.term.getNode(),
+          equivalenceMatchesTermNode = equivalence.matchTermNode(termNode);
 
     if (equivalenceMatchesTermNode) {
-      const equivalenceMatchesVariableNode = equivalence.matchVariableNode(this.variableNode);
+      const variableNode = this.variable.getNode(),
+            equivalenceMatchesVariableNode = equivalence.matchVariableNode(variableNode);
 
       if (equivalenceMatchesVariableNode) {
           unifiedWithEquivalence = true;
@@ -111,18 +142,17 @@ export default class TermForVariableSubstitution extends Substitution {
     const substitutionNode = substitutionNodeQuery(statementNode);
 
     if (substitutionNode !== null) {
-      let substitutionTermNode = substitutionTermNodeQuery(substitutionNode);
+      const termNode = termNodeQuery(substitutionNode),
+            variableNode = variableNodeQuery(substitutionNode);
 
-      if (substitutionTermNode !== null) {
+      if ((termNode !== null) && (variableNode !== null)) {
         const { Term, Variable } = shim,
-              substitutionVariableNode = substitutionsVariableNodeQuery(substitutionNode),
-              variableNode = substitutionVariableNode,  ///
-              termNode = substitutionTermNode,  ///
               term = Term.fromTermNode(termNode, localContext),
               variable = Variable.fromVariableNode(variableNode, localContext),
-              string = stringFromTermAndVariable(term, variable, localContext);
+              string = stringFromTermAndVariable(term, variable, localContext),
+              substitutionTokens = localContext.nodeAsTokens(substitutionNode);
 
-        termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode, substitutionNode);
+        termForVariableSubstitution = new TermForVariableSubstitution(string, term, variable, substitutionNode, substitutionTokens);
       }
     }
 
@@ -132,62 +162,21 @@ export default class TermForVariableSubstitution extends Substitution {
   static fromTernAndVariable(term, variable, localContext) {
     let termNode = term.getNode();
 
-    termNode = stripBracketsFromTerm(termNode); ///
+    termNode = stripBracketsFromTermNode(termNode); ///
+
+    const { Term } = shim;
+
+    term = Term.fromTermNode(termNode, localContext);
 
     const string = stringFromTermAndVariable(term, variable, localContext),
-          variableNode = variable.getNode(),
           substitutionNode = null,
-          termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode, substitutionNode);
+          substitutionTokens = null,
+          termForVariableSubstitution = new TermForVariableSubstitution(string, term, variable, 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, localContext) {
   const termNode = term.getNode(),
         termString = localContext.nodeAsString(termNode),

package/src/substitution.js

@@ -1,6 +1,8 @@
 "use strict";
 
-export default class Substitution {
+import shim from "./shim";
+
+class Substitution {
   constructor(string) {
     this.string = string;
   }
@@ -9,34 +11,22 @@ export default class Substitution {
     return this.string;
   }
 
-  getTermNode() {
-    const termNode = null;
+  getTerm() {
+    const term = null;
 
-    return termNode;
+    return term;
   }
 
-  getFrameNode() {
-    const frameNode = null;
+  getFrame() {
+    const frame = null;
 
-    return frameNode;
+    return frame;
   }
 
-  getStatementNode() {
-    const statementNode = null;
+  getStatement() {
+    const statement = null;
 
-    return statementNode;
-  }
-
-  getVariableNode() {
-    const variableNode = null;
-
-    return variableNode;
-  }
-
-  getMetavariableNode() {
-    const metavariableNode = null;
-
-    return metavariableNode;
+    return statement;
   }
 
   getSubstitutionNode() {
@@ -45,6 +35,12 @@ export default class Substitution {
     return substitutionNode;
   }
 
+  getMetavariableName() {
+    const metavariableName = null;
+
+    return metavariableName;
+  }
+
   isSimple() {
     const simple = true;
 
@@ -82,28 +78,28 @@ export default class Substitution {
     return frameNodeMatches;
   }
 
-  matchVariableNode(variableNode) {
-    const variableNodeMatches = false;
-
-    return variableNodeMatches;
-  }
-
   matchStatementNode(statementNode) {
     const statementNodeMatches = false;
 
     return statementNodeMatches;
   }
 
-  matchMetavariableNode(metavariableNode) {
-    const metavariableNodeMatches = false;
+  matchVariableName(variableName) {
+    const variableNameMatches = false;
 
-    return metavariableNodeMatches;
+    return variableNameMatches;
   }
 
-  matchMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
-    const metavariableNodeAndSubstitutionNodeMatches = false;
+  matchMetavariableName(metavariableName) {
+    const metavariableNameMatches = false;
 
-    return metavariableNodeAndSubstitutionNodeMatches;
+    return metavariableNameMatches;
+  }
+
+  matchMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode) {
+    const metavariableNameAndSubstitutionNodeMatches = false;
+
+    return metavariableNameAndSubstitutionNodeMatches;
   }
 
   unifyWithEquivalence(equivalence, substitutions, localContextA, localContextB) {
@@ -124,3 +120,9 @@ export default class Substitution {
     return unifiedWithEquivalences;
   }
 }
+
+Object.assign(shim, {
+  Substitution
+});
+
+export default Substitution;