occam-verify-cli 0.0.1089 → 0.0.1091

package/src/substitution/statementForMetavariable.js

@@ -5,12 +5,19 @@ import Substitution from "../substitution";
 import LocalContext from "../context/local";
 import metaLevelUnifier from "../unifier/metaLevel";
 
+import { nodeQuery } from "../utilities/query";
 import { stripBracketsFromStatementNode } from "../utilities/brackets";
 import { statementFromJSON, statementToStatementJSON, metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
+import { unqualifiedStatementTokensFromUnqualifiedStatementString, substitutionTokensFromUnqualifiedStatementTokensAndSubstitutionNode } from "../utilities/tokens";
+import { substitutionNodeFromUnqualifiedStatementNode,
+         unqualifiedStatementStringFromSubstitutionString,
+         unqualifiedStatementNodeFromUnqualifiedStatementTokens } from "../utilities/node";
 
-export default class StatementForMetavariableSubstitution extends Substitution {
-  constructor(string, resolved, statement, metavariable, substitution) {
-    super(string);
+const substitutionNodeQuery = nodeQuery("/statement/substitution");
+
+class StatementForMetavariableSubstitution extends Substitution {
+  constructor(string, node, tokens, resolved, statement, metavariable, substitution) {
+    super(string, node, tokens);
 
     this.resolved = resolved;
     this.statement = statement;
@@ -46,78 +53,114 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return simple;
   }
 
-  resolve(substitutions, localContextA, localContextB) {
+  matchStatementNode(statementNode) {
+    statementNode = stripBracketsFromStatementNode(statementNode); ///
+
+    const statementNodeMatches = this.statement.matchStatementNode(statementNode);
+
+    return statementNodeMatches;
+  }
+
+  matchMetavariableNode(metavariableNode) { return this.metavariable.matchMetavariableNode(metavariableNode); }
+
+  matchSubstitutionNode(substitutionNode) {
+    debugger
+
+    let substitutionNodeMatches;
+
+    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;
+  }
+
+  matchMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
+    const metavariableNodeMatches = this.matchMetavariableNode(metavariableNode),
+          substitutionNodeMatches = this.matchSubstitutionNode(substitutionNode),
+          metavariableNodeAndSubstitutionNodeMatches = (metavariableNodeMatches && substitutionNodeMatches);
+
+    return metavariableNodeAndSubstitutionNodeMatches;
+  }
+
+  resolve(substitutions, generalContext, specificContext) {
     const substitutionString = this.string;
 
     const metavariableNode = this.getMetavariableNode(),
           simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariableNode(metavariableNode);
 
     if (simpleSubstitution !== null) {
-      localContextB.trace(`Resolving the ${substitutionString} substitution...`);
+      specificContext.trace(`Resolving the ${substitutionString} substitution...`);
 
       const substitution = simpleSubstitution,  ///
-            substitutionResolved = substitution.resolveSubstitution(this.substitution, this.statement, substitutions, localContextA, localContextB);
+        substitutionResolved = substitution.resolveSubstitution(this.substitution, this.statement, substitutions, generalContext, specificContext);
 
       this.resolved = substitutionResolved; ///
 
       if (this.resolved) {
-        localContextB.debug(`...resolved the ${substitutionString} substitution.`);
+        specificContext.debug(`...resolved the ${substitutionString} substitution.`);
       }
     }
   }
 
-  resolveSubstitution(substitution, statement, substitutions, localContextA, localContextB) {
+  resolveSubstitution(substitution, statement, substitutions, generalContext, specificContext) {
     let substitutionResolved = false;
 
     const substitutionString = substitution.getString();
 
-    localContextB.trace(`Resolving the ${substitutionString} substitution...`);
+    specificContext.trace(`Resolving the ${substitutionString} substitution...`);
 
-    const substitutionA = substitution, ///
-          substitutionB = this.unifyStatement(statement, localContextB, localContextB);  ///
+    const generalSubstitution = substitution, ///
+          specificSubstitution = this.unifyStatement(statement, specificContext, specificContext);  ///
 
-    if (substitutionB !== null) {
-      localContextA = localContextFromLocalContextAndSubstitution(localContextA, substitutionA);  ///
+    if (specificSubstitution !== null) {
+      generalContext = contextFromLocalContextAndSubstitution(generalContext, generalSubstitution);  ///
 
-      localContextB = localContextFromLocalContextAndSubstitution(localContextB, substitutionB);  ///
+      specificContext = contextFromLocalContextAndSubstitution(specificContext, specificSubstitution);  ///
 
       substitutions.snapshot();
 
-      const substitutionNodeA = substitutionA.getSubstitutionNode(),  ///
-            substitutionNodeB = substitutionB.getSubstitutionNode(),  ///
-            substitutionStringA = localContextA.nodeAsString(substitutionNodeA),
-            substitutionStringB = localContextB.nodeAsString(substitutionNodeB);
+      const generalSubstitutionNode = generalSubstitution.getSubstitutionNode(),  ///
+            specificSubstitutionNode = specificSubstitution.getSubstitutionNode(),  ///
+            generalSubstitutionString = generalContext.nodeAsString(generalSubstitutionNode),
+            specificSubstitutionString = specificContext.nodeAsString(specificSubstitutionNode);
 
-      localContextB.trace(`Unifying the '${substitutionStringB}' substitution with the '${substitutionStringA}' substitution...`);
+      specificContext.trace(`Unifying the '${specificSubstitutionString}' substitution with the '${generalSubstitutionString}' substitution...`);
 
-      const nodeA = substitutionNodeA,  ///
-            nodeB = substitutionNodeB,  ///
-            unifiedAtMetaLevel = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+      const generalNode = generalSubstitutionNode,  ///
+            specificNode = specificSubstitutionNode,  ///
+            unifiedAtMetaLevel = metaLevelUnifier.unify(generalNode, specificNode, substitutions, generalContext, specificContext);
 
       if (unifiedAtMetaLevel) {
-        localContextB.trace(`...unified the '${substitutionStringB}' substitution with the '${substitutionStringA}' substitution.`);
+        specificContext.trace(`...unified the '${specificSubstitutionString}' substitution with the '${generalSubstitutionString}' substitution.`);
       }
 
       unifiedAtMetaLevel ?
         substitutions.continue() :
-          substitutions.rollback(localContextB);
+          substitutions.rollback(specificContext);
 
       substitutionResolved = unifiedAtMetaLevel;  ///
     }
 
     if (substitutionResolved) {
-      localContextB.debug(`...resolved the ${substitutionString} substitution.`);
+      specificContext.debug(`...resolved the ${substitutionString} substitution.`);
     }
 
     return substitutionResolved;
   }
 
-  unifyStatement(statement, localContextA, localContextB) {
-    let substitution = null;
+  unifyStatement(statement, generalContext, specificContext) {
+    let specificSubstitution = null;
 
     const { Substitutions } = shim,
           substitutions = Substitutions.fromNothing(),
-          statementUnified = this.statement.unifyStatement(statement, substitutions, localContextA, localContextB);
+          statementUnified = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
 
     if (statementUnified) {
       const substitutionsLength = substitutions.getLength();
@@ -125,45 +168,11 @@ export default class StatementForMetavariableSubstitution extends Substitution {
       if (substitutionsLength === 1) {
         const firstSubstitution = substitutions.getFirstSubstitution();
 
-        substitution = firstSubstitution; ///
+        specificSubstitution = firstSubstitution; ///
       }
     }
 
-    return substitution;
-  }
-
-  matchStatementNode(statementNode) {
-    statementNode = stripBracketsFromStatementNode(statementNode); ///
-
-    const statementNodeMatches = this.statement.matchStatementNode(statementNode);
-
-    return statementNodeMatches;
-  }
-
-  matchMetavariableNode(metavariableNode) { return this.metavariable.matchMetavariableNode(metavariableNode); }
-
-  matchSubstitutionNode(substitutionNode) {
-    let substitutionNodeMatches;
-
-    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;
-  }
-
-  matchMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
-    const metavariableNodeMatches = this.matchMetavariableNode(metavariableNode),
-          substitutionNodeMatches = this.matchSubstitutionNode(substitutionNode),
-          metavariableNodeAndSubstitutionNodeMatches = (metavariableNodeMatches && substitutionNodeMatches);
-
-    return metavariableNodeAndSubstitutionNodeMatches;
+    return specificSubstitution;
   }
 
   toJSON() {
@@ -183,66 +192,107 @@ export default class StatementForMetavariableSubstitution extends Substitution {
 
   static fromJSON(json, fileContext) {
     const { string } = json,
+          lexer = fileContext.getLexer(),
+          parser = fileContext.getParser(),
+          substitutionString = string,  ///
+          unqualifiedStatementString = unqualifiedStatementStringFromSubstitutionString(substitutionString),
+          unqualifiedStatementTokens = unqualifiedStatementTokensFromUnqualifiedStatementString(unqualifiedStatementString, lexer),
+          unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser),
+          substitutionNode = substitutionNodeFromUnqualifiedStatementNode(unqualifiedStatementNode),
+          substitutionTokens = substitutionTokensFromUnqualifiedStatementTokensAndSubstitutionNode(unqualifiedStatementTokens, substitutionNode),
+          node = substitutionNode,  ///
+          tokens = substitutionTokens,  ///
           resolved = true,
           statement = statementFromJSON(json, fileContext),
           metavariable = metavariableFromJSON(json, fileContext),
           substitution = null,  ///
-          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, resolved, statement, metavariable, substitution);
+          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, node, tokens, resolved, statement, metavariable, substitution);
 
     return statementForMetavariableSubstitution;
   }
 
-  static fromStatementAndMetavariable(statement, metavariable, localContext) {
+  static fromStatementAndMetavariable(statement, metavariable, context) {
     let statementNode = statement.getNode();
 
     statementNode = stripBracketsFromStatementNode(statementNode); ///
 
     const { Statement } = shim;
 
-    statement = Statement.fromStatementNode(statementNode, localContext);
-
-    const substitution = null,
+    statement = Statement.fromStatementNode(statementNode, context);
+
+    const lexer = context.getLexer(),
+          parser = context.getParser(),
+          string = stringFromStatementAndMetavariable(statement, metavariable),
+          substitutionString = string,  ///
+          unqualifiedStatementString = unqualifiedStatementStringFromSubstitutionString(substitutionString),
+          unqualifiedStatementTokens = unqualifiedStatementTokensFromUnqualifiedStatementString(unqualifiedStatementString, lexer),
+          unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser),
+          substitutionNode = substitutionNodeFromUnqualifiedStatementNode(unqualifiedStatementNode),
+          substitutionTokens = substitutionTokensFromUnqualifiedStatementTokensAndSubstitutionNode(unqualifiedStatementTokens, substitutionNode),
+          node = substitutionNode,  ///
+          tokens = substitutionTokens,  ///
           resolved = true,
-          string = stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext),
-          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, resolved, statement, metavariable, substitution);
+          substitution = null,
+          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, node, tokens, resolved, statement, metavariable, substitution);
 
     return statementForMetavariableSubstitution;
   }
 
-  static fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext) {
+  static fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context) {
     let statementNode = statement.getNode();
 
     statementNode = stripBracketsFromStatementNode(statementNode); ///
 
     const { Statement } = shim;
 
-    statement = Statement.fromStatementNode(statementNode, localContext);
-
-    const string = stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext),
+    statement = Statement.fromStatementNode(statementNode, context);
+
+    const lexer = context.getLexer(),
+          parser = context.getParser(),
+          string = stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context),
+          substitutionString = string,  ///
+          unqualifiedStatementString = unqualifiedStatementStringFromSubstitutionString(substitutionString),
+          unqualifiedStatementTokens = unqualifiedStatementTokensFromUnqualifiedStatementString(unqualifiedStatementString, lexer),
+          unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser),
+          substitutionNode = substitutionNodeFromUnqualifiedStatementNode(unqualifiedStatementNode),
+          substitutionTokens = substitutionTokensFromUnqualifiedStatementTokensAndSubstitutionNode(unqualifiedStatementTokens, substitutionNode),
+          node = substitutionNode,  ///
+          tokens = substitutionTokens,  ///
           resolved = false,
-          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, resolved, statement, metavariable, substitution);
+          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, node, tokens, resolved, statement, metavariable, substitution);
 
     return statementForMetavariableSubstitution;
   }
 }
 
-function localContextFromLocalContextAndSubstitution(localContext, substitution) {
-  substitution.setSubstitutionNodeAndTokens(localContext);
+Object.assign(shim, {
+  StatementForMetavariableSubstitution
+});
+
+export default StatementForMetavariableSubstitution;
 
-  const substitutionTokens = substitution.getSubstitutionTokens(),
-        context = localContext, ///
-        tokens = substitutionTokens; ///
+function contextFromLocalContextAndSubstitution(context, substitution) {
+  const substitutionTokens = substitution.getTokens(),
+        tokens = substitutionTokens, ///
+        localContext = LocalContext.fromContextAndTokens(context, tokens); ///
 
-  localContext = LocalContext.fromContextAndTokens(context, tokens); ///
+  context = localContext; ///
 
-  return localContext;
+  return context;
+}
+
+function stringFromStatementAndMetavariable(statement, metavariable) {
+  const statementString = statement.getString(),
+        metavariableString = metavariable.getString(),
+        string = `[${statementString} for ${metavariableString}]`;
+
+  return string;
 }
 
-function stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext) {
+function stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution) {
   let string;
 
-  const statementNode = statement.getNode(),
-        statementString = localContext.nodeAsString(statementNode),
+  const statementString = statement.getString(),
         metavariableString = metavariable.getString();
 
   if (substitution === null) {

package/src/substitution/termForVariable.js

@@ -16,13 +16,11 @@ const termNodeQuery = nodeQuery("/substitution/term[0]"),
       substitutionNodeQuery = nodeQuery("/statement/substitution");
 
 export default class TermForVariableSubstitution extends Substitution {
-  constructor(string, term, variable, substitutionNode, substitutionTokens) {
-    super(string);
+  constructor(string, node, tokens, term, variable) {
+    super(string, node, tokens);
 
     this.term = term;
     this.variable = variable;
-    this.substitutionNode = substitutionNode;
-    this.substitutionTokens = substitutionTokens;
   }
 
   getTerm() {
@@ -33,35 +31,6 @@ export default class TermForVariableSubstitution extends Substitution {
     return this.variable;
   }
 
-  getSubstitutionNode() {
-    return this.substitutionNode;
-  }
-
-  getSubstitutionTokens() {
-    return this.substitutionTokens;
-  }
-
-  getSubstitutionString() {
-    const termString = this.term.getString(),
-          variableString = this.variable.getString(),
-          substitutionString = `[${termString} for ${variableString}]`;
-
-    return substitutionString;
-  }
-
-  setSubstitutionNodeAndTokens(localContext) {
-    const lexer = localContext.getLexer(),
-          parser = localContext.getParser(),
-          substitutionString = this.getSubstitutionString(),
-          unqualifiedStatementString = unqualifiedStatementStringFromSubstitutionString(substitutionString),
-          unqualifiedStatementTokens = unqualifiedStatementTokensFromUnqualifiedStatementString(unqualifiedStatementString, lexer),
-          unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser);
-
-    this.substitutionNode = substitutionNodeFromUnqualifiedStatementNode(unqualifiedStatementNode);
-
-    this.substitutionTokens = substitutionTokensFromUnqualifiedStatementTokensAndSubstitutionNode(unqualifiedStatementTokens, this.substitutionNode);
-  }
-
   isEqualTo(substitution) {
     let equalTo = false;
 
@@ -103,6 +72,8 @@ export default class TermForVariableSubstitution extends Substitution {
   }
 
   matchSubstitutionNode(substitutionNode) {
+    debugger
+
     let substitutionNodeMatches;
 
     if ((substitutionNode === null) && (this.substitutionNode === null)) {
@@ -118,7 +89,7 @@ export default class TermForVariableSubstitution extends Substitution {
     return substitutionNodeMatches;
   }
 
-  unifyWithEquivalence(equivalence, substitutions, localContextA, localContextB) {
+  unifyWithEquivalence(equivalence, substitutions, generalContext, specificContext) {
     let unifiedWithEquivalence;
 
     const termNode = this.term.getNode(),
@@ -136,7 +107,7 @@ export default class TermForVariableSubstitution extends Substitution {
     return unifiedWithEquivalence;
   }
 
-  static fromStatementNode(statementNode, localContext) {
+  static fromStatementNode(statementNode, context) {
     let termForVariableSubstitution = null;
 
     const substitutionNode = substitutionNodeQuery(statementNode);
@@ -147,39 +118,47 @@ export default class TermForVariableSubstitution extends Substitution {
 
       if ((termNode !== null) && (variableNode !== null)) {
         const { Term, Variable } = shim,
-              term = Term.fromTermNode(termNode, localContext),
-              variable = Variable.fromVariableNode(variableNode, localContext),
-              string = stringFromTermAndVariable(term, variable, localContext),
-              substitutionTokens = localContext.nodeAsTokens(substitutionNode);
+              term = Term.fromTermNode(termNode, context),
+              variable = Variable.fromVariableNode(variableNode, context),
+              node = substitutionNode,  ///
+              tokens = context.nodeAsTokens(node),
+              string = stringFromTermAndVariable(term, variable);
 
-        termForVariableSubstitution = new TermForVariableSubstitution(string, term, variable, substitutionNode, substitutionTokens);
+        termForVariableSubstitution = new TermForVariableSubstitution(string, node, tokens, term, variable);
       }
     }
 
     return termForVariableSubstitution;
   }
 
-  static fromTernAndVariable(term, variable, localContext) {
+  static fromTernAndVariable(term, variable, context) {
     let termNode = term.getNode();
 
     termNode = stripBracketsFromTermNode(termNode); ///
 
     const { Term } = shim;
 
-    term = Term.fromTermNode(termNode, localContext);
+    term = Term.fromTermNode(termNode, context);
 
-    const string = stringFromTermAndVariable(term, variable, localContext),
-          substitutionNode = null,
-          substitutionTokens = null,
-          termForVariableSubstitution = new TermForVariableSubstitution(string, term, variable, substitutionNode, substitutionTokens);
+    const lexer = context.getLexer(),
+          parser = context.getParser(),
+          string = stringFromTermAndVariable(term, variable),
+          substitutionString = string,  ///
+          unqualifiedStatementString = unqualifiedStatementStringFromSubstitutionString(substitutionString),
+          unqualifiedStatementTokens = unqualifiedStatementTokensFromUnqualifiedStatementString(unqualifiedStatementString, lexer),
+          unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser),
+          substitutionNode = substitutionNodeFromUnqualifiedStatementNode(unqualifiedStatementNode),
+          substitutionTokens = substitutionTokensFromUnqualifiedStatementTokensAndSubstitutionNode(unqualifiedStatementTokens, substitutionNode),
+          node = substitutionNode,  //
+          tokens = substitutionTokens,  ///
+          termForVariableSubstitution = new TermForVariableSubstitution(string, node, tokens, term, variable);
 
     return termForVariableSubstitution;
   }
 }
 
-function stringFromTermAndVariable(term, variable, localContext) {
-  const termNode = term.getNode(),
-        termString = localContext.nodeAsString(termNode),
+function stringFromTermAndVariable(term, variable) {
+  const termString = term.getString(),
         variableString = variable.getString(),
         string = `[${termString} for ${variableString}]`;
 

package/src/substitution.js

@@ -3,14 +3,24 @@
 import shim from "./shim";
 
 class Substitution {
-  constructor(string) {
+  constructor(string, node, tokens) {
     this.string = string;
+    this.node = node;
+    this.tokens = tokens;
   }
 
   getString() {
     return this.string;
   }
 
+  getNode() {
+    return this.node;
+  }
+
+  getTokens() {
+    return this.tokens;
+  }
+
   getTerm() {
     const term = null;
 
@@ -60,7 +70,7 @@ class Substitution {
     return equalTo;
   }
 
-  resolve(substitutions, localContext) {
+  resolve(substitutions, context) {
     const resolved = true;
 
     return resolved;
@@ -102,15 +112,15 @@ class Substitution {
     return metavariableNodeAndSubstitutionNodeMatches;
   }
 
-  unifyWithEquivalence(equivalence, substitutions, localContextA, localContextB) {
+  unifyWithEquivalence(equivalence, substitutions, generalContext, specificContext) {
     let unifiedWithEquivalence = false;
 
     return unifiedWithEquivalence;
   }
 
-  unifyWithEquivalences(equivalences, substitutions, localContextA, localContextB) {
+  unifyWithEquivalences(equivalences, substitutions, generalContext, specificContext) {
     const unifiedWithEquivalences = equivalences.some((equivalence) => {
-      const substitutionUnifiedWithEquivalence = this.unifyWithEquivalence(equivalence, substitutions, localContextA, localContextB);
+      const substitutionUnifiedWithEquivalence = this.unifyWithEquivalence(equivalence, substitutions, generalContext, specificContext);
 
       if (substitutionUnifiedWithEquivalence) {
         return true;

package/src/substitutions.js

@@ -186,15 +186,15 @@ class Substitutions {
     return substitutionPresent;
   }
 
-  addSubstitution(substitution, localContext) {
+  addSubstitution(substitution, context) {
     this.array.push(substitution);
 
     const substitutionString = substitution.getString();
 
-    localContext.trace(`Added the ${substitutionString} substitution.`);
+    context.trace(`Added the ${substitutionString} substitution.`);
   }
 
-  removeSubstitution(substitution, localContext) {
+  removeSubstitution(substitution, context) {
     const substitutionA = substitution; ///
 
     prune(this.array, (substitution) => {
@@ -207,13 +207,13 @@ class Substitutions {
 
     const substitutionString = substitution.getString();
 
-    localContext.trace(`Removed the ${substitutionString} substitution.`);
+    context.trace(`Removed the ${substitutionString} substitution.`);
   }
 
-  unifyWithEquivalences(equivalences, localContext) {
+  unifyWithEquivalences(equivalences, context) {
     const unifiedWithEquivalences = this.everySubstitution((substitution) => {
       const substitutions = this, ///
-            substitutionUnifiedWithEquivalence = substitution.unifyWithEquivalences(equivalences, substitutions, localContext);
+            substitutionUnifiedWithEquivalence = substitution.unifyWithEquivalences(equivalences, substitutions, context);
 
       if (substitutionUnifiedWithEquivalence) {
         return true;
@@ -223,7 +223,7 @@ class Substitutions {
     return unifiedWithEquivalences;
   }
 
-  resolve(localContextA, localContextB) {
+  resolve(generalContext, specificContext) {
     const metavariableNodes = this.getMetavariableNodes();
 
     metavariableNodes.forEach((metavariableNode) => {
@@ -237,7 +237,7 @@ class Substitutions {
               resolved = substitution.isResolved();
 
               if (!resolved) {
-                substitution.resolve(substitutions, localContextA, localContextB);
+                substitution.resolve(substitutions, generalContext, specificContext);
               }
             });
 
@@ -273,7 +273,7 @@ class Substitutions {
     ];
   }
 
-  rollback(localContext) {
+  rollback(context) {
     const array = [
       ...this.array
     ];
@@ -281,7 +281,7 @@ class Substitutions {
     leftDifference(array, this.savedArray);
 
     array.forEach((substitution) => {
-      this.removeSubstitution(substitution, localContext);
+      this.removeSubstitution(substitution, context);
     });
 
     this.array = [
@@ -295,9 +295,9 @@ class Substitutions {
     this.savedArray = null;
   }
 
-  getString(localContextA, localContextB) {
+  getString(generalContext, specificContext) {
     let string = this.array.reduce((string, substitution) => {
-      const substitutionString = substitution.getString(localContextA, localContextB);
+      const substitutionString = substitution.getString(generalContext, specificContext);
 
       string = (string === null) ?
                  substitutionString :