occam-verify-cli 1.0.809 → 1.0.814

package/src/element/topLevelAssertion.js

@@ -16,8 +16,8 @@ import { labelsFromJSON,
          hypothesesToHypothesesJSON,
          suppositionsToSuppositionsJSON } from "../utilities/json";
 
-const { extract, reverse, correlate } = arrayUtilities,
-      { asyncForwardsEvery, asyncBackwardsEvery } = asynchronousUtilities;
+const { reverse, correlate } = arrayUtilities,
+      { asyncExtract, asyncForwardsEvery, asyncBackwardsEvery } = asynchronousUtilities;
 
 export default class TopLevelAssertion extends Element {
   constructor(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses) {
@@ -59,6 +59,12 @@ export default class TopLevelAssertion extends Element {
     this.hypotheses = hypotheses;
   }
 
+  getSupposition(index) {
+    const supposition = this.suppositions[index] || null;
+
+    return supposition;
+  }
+
   isHypothetical() {
     const hypothesesLength = this.hypotheses.length,
           hypothetical = (hypothesesLength > 0);
@@ -73,22 +79,16 @@ export default class TopLevelAssertion extends Element {
     return unconditional;
   }
 
-  getSupposition(index) {
-    const supposition = this.suppositions[index] || null;
-
-    return supposition;
-  }
+  matchMetavariableNode(metavariableNode) {
+    const metavariableNodeMatches = this.labels.some((label) => {
+      const metavariableNodeMatches = label.matchMetavariableNode(metavariableNode);
 
-  compareMetavariableName(metavariableName) {
-    const comparesToMetavariableName = this.labels.some((label) => {
-      const labelComparesToMetavariableName = label.compareMetavariableName(metavariableName);
-
-      if (labelComparesToMetavariableName) {
+      if (metavariableNodeMatches) {
         return true;
       }
     });
 
-    return comparesToMetavariableName;
+    return metavariableNodeMatches;
   }
 
   correlateHypotheses(context) {
@@ -120,28 +120,6 @@ export default class TopLevelAssertion extends Element {
     return correlatesToHypotheses;
   }
 
-  unifyStatementWithDeduction(statement, context) {
-    let statementUnifiesWithDeduction = false;
-
-    const statementString = statement.getString(),
-          deductionString = this.deduction.getString(),
-          topLevelAssertionString = this.getString(); ///
-
-    context.trace(`Unifying the '${statementString}' statement with the '${topLevelAssertionString}' top level assertion's '${deductionString}' deduction...`);
-
-    const statementUnifies = this.deduction.unifyStatement(statement, context);
-
-    if (statementUnifies) {
-      statementUnifiesWithDeduction = true;
-    }
-
-    if (statementUnifiesWithDeduction) {
-      context.debug(`...unified the '${statementString}' statement with the '${topLevelAssertionString}' top level assertion's '${deductionString}' deduction.`);
-    }
-
-    return statementUnifiesWithDeduction;
-  }
-
   async verify() {
     let verifies = false;
 
@@ -304,47 +282,65 @@ export default class TopLevelAssertion extends Element {
     return suppositionsVerify;
   }
 
-  async unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, context) {
-    let statementAndSubproofOrProofAssertionsUnify = false;
+  async unifyStepWithDeduction(step, context) {
+    let stepUnifiesWithDeduction = false;
+
+    await this.break(context);
+
+    const stepString = step.getString(),
+          deductionString = this.deduction.getString(),
+          topLevelAssertionString = this.getString(); ///
+
+    context.trace(`Unifying the '${stepString}' step with the '${topLevelAssertionString}' top level assertion's '${deductionString}' deduction...`);
+
+    const stepUnifies = await this.deduction.unifyStep(step, context);
+
+    if (stepUnifies) {
+      stepUnifiesWithDeduction = true;
+    }
+
+    if (stepUnifiesWithDeduction) {
+      context.debug(`...unified the '${stepString}' step with the '${topLevelAssertionString}' top level assertion's '${deductionString}' deduction.`);
+    }
+
+    return stepUnifiesWithDeduction;
+  }
+
+  async unifyStepAndSubproofOrProofAssertions(step, subproofOrProofAssertions, context) {
+    let stepAndSubproofOrProofAssertionsUnify = false;
 
     const correlatesToHypotheses = this.correlateHypotheses(context);
 
     if (correlatesToHypotheses) {
-      const statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, context);
+      const stepUnifiesWithDeduction = await this.unifyStepWithDeduction(step, context);
 
-      if (statementUnifiesWithDeduction) {
+      if (stepUnifiesWithDeduction) {
         const subproofOrProofAssertionsUnifiesWithSuppositions = await this.unifySubproofOrProofAssertionsWithSuppositions(subproofOrProofAssertions, context);
 
         if (subproofOrProofAssertionsUnifiesWithSuppositions) {
           const substitutionsResolved = context.areSubstitutionsResolved();
 
           if (substitutionsResolved) {
-            statementAndSubproofOrProofAssertionsUnify = true;
+            stepAndSubproofOrProofAssertionsUnify = true;
           }
         }
       }
     }
 
-    return statementAndSubproofOrProofAssertionsUnify;
+    return stepAndSubproofOrProofAssertionsUnify;
   }
 
   async unifySubproofOrProofAssertionsWithSupposition(subproofOrProofAssertions, supposition, context) {
     let subproofOrProofAssertionsUnifiesWithSupposition = false;
 
+    await this.break(context);
+
     if (!subproofOrProofAssertionsUnifiesWithSupposition) {
-      const subproofOrProofAssertion = extract(subproofOrProofAssertions, (subproofOrProofAssertion) => {
-        const subproofOrProofAssertionUnifies = supposition.unifySubproofOrProofAssertion(subproofOrProofAssertion, context);
+      const subproofOrProofAssertion = await asyncExtract(subproofOrProofAssertions, async (subproofOrProofAssertion) => {
+        const subproofOrProofAssertionUnifies = await supposition.unifySubproofOrProofAssertion(subproofOrProofAssertion, context);
 
         if (subproofOrProofAssertionUnifies) {
-          const specificContext = context;  ///
-
-          context = this.getContext();
-
-          const generalContext = context; ///
-
-          context = specificContext;  ///
-
-          context.resolveSubstitutions(generalContext, specificContext);
+          context.resolveSubstitutions();
 
           return true;
         }
@@ -371,7 +367,7 @@ export default class TopLevelAssertion extends Element {
 
     subproofOrProofAssertions = reverse(subproofOrProofAssertions); ///
 
-    subproofOrProofAssertionsUnifiesWithSuppositions = asyncBackwardsEvery(this.suppositions, async (supposition) => {
+    subproofOrProofAssertionsUnifiesWithSuppositions = await asyncBackwardsEvery(this.suppositions, async (supposition) => {
       const stepUnifiesWithSupposition = await this.unifySubproofOrProofAssertionsWithSupposition(subproofOrProofAssertions, supposition, context);
 
       if (stepUnifiesWithSupposition) {

package/src/element/variable.js

@@ -45,11 +45,11 @@ export default define(class Variable extends Element {
     return identifierEqualTo;
   }
 
-  compare(variable) {
+  compareVariable(variable) {
     const variableIdentifier = variable.getIdentifier(),
-          comparesTo = (this.identifier === variableIdentifier);
+          comparesToVariable = (this.identifier === variableIdentifier);
 
-    return comparesTo;
+    return comparesToVariable;
   }
 
   compareParamter(parameter) {
@@ -117,9 +117,9 @@ export default define(class Variable extends Element {
 
     variable = this; ///
 
-    const variableIdentifier = variable.getIdentifier();
+    const variableNode = variable.getNode();
 
-    substitution = context.findSubstitutionByVariableIdentifier(variableIdentifier);
+    substitution = context.findSubstitutionByVariableNode(variableNode);
 
     if (substitution !== null) {
       const substitutionComparesToTerm = substitution.compareTerm(term, context);

package/src/node/frame.js

@@ -22,18 +22,6 @@ export default class FrameNode extends NonTerminalNode {
     return singular;
   }
 
-  getMetavariableName() {
-    let metavariableName = null;
-
-    const metavariableNode = this.getMetavariableNode();
-
-    if (metavariableNode !== null) {
-      metavariableName = metavariableNode.getMetavariableName();
-    }
-
-    return metavariableName;
-  }
-
   getAssumptionNodes() {
     const ruleName = ASSUMPTION_RULE_NAME,
           declarationNodes = this.getNodesByRuleName(ruleName);

package/src/node/statement.js

@@ -31,18 +31,6 @@ export default class StatementNode extends NonTerminalNode {
     return singular;
   }
 
-  getMetavariableName() {
-    let metavariableName = null;
-
-    const metavariableNode = this.getMetavariableNode();
-
-    if (metavariableNode !== null) {
-      metavariableName = metavariableNode.getMetavariableName();
-    }
-
-    return metavariableName;
-  }
-
   getMetavariableNode() {
     const singularMetavariableNode = this.getSingularMetavariableNode(),
           metavariableNode = singularMetavariableNode;  ///

package/src/node/term.js

@@ -36,34 +36,6 @@ export default class TermNode extends NonTerminalNode {
     return singularTermNode;
   }
 
-  getVariableIdentifier() {
-    let variableIdentifier = null;
-
-    const singular = this.isSingular();
-
-    if (singular) {
-      const singularVariableNode = this.getSingularVariableNode();
-
-      variableIdentifier = singularVariableNode.getVariableIdentifier();
-    }
-
-    return variableIdentifier;
-  }
-
-  getSingularVariableIdentifier() {
-    let singularVariableIdentifier = null;
-
-    const singularVariableNode = this.getSingularVariableNode();
-
-    if (singularVariableNode !== null) {
-      const variableIdentifier = singularVariableNode.getVariableIdentifier();
-
-      singularVariableIdentifier = variableIdentifier;  ///
-    }
-
-    return singularVariableIdentifier;
-  }
-
   getVariableNodes() {
     const ruleName = VARIABLE_RULE_NAME,
           variableNodes = this.getNodesByRuleName(ruleName);

package/src/process/assign.js

@@ -24,37 +24,17 @@ export function judgementAssignmentFromJudgement(judgement, context) {
 }
 
 export function leftVariableAssignmentFromEquality(equality, context) {
-  let leftVariableAssignment = (contxt) => {
-    ///
-  };
-
   const type = equality.getType(),
-        leftTermNode = equality.getLeftTermNode(),
-        singularVariableNode = leftTermNode.getSingularVariableNode();
-
-  if (singularVariableNode !== null) {
-    const leftVariableNode = singularVariableNode;  ///
-
-    leftVariableAssignment = variableAssignmentFromVariableNodeAndType(leftVariableNode, type, context);
-  }
+        leftTerm = equality.getLeftTerm(),
+        leftVariableAssignment = variableAssignmentFromTermAndType(leftTerm, type, context);
 
   return leftVariableAssignment;
 }
 
 export function rightVariableAssignmentFromEquality(equality, context) {
-  let rightVariableAssignment = (context) => {
-    ///
-  };
-
   const type = equality.getType(),
-        rightTermNode = equality.getRightTermNode(),
-        singularVariableNode = rightTermNode.getSingularVariableNode();
-
-  if (singularVariableNode !== null) {
-    const rightVariableNode = singularVariableNode;  ///
-
-    rightVariableAssignment = variableAssignmentFromVariableNodeAndType(rightVariableNode, type, context);
-  }
+        rightTerm = equality.getRightTerm(),
+        rightVariableAssignment = variableAssignmentFromTermAndType(rightTerm, type, context);
 
   return rightVariableAssignment;
 }
@@ -68,15 +48,10 @@ export function variableAssignmentFromTypeAssertion(typeAssertion, context) {
         termSingular = term.isSingular();
 
   if (termSingular) {
-    const variableIdentifier = term.getVariableIdentifier(),
-          variable = context.findVariableByVariableIdentifier(variableIdentifier);
+    const type = typeAssertion.getType(),
+          variableNode = term.getVariableNode();
 
-    if (variable !== null) {
-      const type = typeAssertion.getType(),
-            variableNode = variable.getNode();
-
-      variableAssignment = variableAssignmentFromVariableNodeAndType(variableNode, type, context);
-    }
+    variableAssignment = variableAssignmentFromTermAndType(variableNode, type, context);
   }
 
   return variableAssignment;
@@ -104,26 +79,40 @@ export function variableAssignmentFromPrepertyAssertion(propertyAssertion, conte
 
   }
 
-function variableAssignmentFromVariableNodeAndType(variableNode, type, context) {
-  const variable = variableFromVariableNode(variableNode, context);
+function variableAssignmentFromTermAndType(term, type, context) {
+  let variableAssignment = (context) => {
+    ///
+  };
+
+  const termSingular = term.isSingular();
 
-  variable.setType(type);
+  if (termSingular) {
+    const termType = term.getType(),
+          termTypeEqualToType = termType.isEqualTo(type);
 
-  const variableAssignment = (context) => {
-    const declaredVariable = variable;  ///
+    if (!termTypeEqualToType) {
+      const variableNode = term.getVariableNode(),
+            variable = variableFromVariableNode(variableNode, context);
 
-    context.addDeclaredVariable(declaredVariable);
+      variable.setType(type);
 
-    const declaredVariableTypeString = declaredVariable.getTypeString(),
-          declaredVariableString = declaredVariable.getString(),
-          assigned = true;  ///
+      variableAssignment = (context) => {
+        const declaredVariable = variable;  ///
 
-    assigned ?
-      context.trace(`Assigned the '${declaredVariableString}' declared variable with type '${declaredVariableTypeString}'.`) :
-        context.debug(`Unable to assign the '${declaredVariableString}' declared variable with type '${declaredVariableTypeString}'.`);
+        context.addDeclaredVariable(declaredVariable);
 
-    return assigned;
-  };
+        const declaredVariableTypeString = declaredVariable.getTypeString(),
+              declaredVariableString = declaredVariable.getString(),
+              assigned = true;  ///
+
+        assigned ?
+          context.trace(`Assigned the '${declaredVariableString}' declared variable with type '${declaredVariableTypeString}'.`) :
+             context.debug(`Unable to assign the '${declaredVariableString}' declared variable with type '${declaredVariableTypeString}'.`);
+
+        return assigned;
+      };
+    }
+  }
 
   return variableAssignment;
 }

package/src/utilities/element.js

@@ -618,9 +618,10 @@ export function termSubstitutionFromTermSubstitutionNode(termSubstitutionNode, c
   const { TermSubstitution } = elements,
         node = termSubstitutionNode,  ///
         string = context.nodeAsString(node),
+        generalContext = generalContextFromTermSubstitutionNode(termSubstitutionNode, context),
         targetTerm = targetTermFromTermSubstitutionNode(termSubstitutionNode, context),
         replacementTerm = replacementTermFromTermSubstitutionNode(termSubstitutionNode, context),
-        termSubstitution = new TermSubstitution(context, string, node, targetTerm, replacementTerm);
+        termSubstitution = new TermSubstitution(context, string, node, generalContext, targetTerm, replacementTerm);
 
   return termSubstitution;
 }
@@ -629,9 +630,10 @@ export function frameSubstitutionFromFrameSubstitutionNode(frameSubstitutionNode
   const { FrameSubstitution } = elements,
         node = frameSubstitutionNode,  ///
         string = context.nodeAsString(node),
+        generalContext = generalContextFromFrameSubstitutionNode(frameSubstitutionNode, context),
         targetFrame = targetFrameFromFrameSubstitutionNode(frameSubstitutionNode, context),
         replacementFrame = replacementFrameFromFrameSubstitutionNode(frameSubstitutionNode, context),
-        frameSubstitution = new FrameSubstitution(context, string, node, targetFrame, replacementFrame);
+        frameSubstitution = new FrameSubstitution(context, string, node, generalContext, targetFrame, replacementFrame);
 
   return frameSubstitution;
 }
@@ -767,9 +769,10 @@ export function referenceSubstitutionFromReferenceSubstitutionNode(referenceSubs
   const { ReferenceSubstitution } = elements,
         node = referenceSubstitutionNode,  ///
         string = context.nodeAsString(node),
+        generalContext = generalContextFromReferenceSubstitutionNode(referenceSubstitutionNode, context),
         targetReference = targetReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context),
         replacementReference = replacementReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context),
-        referenceSubstitution = new ReferenceSubstitution(context, string, node, targetReference, replacementReference);
+        referenceSubstitution = new ReferenceSubstitution(context, string, node, generalContext, targetReference, replacementReference);
 
   return referenceSubstitution;
 }
@@ -779,11 +782,12 @@ export function statementSubstitutionFromStatementSubstitutionNode(statementSubs
   const { StatementSubstitution } = elements,
         node = statementSubstitutionNode,  ///
         string = context.nodeAsString(node),
+        generalContext = generalContextFromStatementSubstitutionNode(statementSubstitutionNode, context),
         resolved = resolvedFromStatementSubstitutionNode(statementSubstitutionNode, context),
         substitution = substitutionFromStatementSubstitutionNode(statementSubstitutionNode, context),
         targetStatement = targetStatementFromStatementSubstitutionNode(statementSubstitutionNode, context),
         replacementStatement = replacementStatementFromStatementSubstitutionNode(statementSubstitutionNode, context),
-        statementSubstitution = new StatementSubstitution(context, string, node, resolved, substitution, targetStatement, replacementStatement);
+        statementSubstitution = new StatementSubstitution(context, string, node, generalContext, resolved, substitution, targetStatement, replacementStatement);
 
   return statementSubstitution;
 }
@@ -1757,6 +1761,12 @@ export function topLevelMetaAssertionFromReferenceNode(referenceNode, context) {
   return topLevelMetaAssertion;
 }
 
+export function generalContextFromTermSubstitutionNode(termSubstitutionNode, context) {
+  const generalContext = null;
+
+  return generalContext;
+}
+
 export function deductionFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context) {
   const deductionNode = metaLemmaMetathoremNode.getDeductionNode(),
         deduction = deductionFromDeductionNode(deductionNode, context);
@@ -1778,6 +1788,12 @@ export function replacementTermFromTermSubstitutionNode(termSubstitutionNode, co
   return replacementTerm;
 }
 
+export function generalContextFromFrameSubstitutionNode(frameSubstitutionNode, context) {
+  const generalContext = null;
+
+  return generalContext;
+}
+
 export function superTypesFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
   let superTypes = [];
 
@@ -1881,6 +1897,18 @@ export function provisionalFromComplexTypeDeclarationNode(complexTypeDeclaration
   return provisional;
 }
 
+export function generalContextFromStatementSubstitutionNode(statementSubstitutionNode, context) {
+  const generalContext = null;
+
+  return generalContext;
+}
+
+export function generalContextFromReferenceSubstitutionNode(referenceSubstitutionNode, context) {
+  const generalContext = null;
+
+  return generalContext;
+}
+
 export function metavariableFromMetavariableDeclarationNode(metavariableDeclarationNode, context) {
   const metavariableNode = metavariableDeclarationNode.getMetavariableNode(),
         metavariable = metavariableFromMetavariableNode(metavariableNode, context);

package/src/utilities/equivalence.js

@@ -8,16 +8,15 @@ export function variablesFromTerm(term, context) {
   const termNode = term.getNode(),
         variableNodes = termNode.getVariableNodes(),
         variables = variableNodes.map((variableNode) => {
-          const variableIdentifier = variableNode.getVariableIdentifier(),
-                variable = context.findVariableByVariableIdentifier(variableIdentifier);
+          const variable = context.findVariableByVariableNode(variableNode);
 
           return variable;
         });
 
   compress(variables, (variableA, variableB) => {
-    const variableAEqualToVariableB = variableA.isEqualTo(variableB);
+    const variableAComparesToVariableB = variableA.compareVariable(variableB);
 
-    if (!variableAEqualToVariableB) {
+    if (!variableAComparesToVariableB) {
       return true;
     }
   });

package/src/utilities/equivalences.js

@@ -2,6 +2,8 @@
 
 import { arrayUtilities } from "necessary";
 
+import elements from "../elements";
+
 import { variablesFromTerm } from "../utilities/equivalence";
 
 const { push, separate } = arrayUtilities;
@@ -30,6 +32,16 @@ export function findEquivalenceByTerm(equivalences, term) {
   return equivalence;
 }
 
+export function equivalencesFromEquality(equality, context) {
+  const { Equivalence } = elements,
+        eaulivalence = Equivalence.fromEquality(equality, context),
+        equivalences = [
+          eaulivalence
+        ];
+
+  return equivalences;
+}
+
 export function findEquivalenceByTermNodes(equivalences, termNodes) {
   const equivalence = equivalences.find((equivalence) => {
     const termNodeMatches = equivalence.matchTermNodes(termNodes);
@@ -114,6 +126,23 @@ function mergeEquivalence(equivalencesA, equivalenceB, context) {
   return equivalencesA;
 }
 
+function definedVariablesFromGroundedTerms(groundedTerms, definedVariables, context) {
+  groundedTerms.forEach((groundedTerm) => {
+    const term = groundedTerm,  ///
+          variables = variablesFromTerm(term, context);
+
+    variables.forEach((variable) => {
+      const definedVariablesIncludesTermVariable = definedVariables.includes(variable);
+
+      if (!definedVariablesIncludesTermVariable) {
+        const definedVariable = variable;  ///
+
+        definedVariables.push(definedVariable);
+      }
+    });
+  });
+}
+
 function separateInitiallyGroundedEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences, context) {
   separate(equivalences, remainingEquivalences, initiallyGroundedEquivalences, (equivalence) => {
     const equivalenceInitiallyGrounded = equivalence.isInitiallyGrounded(context);
@@ -134,23 +163,6 @@ function separateImplicitlyGroundedEquivalences(equivalences, remainingEquivalen
   });
 }
 
-function definedVariablesFromGroundedTerms(groundedTerms, definedVariables, context) {
-  groundedTerms.forEach((groundedTerm) => {
-    const term = groundedTerm,  ///
-          variables = variablesFromTerm(term, context);
-
-    variables.forEach((variable) => {
-      const definedVariablesIncludesTermVariable = definedVariables.includes(variable);
-
-      if (!definedVariablesIncludesTermVariable) {
-        const definedVariable = variable;  ///
-
-        definedVariables.push(definedVariable);
-      }
-    });
-  });
-}
-
 function groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, context) {
   groundedEquivalences.forEach((groundedEquivalence) => {
     groundedEquivalence.getGroundedTerms(definedVariables, groundedTerms, context);

package/src/utilities/string.js

@@ -160,8 +160,8 @@ export function termSubstitutionStringFromTermAndVariable(term, variable) {
 }
 
 export function rulsStringFromLabelsPremisesAndConclusion(labels, premises, conclusion) {
-  const premisesString = premisesStringFromPremises(premises),
-        conclusionString = conclusion.getString(),
+  const conclusionString = conclusion.getString(),
+        premisesString = premisesStringFromPremises(premises),
         labelsString = labelsStringFromLabels(labels),
         ruleString = (premisesString !== null) ?
                        `${labelsString} :: [${premisesString}]...${conclusionString}` :

package/src/utilities/substitutions.js

@@ -12,8 +12,8 @@ export function termFromTermAndSubstitutions(term, generalContext, specificConte
     term = null;  ///
 
     if (termSingular) {
-      const variableIdentifier = termNode.getVariableIdentifier(),
-            substitution = specificContext.findSubstitutionByVariableIdentifier(variableIdentifier);
+      const variableNode = termNode.getVariableNode(),
+            substitution = specificContext.findSubstitutionByVariableNode(variableNode);
 
       if (substitution !== null) {
         const termSubstitution = substitution,  ///
@@ -35,8 +35,8 @@ export function frameFromFrameAndSubstitutions(frame, generalContext, specificCo
     frame = null;  ///
 
     if (frameSingular) {
-      const metavariableName = frameNode.getMetavariableName(),
-            substitution = specificContext.findSubstitutionByMetavariableName(metavariableName);
+      const metavariableNode = frameNode.getMetavariableNode(),
+            substitution = specificContext.findSubstitutionByMetavariableNode(metavariableNode);
 
       if (substitution !== null) {
         const frameSubstitution = substitution, ///
@@ -78,11 +78,11 @@ export function statementFromStatementAndSubstitutions(statement, generalContext
         specificContext = context;  ///
       }
 
-      const metavariableName = statementNode.getMetavariableName();
+      const metavariableNode = statementNode.getMetavariableNode();
 
       substitution = (substitution !== null) ?
-                       specificContext.findSubstitutionByMetavariableNameAndSubstitution(metavariableName, substitution) :
-                         specificContext.findSubstitutionByMetavariableName(metavariableName);
+                       specificContext.findSubstitutionByMetavariableNodeAndSubstitution(metavariableNode, substitution) :
+                         specificContext.findSubstitutionByMetavariableNode(metavariableNode);
 
       if (substitution !== null) {
         const statementSubstitution = substitution, ///
@@ -96,22 +96,24 @@ export function statementFromStatementAndSubstitutions(statement, generalContext
   return statement;
 }
 
-export function metavariableNamesFromSubstitutions(substitutions) {
-  const metavariableNames = [];
+export function metavariableNodesFromSubstitutions(substitutions) {
+  const metavariableNodes = [];
 
   substitutions.forEach((substitution) => {
-    const metavariableName = substitution.getMetavariableName();
+    const metavariableNode = substitution.getMetavariableNode();
 
-    if (metavariableName !== null) {
-      metavariableNames.push(metavariableName);
+    if (metavariableNode !== null) {
+      metavariableNodes.push(metavariableNode);
     }
   });
 
-  compress(metavariableNames, (metavariableNameA, metavariableNameB) => {
-    if (metavariableNameA !== metavariableNameB) {
+  compress(metavariableNodes, (metavariableNodeA, metavariableNodeB) => {
+    const metavariableNodeAMatchesetavariableNodeB = metavariableNodeA.match(metavariableNodeB);
+
+    if (!metavariableNodeAMatchesetavariableNodeB) {
       return true;
     }
   });
 
-  return metavariableNames;
+  return metavariableNodes;
 }