occam-verify-cli 1.0.806 → 1.0.814

package/src/element/subproof.js

@@ -3,7 +3,7 @@
 import { Element, asynchronousUtilities } from "occam-languages";
 
 import { define } from "../elements";
-import { asyncRestrict } from "../utilities/context";
+import { enclose } from "../utilities/context";
 
 const { asyncEvery } = asynchronousUtilities;
 
@@ -54,16 +54,16 @@ export default define(class Subproof extends Element {
     return proofAssertion;
   }
 
-  compareStatement(statement, context) {
-    const statementUnifies = false;
+  compareStep(step, context) {
+    const comparesToStep = false;
 
-    return statementUnifies;
+    return comparesToStep;
   }
 
   async verify(context) {
     let verifies = false;
 
-    await asyncRestrict(async (context) => {
+    await enclose(async (context) => {
       const suppositionsVerify = await this.verifySuppositions(context);
 
       if (suppositionsVerify) {

package/src/element/substitution/frame.js

@@ -9,8 +9,8 @@ import { join, ablate, descend, attempt, instantiate } from "../../utilities/con
 import { frameSubstitutionStringFromFrameAndMetavariable } from "../../utilities/string";
 
 export default define(class FrameSubstitution extends Substitution {
-  constructor(context, string, node, targetFrame, replacementFrame) {
-    super(context, string, node);
+  constructor(context, string, node, generalContext, targetFrame, replacementFrame) {
+    super(context, string, node, generalContext);
 
     this.targetFrame = targetFrame;
     this.replacementFrame = replacementFrame;
@@ -31,6 +31,8 @@ export default define(class FrameSubstitution extends Substitution {
     return frameSubstitutionNode;
   }
 
+  getMetavariableNode() { return this.targetFrame.getMetavariableNode(); }
+
   getTargetNode() {
     const targetFrameNode = this.targetFrame.getNode(),
           tergetNode = targetFrameNode; ///
@@ -45,10 +47,6 @@ export default define(class FrameSubstitution extends Substitution {
     return replacementNode;
   }
 
-  compareMetavariableName(metavariableName) { return this.targetFrame.compareMetavariableName(metavariableName); }
-
-  getMetavariableName() { return this.targetFrame.getMetavariableName(); }
-
   isTrivial() {
     const targetFrameEqualToReplacementFrame = this.targetFrame.isEqualTo(this.replacementFrame),
           trivial = targetFrameEqualToReplacementFrame; ///
@@ -56,6 +54,8 @@ export default define(class FrameSubstitution extends Substitution {
     return trivial;
   }
 
+  matchMetavariableNode(metavariableNode) { return this.targetFrame.matchMetavariableNode(metavariableNode); }
+
   compareFrame(frame, context) {
     const frameEqualToReplacementFrame = this.replacementFrame.isEqualTo(frame),
           comparedToFrame = frameEqualToReplacementFrame; ///
@@ -116,6 +116,8 @@ export default define(class FrameSubstitution extends Substitution {
 
       context.addSubstitution(substitution);
 
+      this.setGeneralContext(generalContext);
+
       context.debug(`...validated the '${frameSubstitutionString}' frame substitution.`);
     }
 
@@ -191,11 +193,12 @@ export default define(class FrameSubstitution extends Substitution {
       instantiate((context) => {
         const { string } = json,
               frameSubstitutionNode = instantiateFrameSubstitution(string, context),
-              node = frameSubstitutionNode,  ///
+              node = frameSubstitutionNode, ///
+              generalContext = generalContextFromFrameSubstitutionNode(frameSubstitutionNode, context),
               targetFrame = targetFrameFromFrameSubstitutionNode(frameSubstitutionNode, context),
               replacementFrame = replacementFrameFromFrameSubstitutionNode(frameSubstitutionNode, context);
 
-        frameSubstitutionn = new FrameSubstitution(context, string, node, targetFrame, replacementFrame);
+        frameSubstitutionn = new FrameSubstitution(context, string, node, generalContext, targetFrame, replacementFrame);
       }, context);
     }
 
@@ -246,3 +249,10 @@ function replacementFrameFromFrameSubstitutionNode(frameSubstitutionNode, contex
 
   return replacementFrame;
 }
+
+function generalContextFromFrameSubstitutionNode(frameSubstitutionNode, context) {
+  const generalContext = context; ///
+
+  return generalContext;
+}
+

package/src/element/substitution/reference.js

@@ -9,8 +9,8 @@ import { referenceSubstitutionFromReferenceSubstitutionNode } from "../../utilit
 import { referenceSubstitutionStringFromReferenceAndMetavariable } from "../../utilities/string";
 
 export default define(class ReferenceSubstitution extends Substitution {
-  constructor(context, string, node, targetReference, replacementReference) {
-    super(context, string, node);
+  constructor(context, string, node, generalContext, targetReference, replacementReference) {
+    super(context, string, node, generalContext);
 
     this.targetReference = targetReference;
     this.replacementReference = replacementReference;
@@ -45,9 +45,7 @@ export default define(class ReferenceSubstitution extends Substitution {
     return replacementNode;
   }
 
-  getMetavariableName() { return this.targetReference.getMetavariableName(); }
-
-  compareMetavariableName(metavariableName) { return this.targetReference.compareMetavariableName(metavariableName); }
+  getMetavariableNode() { return this.targetReference.getMetavariableNode(); }
 
   isTrivial() {
     const targetReferenceEqualToReplacementReference = this.targetReference.isEqualTo(this.replacementReference),
@@ -56,6 +54,8 @@ export default define(class ReferenceSubstitution extends Substitution {
     return trivial;
   }
 
+  matchMetavariableNode(metavariableNode) { return this.targetReference.matchMetavariableNode(metavariableNode); }
+
   compareReference(reference, context) {
     const referenceEqualToReplacementReference = this.replacementReference.isEqualTo(reference),
           comparedToReference = referenceEqualToReplacementReference; ///
@@ -133,6 +133,8 @@ export default define(class ReferenceSubstitution extends Substitution {
 
       context.addSubstitution(substitution);
 
+      this.setGeneralContext(generalContext);
+
       context.debug(`...validated the '${referenceSubstitutionString}' reference substitution.`);
     }
 
@@ -198,11 +200,12 @@ export default define(class ReferenceSubstitution extends Substitution {
       instantiate((context) => {
         const { string } = json,
               referenceSubstitutionNode = instantiateReferenceSubstitution(string, context),
-              node = referenceSubstitutionNode,  ///
+              node = referenceSubstitutionNode, ///
+              generalContext = generalContextFromReferenceSubstitutionNode(referenceSubstitutionNode, context),
               targetReference = targetReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context),
               replacementReference = replacementReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context);
 
-        referenceSubstitutionn = new ReferenceSubstitution(context, string, node, targetReference, replacementReference);
+        referenceSubstitutionn = new ReferenceSubstitution(context, string, node, generalContext, targetReference, replacementReference);
       }, context);
     }
 
@@ -257,3 +260,9 @@ function replacementReferenceFromReferenceSubstitutionNode(referenceSubstitution
 
   return replacementReference;
 }
+
+function generalContextFromReferenceSubstitutionNode(referenceSubstitutionNode, context) {
+  const generalContext = context; ///
+
+  return generalContext;
+}

package/src/element/substitution/statement.js

@@ -11,8 +11,8 @@ import { join, ablate, attempt, descend, reconcile, instantiate } from "../../ut
 import { statementSubstitutionStringFromStatementAndMetavariable, statementSubstitutionStringFromStatementMetavariableAndSubstitution } from "../../utilities/string";
 
 export default define(class StatementSubstitution extends Substitution {
-  constructor(context, string, node, resolved, substitution, targetStatement, replacementStatement) {
-    super(context, string, node);
+  constructor(context, string, node, generalContext, resolved, substitution, targetStatement, replacementStatement) {
+    super(context, string, node, generalContext);
 
     this.resolved = resolved;
     this.substitution = substitution;
@@ -43,8 +43,6 @@ export default define(class StatementSubstitution extends Substitution {
     return statementSubstitutionNode;
   }
 
-  getMtavariableName() { return this.targetStatement.getMtavariableName(); }
-
   getTargetNode() {
     const targetStatementNode = this.targetStatement.getNode(),
           targetNode = targetStatementNode; ///
@@ -59,15 +57,15 @@ export default define(class StatementSubstitution extends Substitution {
     return replacementNode;
   }
 
+  getMetavariableNode() { return this.targetStatement.getMetavariableNode(); }
+
   isSimple() {
     const simple = (this.substitution === null);
 
     return simple;
   }
 
-  getMetavariableName() { return this.targetStatement.getMetavariableName(); }
-
-  compareMetavariableName(metavariableName) { return this.targetStatement.compareMetavariableName(metavariableName); }
+  matchMetavariableNode(metavariableNode) { return this.targetStatement.matchMetavariableNode(metavariableNode); }
 
   compareStatement(statement, context) {
     statement = stripBracketsFromStatement(statement, context); ///
@@ -103,8 +101,6 @@ export default define(class StatementSubstitution extends Substitution {
     return comparesToSubstitution;
   }
 
-  compareMetavariable(metavariable) { return this.targetStatement.compareMetavariable(metavariable); }
-
   validate(generalContext, specificContext) {
     let statementSubstitution = null;
 
@@ -155,6 +151,8 @@ export default define(class StatementSubstitution extends Substitution {
 
       context.addSubstitution(substitution);
 
+      this.setGeneralContext(generalContext);
+
       context.debug(`...validated the '${statementSubstitutionString}' statement substitution.`);
     }
 
@@ -165,21 +163,23 @@ export default define(class StatementSubstitution extends Substitution {
     let substitutionValidates = true;
 
     if (this.substitution !== null) {
-      const context = specificContext,  ///
+      const context = generalContext,  ///
             substitutionString = this.substitution.getString(),
             statementSubstitutionString = this.getString();
 
       context.trace(`Validating the '${statementSubstitutionString}' statement substitution's '${substitutionString}' substitution...`);
 
-      const generalContext = context, ///
-            specificContext = context,  ///
-            substitution = this.substitution.validate(generalContext, specificContext);
+      descend((context) => {
+        const generalContext = context, ///
+              specificContext = context,  ///
+              substitution = this.substitution.validate(generalContext, specificContext);
 
-      if (substitution !== null) {
-        this.substitution = substitution;
+        if (substitution !== null) {
+          this.substitution = substitution;
 
-        substitutionValidates = true;
-      }
+          substitutionValidates = true;
+        }
+      }, context);
 
       if (substitutionValidates) {
         context.debug(`...validatewd the '${statementSubstitutionString}' statement substitution's '${substitutionString}' substitution.`);
@@ -243,41 +243,58 @@ export default define(class StatementSubstitution extends Substitution {
     return replacementStatementValidates;
   }
 
-  unifySubstitution(substitution, generalContext, specificContext) {
-    let substitutionUnifies;
+  unifySimpleSubstitution(simpleSubstitution, context) {
+    let simpleSubstitutionUnifies;
 
-    const context = specificContext,
-          generalSubstitution = this.substitution,  ///
-          specificSubstitution = substitution,  ///
-          generalSubstitutionString = generalSubstitution.getString(),
-          specificSubstitutionString = specificSubstitution.getString();
+    const substitutionString = this.substitution.getString(),
+          simpleSubstitutionString = simpleSubstitution.getString();
 
-    context.trace(`Unifying the '${specificSubstitutionString}' substitution with the '${generalSubstitutionString}' substitution...`);
+    context.trace(`Unifying the '${simpleSubstitutionString}' simple substitution with the '${substitutionString}' substitution...`);
 
-    reconcile((specificContext) => {
-      substitutionUnifies = unifySubstitution(generalSubstitution, specificSubstitution, generalContext, specificContext);
+    const generalSubstitution = this.substitution,  ///
+          specificSubstitution = simpleSubstitution,  ///
+          generalSubstitutionGeneralContext = generalSubstitution.getGeneralContext(),
+          generalSubstitutionSpecificContext = generalSubstitution.getSpecificContext(),
+          specificSubstitutionGeneralContext = specificSubstitution.getGeneralContext(),
+          specificSubstitutionSpecificContext = specificSubstitution.getSpecificContext();
 
-      if (substitutionUnifies) {
-        specificContext.commit();
-      }
-    }, specificContext);
+    join((specificContext) => {
+      join((generalContext) => {
+        reconcile((specificContext) => {
+          simpleSubstitutionUnifies = unifySubstitution(generalSubstitution, specificSubstitution, generalContext, specificContext);
+
+          if (simpleSubstitutionUnifies) {
+            specificContext.commit(context);
+          }
+        }, specificContext)
+      }, generalSubstitutionSpecificContext, generalSubstitutionGeneralContext);
+    }, specificSubstitutionSpecificContext, specificSubstitutionGeneralContext, context);
 
-    if (substitutionUnifies) {
-      context.trace(`...unified the '${specificSubstitutionString}' substitution with the '${generalSubstitutionString}' substitution.`);
+    if (simpleSubstitutionUnifies) {
+      context.trace(`...unified the '${simpleSubstitutionString}' simple substitution with the '${substitutionString}' substitution.`);
     }
 
-    return substitutionUnifies;
+    return simpleSubstitutionUnifies;
   }
 
-  unifyComplexSubstitution(complexSubstitution, generalContext, specificContext) {
+  unifyComplexSubstitution(complexSubstitution, context) {
     let substitution = null;
 
-    const context = specificContext, ///
-          simpleSubstitutionString = this.getString(),  ///
+    const simpleSubstitutionString = this.getString(),  ///
           complexSubstitutionString = complexSubstitution.getString();  ///
 
     context.trace(`Unifying the '${complexSubstitutionString}' complex substitution with the '${simpleSubstitutionString}' simple substitution...`);
 
+    context = complexSubstitution.getContext();
+
+    const specificContext = context;  ///
+
+    context = this.getContext();
+
+    const generalContext = context; ///
+
+    context = specificContext;  ///
+
     let simpleSubstitutionUnifies = false;
 
     reconcile((specificContext) => {
@@ -294,6 +311,8 @@ export default define(class StatementSubstitution extends Substitution {
     }, specificContext);
 
     if (substitution !== null) {
+      substitution = substitution.validate(generalContext, specificContext);
+
       simpleSubstitutionUnifies = true;
     }
 
@@ -326,52 +345,24 @@ export default define(class StatementSubstitution extends Substitution {
     return replacementStatemnentUnifies;
   }
 
-  unifyWithSimpleSubstitution(simpleSubstitution, generalContext, specificContext) {
-    let substitution;
-
-    const complexSubstitution = this, ///
-          simpleSubstitutionContext = simpleSubstitution.getContext(),
-          complexSubstitutionContext = complexSubstitution.getContext();
-
-    generalContext = simpleSubstitutionContext; ///
-
-    specificContext = complexSubstitutionContext;  ///
-
-    substitution = simpleSubstitution.unifyComplexSubstitution(complexSubstitution, generalContext, specificContext);
-
-    return substitution;
-  }
-
-  resolve(generalContext, specificContext) {
+  resolve(context) {
     let resolved = false;
 
-    const context = specificContext,  ///
-          metavariableName = this.getMetavariableName(),
-          simpleSubstitution = context.findSimpleSubstitutionByMetavariableName(metavariableName);
+    const metavariableNode = this.getMetavariableNode(),
+          simpleSubstitution = context.findSimpleSubstitutionByMetavariableNode(metavariableNode),
+          complexSubstitution = this; ///
 
     if (simpleSubstitution !== null) {
       const substitutionString = this.getString(); ///
 
       context.trace(`Resolving the ${substitutionString} substitution...`);
 
-      const substitution = this.unifyWithSimpleSubstitution(simpleSubstitution, generalContext, specificContext); ///
+      const substitution = simpleSubstitution.unifyComplexSubstitution(complexSubstitution, context);
 
       if (substitution !== null) {
-        let context;
-
-        context = substitution.getContext();
-
-        const specificContext = context;  ///
-
-        context = this.substitution.getContext();
-
-        const generalContext = context; ///
+        const simpleSubstitutionUnifies = complexSubstitution.unifySimpleSubstitution(substitution, context);
 
-        context = specificContext;  ///
-
-        const substitutionUnifies = this.unifySubstitution(substitution, generalContext, specificContext);
-
-        if (substitutionUnifies) {
+        if (simpleSubstitutionUnifies) {
           resolved = true;
         }
 
@@ -395,11 +386,14 @@ export default define(class StatementSubstitution extends Substitution {
       instantiate((context) => {
         const { string } = json,
               statementSubstitutionNode = instantiateStatementSubstitution(string, context),
-              node = statementSubstitutionNode,  ///
+              node = statementSubstitutionNode, ///
+              generalContext = generalContextFromStatementSubstitutionNode(statementSubstitutionNode, context),
+              resolved = resolvedFromStatementSubstitutionNode(statementSubstitutionNode, context),
+              substitution = substitutionFromStatementSubstitutionNode(statementSubstitutionNode, context),
               targetStatement = targetStatementFromStatementSubstitutionNode(statementSubstitutionNode, context),
               replacementStatement = replacementStatementFromStatementSubstitutionNode(statementSubstitutionNode, context);
 
-        statementSubstitutionn = new StatementSubstitution(context, string, node, targetStatement, replacementStatement);
+        statementSubstitutionn = new StatementSubstitution(context, string, node, generalContext, resolved, substitution, targetStatement, replacementStatement);
       }, context);
     }
 
@@ -456,3 +450,22 @@ function replacementStatementFromStatementSubstitutionNode(statementSubstitution
 
   return replacementStatement;
 }
+
+function resolvedFromStatementSubstitutionNode(statementSubstitutionNode, context) {
+  const resolved = true;
+
+  return resolved;
+}
+
+function substitutionFromStatementSubstitutionNode(statementSubstitutionNode, context) {
+  const substitutionNode = statementSubstitutionNode.getSubstitutionNode(),
+        substitution = context.findStatementByStatementNode(substitutionNode);
+
+  return substitution;
+}
+
+function generalContextFromStatementSubstitutionNode(statementSubstitutionNode, context) {
+  const generalContext = context; ///
+
+  return generalContext;
+}

package/src/element/substitution/term.js

@@ -10,8 +10,8 @@ import { termSubstitutionStringFromTermAndVariable } from "../../utilities/strin
 import { join, ablate, descend, attempt, instantiate } from "../../utilities/context";
 
 export default define(class TermSubstitution extends Substitution {
-  constructor(context, string, node, targetTerm, replacementTerm) {
-    super(context, string, node);
+  constructor(context, string, node, generalContext, targetTerm, replacementTerm) {
+    super(context, string, node, generalContext);
 
     this.targetTerm = targetTerm;
     this.replacementTerm = replacementTerm;
@@ -46,9 +46,7 @@ export default define(class TermSubstitution extends Substitution {
     return replacementNode;
   }
 
-  getVariableIdentifier() { return this.targetTerm.getVariableIdentifier(); }
-
-  compareVariableIdentifier(variableIdentifier) { return this.targetTerm.compareVariableIdentifier(variableIdentifier); }
+  getVariableNode() { return this.targetTerm.getVariableNode(); }
 
   isTrivial() {
     const targetTermEqualToReplacementTerm = this.targetTerm.isEqualTo(this.replacementTerm),
@@ -57,6 +55,8 @@ export default define(class TermSubstitution extends Substitution {
     return trivial;
   }
 
+  matchVariableNode(variableNode) { return this.targetTerm.matchVariableNode(variableNode); }
+
   compareTerm(term, context) {
     term = stripBracketsFromTerm(term, context); ///
 
@@ -119,6 +119,8 @@ export default define(class TermSubstitution extends Substitution {
 
       context.addSubstitution(substitution);
 
+      this.setGeneralContext(generalContext);
+
       context.debug(`...validated the '${termSubstitutionString}' term substitution.`);
     }
 
@@ -203,10 +205,11 @@ export default define(class TermSubstitution extends Substitution {
         const { string } = json,
               termSubstitutionNode = instantiateTermSubstitution(string, context),
               node = termSubstitutionNode,  ///
+              generalContext = generalContextFromTermSubstitutionNode(termSubstitutionNode, context),
               targetTerm = targetTermFromTermSubstitutionNode(termSubstitutionNode, context),
               replacementTerm = replacementTermFromTermSubstitutionNode(termSubstitutionNode, context);
 
-        termSubstitutionn = new TermSubstitution(context, string, node, targetTerm, replacementTerm);
+        termSubstitutionn = new TermSubstitution(context, string, node, generalContext, targetTerm, replacementTerm);
       }, context);
     }
 
@@ -259,3 +262,9 @@ function replacementTermFromTermSubstitutionNode(termSubstitutionNode, context)
 
   return replacementTerm;
 }
+
+function generalContextFromTermSubstitutionNode(termSubstitutionNode, context) {
+  const generalContext = context; ///
+
+  return generalContext;
+}

package/src/element/substitution.js

@@ -6,6 +6,16 @@ import { primitiveUtilities } from "occam-furtle";
 const { primitiveFromNode } =primitiveUtilities;
 
 export default class Substitution extends Element {
+  constructor(context, string, node, generalContext) {
+    super(context, string, node);
+
+    this.generalContext = generalContext;
+  }
+
+  getGeneralContext() {
+    return this.generalContext;
+  }
+
   getPrimitive(context) {
     const replacementNode = this.getReplacementNode(),
           node = replacementNode, ///
@@ -21,20 +31,15 @@ export default class Substitution extends Element {
     return substitutionNode;
   }
 
-  matchSubstitutionNode(substitutionNode) {
-    const node = substitutionNode, ///
-          nodeMatches = this.matchNode(node),
-          substitutionNodeMatches = nodeMatches; ///
+  getSpecificContext() {
+    const context = this.getContext(),
+          specificContext = context;  ///
 
-    return substitutionNodeMatches;
+    return specificContext;
   }
 
-  findValidSubstitution(context) {
-    const substitutionNode = this.getSubstitutionNode(),
-          substitution = context.findSubstitutionBySubstitutionNode(substitutionNode),
-          validSubstitution = substitution;  ///
-
-    return validSubstitution;
+  setGeneralContext(generalContext) {
+    this.generalContext = generalContext;
   }
 
   isEqualTo(substitution) {
@@ -65,58 +70,50 @@ export default class Substitution extends Element {
     return variable;
   }
 
-  getSubstitution() {
-    const substitution = null;
-
-    return substitution;
-  }
-
   getMetavariable() {
     const metavariable = null;
 
     return metavariable;
   }
 
-  getMetavariableName() {
-    const metavariableName = null;
+  getSubstitution() {
+    const substitution = null;
 
-    return metavariableName;
+    return substitution;
   }
 
-  getVariableIdentifier() {
-    const variableIdentifier = null;
+  getVariableNode() {
+    const variableNode = null;
 
-    return variableIdentifier;
+    return variableNode;
   }
 
-  isSimple() {
-    const simple = true;
+  getMetavariableNode() {
+    const metavariableNode = null;
 
-    return simple;
+    return metavariableNode;
   }
 
-  compareParameter(parameter) {
-    const comparesToParameter = false;
-
-    return comparesToParameter;
-  }
-
-  compareMetavariable(metavariable) {
-    const compaaresToMetavariable = false;
+  isSimple() {
+    const simple = true;
 
-    return compaaresToMetavariable;
+    return simple;
   }
 
-  compareMetavariableName(metavariableName) {
-    const comparesToMetavariableName = false;
+  matchSubstitutionNode(substitutionNode) {
+    const node = substitutionNode, ///
+          nodeMatches = this.matchNode(node),
+          substitutionNodeMatches = nodeMatches; ///
 
-    return comparesToMetavariableName;
+    return substitutionNodeMatches;
   }
 
-  compareVariableIdentifier(variableIdentifier) {
-    const comparesToVariableIdentifier = false;
+  findValidSubstitution(context) {
+    const substitutionNode = this.getSubstitutionNode(),
+          substitution = context.findSubstitutionBySubstitutionNode(substitutionNode),
+          validSubstitution = substitution;  ///
 
-    return comparesToVariableIdentifier;
+    return validSubstitution;
   }
 
   resolve(substitutions, generalContext, specificContext) {

package/src/element/term.js

@@ -41,14 +41,6 @@ export default define(class Term extends Element {
     return variableIdentifier;
   }
 
-  isEqualTo(term) {
-    const termNode = term.getNode(),
-          termNodeMatches = this.matchTermNode(termNode),
-          equalTo = termNodeMatches;  ///
-
-    return equalTo;
-  }
-
   isGrounded(definedVariables, context) {
     const term  = this, ///
           variables = variablesFromTerm(term, context);
@@ -129,24 +121,6 @@ export default define(class Term extends Element {
     return comparesToParamter;
   }
 
-  compareVariableIdentifier(variableIdentifier) {
-    let comparesToVariableIdentifier = false;
-
-    const singular = this.isSingular();
-
-    if (singular) {
-      const variableIdentifierA = variableIdentifier; ///
-
-      variableIdentifier = this.getVariableIdentifier();
-
-      const variableIdentifierB = variableIdentifier;
-
-      comparesToVariableIdentifier = (variableIdentifierA === variableIdentifierB);
-    }
-
-    return comparesToVariableIdentifier;
-  }
-
   findValidTerm(context) {
     const termNode = this.getTermNode(),
           term = context.findTermByTermNode(termNode),