occam-verify-cli 1.0.768 → 1.0.781

package/src/element/statement.js

@@ -7,7 +7,7 @@ import { define } from "../elements";
 import { unifyStatement } from "../process/unify";
 import { validateStatements } from "../utilities/validation";
 import { instantiateStatement } from "../process/instantiate";
-import { reconcile, instantiate } from "../utilities/context";
+import { join, reconcile, instantiate } from "../utilities/context";
 
 const { backwardsSome } = arrayUtilities;
 
@@ -184,7 +184,7 @@ export default define(class Statement extends Element {
     return frameContained;
   }
 
-  validate(stated, context) {
+  validate(context) {
     let statement = null;
 
     const statementString = this.getString();  ///
@@ -200,7 +200,7 @@ export default define(class Statement extends Element {
     } else {
       const validates = validateStatements.some((validateStatement) => {
         const statement = this, ///
-              statementValidates = validateStatement(statement, stated, context);
+              statementValidates = validateStatement(statement, context);
 
         if (statementValidates) {
           return true;
@@ -244,36 +244,33 @@ export default define(class Statement extends Element {
     return subproofUnifies;
   }
 
-  unifyDeduction(deduction, generalContext, specificContext) {
+  unifyDeduction(deduction, context) {
     let deductionUnifies = false;
 
     const statementString = this.getString(),  ///
           deductionString = deduction.getString(),
-          deductionStatement = deduction.getStatement(),
-          deductionStatementString = deductionStatement.getString();
+          deductionContext = deduction.getContext(),
+          deductionStatement = deduction.getStatement();
 
-    let context;
+    context.trace(`Unifying the '${deductionString}' deduction with the '${statementString}' statement...`);
 
-    context = specificContext;  ///
+    const generalContext = context, ///
+          specificContext = deductionContext;  ///
 
-    context.trace(`Unifying the '${deductionString}' deduction's '${deductionStatementString}' statement with the '${statementString}' statement...`);
+    join((specificContext) => {
+      reconcile((specificContext) => {
+        const deductionStatementUnifies = this.unifyStatement(deductionStatement, generalContext, specificContext);
 
-    context = deduction.getContext();
+        if (deductionStatementUnifies) {
+          specificContext.commit(context);
 
-    specificContext = context;  ///
-
-    reconcile((specificContext) => {
-      const deductionStatementUnfies = this.unifyStatement(deductionStatement, generalContext, specificContext);
-
-      if (deductionStatementUnfies) {
-        specificContext.commit();
-
-        deductionUnifies = true;
-      }
-    }, specificContext);
+          deductionUnifies = true;
+        }
+      }, specificContext);
+    }, specificContext, context);
 
     if (deductionUnifies) {
-      context.debug(`...unified the '${deductionString}' deduction's '${deductionStatementString}' statement with the '${statementString}' statement.`);
+      context.debug(`...unified the '${deductionString}' deduction with the '${statementString}' statement.`);
     }
 
     return deductionUnifies;
@@ -338,41 +335,39 @@ export default define(class Statement extends Element {
     return unifiesIndependently;
   }
 
-  unifyTopLevelMetaAssertion(topLevelMetaAssertion, generalContext, specificContext) {
-    let topLevelMetaAssertionUnifies = false;
+  unifyTopLevelMetaAssertion(topLevelMetaAssertion, context) {
+    let topLevelAssertionUnifies = false;
 
-    const context = specificContext,  ///
-          statementString = this.getString(), ///
+    const statementString = this.getString(), ///
           topLevelMetaAssertionString = topLevelMetaAssertion.getString();
 
     context.trace(`Unifying the '${topLevelMetaAssertionString}' top level meta-assertion with the '${statementString}' statement...`);
 
-    const topLevelMetaAssertionUnconditional = topLevelMetaAssertion.isUnconditional();
+    const unconditional = topLevelMetaAssertion.isUnconditional();
 
-    if (topLevelMetaAssertionUnconditional) {
+    if (unconditional) {
       const deduction = topLevelMetaAssertion.getDeduction(),
-            deductionUnifies = this.unifyDeduction(deduction, generalContext, specificContext);
+            deductionUnifies = this.unifyDeduction(deduction, context);
 
       if (deductionUnifies) {
-        topLevelMetaAssertionUnifies = true;
+        topLevelAssertionUnifies = true;
       }
     } else {
       const statementNode = this.getStatementNode(),
             subproofAssertionNode = statementNode.getSubproofAssertionNode();
 
       if (subproofAssertionNode !== null) {
-        const context = generalContext, ///
-              subproofAssertion = context.findAssertionByAssertionNode(subproofAssertionNode);
+        const subproofAssertion = context.findAssertionByAssertionNode(subproofAssertionNode);
 
-        topLevelMetaAssertionUnifies = subproofAssertion.unifyTopLevelMetaAssertion(topLevelMetaAssertion, generalContext, specificContext);
+        topLevelAssertionUnifies = subproofAssertion.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
       }
     }
 
-    if (topLevelMetaAssertionUnifies) {
+    if (topLevelAssertionUnifies) {
       context.debug(`...unified the '${topLevelMetaAssertionString}' top level meta-assertion with the '${statementString}' statement.`);
     }
 
-    return topLevelMetaAssertionUnifies;
+    return topLevelAssertionUnifies;
   }
 
   toJSON() {

package/src/element/subproof.js

@@ -121,7 +121,7 @@ export default define(class Subproof extends Element {
     context.trace(`Unifying the '${subproofString}' subproof with the '${satisfiesAssertionString}' satisfies assertion...`)
 
     const reference = satisfiesAssertion.getReference(),
-          axiom = context.findAxiomByReference(reference, context);
+          axiom = context.findAxiomByReference(reference);
 
     if (axiom !== null) {
       const axiomSatisfiable = axiom.isSatisfiable();

package/src/element/substitution/frame.js

@@ -4,7 +4,7 @@ import Substitution from "../substitution";
 
 import { define } from "../../elements";
 import { instantiateFrameSubstitution } from "../../process/instantiate";
-import { instantiate, sanitisedContextFromContext } from "../../utilities/context";
+import { descend, simplify, instantiate } from "../../utilities/context";
 import { frameSubstitutionStringFromFrameAndMetavariable } from "../../utilities/string";
 import { frameSubstitutionFromStatementNode, frameSubstitutionFromFrameSubstitutionNode } from "../../utilities/element";
 
@@ -123,14 +123,15 @@ export default define(class FrameSubstitution extends Substitution {
     const targetFrameSingular = this.targetFrame.isSingular();
 
     if (targetFrameSingular) {
-      const stated = true,
-            tragetFrame = this.targetFrame.validate(stated, context);
+      descend((context) => {
+        const tragetFrame = this.targetFrame.validate(context);
 
-      if (tragetFrame !== null) {
-        this.targetFrame = tragetFrame;
+        if (tragetFrame !== null) {
+          this.targetFrame = tragetFrame;
 
-        targetFrameValidates = true;
-      }
+          targetFrameValidates = true;
+        }
+      }, context);
     } else {
       context.debug(`The '${frameSubstitutionString}' frame substitution's '${targetFrameString}' target frame is not singular.`);
     }
@@ -151,14 +152,15 @@ export default define(class FrameSubstitution extends Substitution {
 
     context.trace(`Validating the '${frameSubstitutionString}' frame substitution's '${replacementFrameString}' replacement frame...`);
 
-    const stated = true,
-          replacementFrame = this.replacementFrame.validate(stated, context);
+    descend((context) => {
+      const replacementFrame = this.replacementFrame.validate(context);
 
-    if (replacementFrame !== null) {
-      this.replacementFrame = replacementFrame;
+      if (replacementFrame !== null) {
+        this.replacementFrame = replacementFrame;
 
-      replacementFrameValidates = true;
-    }
+        replacementFrameValidates = true;
+      }
+    }, context);
 
     if (replacementFrameValidates) {
       context.debug(`...validated the '${frameSubstitutionString}' frame substitution's '${replacementFrameString}' replacement frame.`);
@@ -175,7 +177,7 @@ export default define(class FrameSubstitution extends Substitution {
     const { name } = json;
 
     if (this.name === name) {
-      frameSubstitutionn = instantiate((context) => {
+      instantiate((context) => {
         const { string } = json,
               frameSubstitutionNode = instantiateFrameSubstitution(string, context),
               node = frameSubstitutionNode,  ///
@@ -184,9 +186,7 @@ export default define(class FrameSubstitution extends Substitution {
 
         context = null;
 
-        const frameSubstitutionn = new FrameSubstitution(context, string, node, targetFrame, replacementFrame);
-
-        return frameSubstitutionn;
+        frameSubstitutionn = new FrameSubstitution(context, string, node, targetFrame, replacementFrame);
       }, context);
     }
 
@@ -201,18 +201,19 @@ export default define(class FrameSubstitution extends Substitution {
   }
 
   static fromFrameAndMetavariable(frame, metavariable, context) {
-    const santisedContext = sanitisedContextFromContext(context);
-
-    context = santisedContext;  ///
+    let frameSubstitution
 
-    return instantiate((context) => {
-      const frameSubstitutionString = frameSubstitutionStringFromFrameAndMetavariable(frame, metavariable),
-            string = frameSubstitutionString,  ///
-            frameSubstitutionNode = instantiateFrameSubstitution(string, context),
-            frameSubstitution = frameSubstitutionFromFrameSubstitutionNode(frameSubstitutionNode, context);
+    simplify((context) => {
+      instantiate((context) => {
+        const frameSubstitutionString = frameSubstitutionStringFromFrameAndMetavariable(frame, metavariable),
+              string = frameSubstitutionString,  ///
+              frameSubstitutionNode = instantiateFrameSubstitution(string, context);
 
-      return frameSubstitution;
+        frameSubstitution = frameSubstitutionFromFrameSubstitutionNode(frameSubstitutionNode, context);
+      }, context);
     }, context);
+
+    return frameSubstitution;
   }
 });
 

package/src/element/substitution/metaLevel.js

@@ -4,10 +4,9 @@ import Substitution from "../substitution";
 
 import { define } from "../../elements";
 import { instantiateMetaLevelSubstitution } from "../../process/instantiate";
-import { instantiate, sanitisedContextFromContext } from "../../utilities/context";
 import { metaLevelSubstitutionFromMetaLevelSubstitutionNode } from "../../utilities/element";
 import { metaLevelSubstitutionStringFromStatementAndReference } from "../../utilities/string";
-import { ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../../utilities/json";
+import { descend, simplify, serialise, unserialise, instantiate } from "../../utilities/context";
 
 export default define(class MetaLevelSubstitution extends Substitution {
   constructor(context, string, node, targetReference, replacementStatement) {
@@ -132,12 +131,13 @@ export default define(class MetaLevelSubstitution extends Substitution {
 
     context.trace(`Validating the '${metaLevelSubstitutionString}' meta-level substitution's '${replacementStatementString}' replacement statement...`);
 
-    const stated = true,
-      replacementStatement = this.replacementStatement.validate(stated, context);
+    descend((context) => {
+      const replacementStatement = this.replacementStatement.validate(context);
 
-    if (replacementStatement !== null) {
-      replacementStatementValidates = true;
-    }
+      if (replacementStatement !== null) {
+        replacementStatementValidates = true;
+      }
+    }, context);
 
     if (replacementStatementValidates) {
       context.debug(`...validated the '${metaLevelSubstitutionString}' meta-level substitution's '${replacementStatementString}' replacement statement.`);
@@ -147,57 +147,53 @@ export default define(class MetaLevelSubstitution extends Substitution {
   }
 
   toJSON() {
-    let context;
-
-    context = this.getContext();
-
-    const ephemeralContext = context, ///
-          ephemeralContextJSON = ephemeralContextToEphemeralContextJSON(ephemeralContext),
-          contextJSON = ephemeralContextJSON; ///
-
-    context = contextJSON;  ///
+    const context = this.getContext();
 
-    const string = this.getString(),
-          json = {
-            context,
-            string
-          };
+    return serialise((context) => {
+      const string = this.getString(),
+            json = {
+              context,
+              string
+            };
 
-    return json;
+      return json;
+    }, context);
   }
 
   static name = "MetaLevelSubstitution";
 
   static fromJSON(json, context) {
-    const ephemeralContext = ephemeralContextFromJSON(json, context);
+    let metaLevelSubstitution;
 
-    context = ephemeralContext; ///
+    unserialise((json, context) => {
+      instantiate((context) => {
+        const { string } = json,
+              metaLevelSubstitutionNode = instantiateMetaLevelSubstitution(string, context),
+              node = metaLevelSubstitutionNode, ///
+              targetReference = targetReferenceFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context),
+              replacementStatement = replacementStatementFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context);
 
-    return instantiate((context) => {
-      const { string } = json,
-            metaLevelSubstitutionNode = instantiateMetaLevelSubstitution(string, context),
-            node = metaLevelSubstitutionNode, ///
-            targetReference = targetReferenceFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context),
-            replacementStatement = replacementStatementFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context),
-            metaLevelSubstitution = new MetaLevelSubstitution(context, string, node, targetReference, replacementStatement);
+        metaLevelSubstitution = new MetaLevelSubstitution(context, string, node, targetReference, replacementStatement);
+      }, context);
+    }, json, context);
 
-      return metaLevelSubstitution;
-    }, context);
+    return metaLevelSubstitution;
   }
 
   static fromStatementAndReference(statement, reference, context) {
-    const santisedContext = sanitisedContextFromContext(context);
+    let metaLevelSubstitution;
 
-    context = santisedContext;  ///
+    simplify((context) => {
+      instantiate((context) => {
+        const metaLevelSubstitutionString = metaLevelSubstitutionStringFromStatementAndReference(statement, reference),
+              string = metaLevelSubstitutionString,  ///
+              metaLevelSubstitutionNode = instantiateMetaLevelSubstitution(string, context);
 
-    return instantiate((context) => {
-      const metaLevelSubstitutionString = metaLevelSubstitutionStringFromStatementAndReference(statement, reference),
-            string = metaLevelSubstitutionString,  ///
-            metaLevelSubstitutionNode = instantiateMetaLevelSubstitution(string, context),
-            metaLevelSubstitution = metaLevelSubstitutionFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context);
-
-      return metaLevelSubstitution;
+        metaLevelSubstitution = metaLevelSubstitutionFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context);
+      }, context);
     }, context);
+
+    return metaLevelSubstitution;
   }
 });
 

package/src/element/substitution/reference.js

@@ -3,8 +3,8 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
+import { simplify, instantiate } from "../../utilities/context";
 import { instantiateReferenceSubstitution } from "../../process/instantiate";
-import { instantiate, sanitisedContextFromContext } from "../../utilities/context";
 import { referenceSubstitutionFromReferenceSubstitutionNode } from "../../utilities/element";
 import { referenceSubstitutionStringFromReferenceAndMetavariable } from "../../utilities/string";
 
@@ -163,7 +163,7 @@ export default define(class ReferenceSubstitution extends Substitution {
     const { name } = json;
 
     if (this.name === name) {
-      referenceSubstitutionn = instantiate((context) => {
+      instantiate((context) => {
         const { string } = json,
               referenceSubstitutionNode = instantiateReferenceSubstitution(string, context),
               node = referenceSubstitutionNode,  ///
@@ -172,9 +172,7 @@ export default define(class ReferenceSubstitution extends Substitution {
 
         context = null;
 
-        const referenceSubstitutionn = new ReferenceSubstitution(context, string, node, targetReference, replacementReference);
-
-        return referenceSubstitutionn;
+        referenceSubstitutionn = new ReferenceSubstitution(context, string, node, targetReference, replacementReference);
       }, context);
     }
 
@@ -182,18 +180,19 @@ export default define(class ReferenceSubstitution extends Substitution {
   }
 
   static fromReferenceAndMetavariable(reference, metavariable, context) {
-    const santisedContext = sanitisedContextFromContext(context);
-
-    context = santisedContext;  ///
+    let referenceSubstitution;
 
-    return instantiate((context) => {
-      const referenceSubstitutionString = referenceSubstitutionStringFromReferenceAndMetavariable(reference, metavariable),
-            string = referenceSubstitutionString,  ///
-            referenceSubstitutionNode = instantiateReferenceSubstitution(string, context),
-            referenceSubstitution = referenceSubstitutionFromReferenceSubstitutionNode(referenceSubstitutionNode, context);
+    simplify((context) => {
+      instantiate((context) => {
+        const referenceSubstitutionString = referenceSubstitutionStringFromReferenceAndMetavariable(reference, metavariable),
+              string = referenceSubstitutionString,  ///
+              referenceSubstitutionNode = instantiateReferenceSubstitution(string, context);
 
-      return referenceSubstitution;
+        referenceSubstitution = referenceSubstitutionFromReferenceSubstitutionNode(referenceSubstitutionNode, context);
+      }, context);
     }, context);
+
+    return referenceSubstitution;
   }
 });
 

package/src/element/substitution/statement.js

@@ -6,8 +6,8 @@ import { define } from "../../elements";
 import { unifySubstitution } from "../../process/unify";
 import { stripBracketsFromStatement } from "../../utilities/brackets";
 import { instantiateStatementSubstitution } from "../../process/instantiate";
+import { join, simplify, descend, reconcile, instantiate } from "../../utilities/context";
 import { statementSubstitutionFromStatementSubstitutionNode } from "../../utilities/element";
-import { join, reconcile, instantiate, sanitisedContextFromContext } from "../../utilities/context";
 import { statementSubstitutionStringFromStatementAndMetavariable, statementSubstitutionStringFromStatementMetavariableAndSubstitution } from "../../utilities/string";
 
 export default define(class StatementSubstitution extends Substitution {
@@ -158,12 +158,13 @@ export default define(class StatementSubstitution extends Substitution {
     const targetStatementSingular = this.targetStatement.isSingular();
 
     if (targetStatementSingular) {
-      const stated = true,
-            targetStatement = this.targetStatement.validate(stated, context);
+      descend((context) => {
+        const targetStatement = this.targetStatement.validate(context);
 
-      if (targetStatement !== null) {
-        targetStatementValidates = true;
-      }
+        if (targetStatement !== null) {
+          targetStatementValidates = true;
+        }
+      }, context);
     } else {
       context.debug(`The '${statementSubstitutionString}' statement substitution's '${targetStatementString}' target statement is not singular.`);
     }
@@ -184,12 +185,13 @@ export default define(class StatementSubstitution extends Substitution {
 
     context.trace(`Validating the '${statementSubstitutionString}' statement substitution's '${replacementStatementString}' replacement statement...`);
 
-    const stated = true,
-          replacementStatement = this.replacementStatement.validate(stated, context);
+    descend((context) => {
+      const replacementStatement = this.replacementStatement.validate(context);
 
-    if (replacementStatement !== null) {
-      replacementStatementValidates = true;
-    }
+      if (replacementStatement !== null) {
+        replacementStatementValidates = true;
+      }
+    }, context);
 
     if (replacementStatementValidates) {
       context.debug(`...validated the '${statementSubstitutionString}' statement substitution's '${replacementStatementString}' replacement statement.`);
@@ -344,7 +346,7 @@ export default define(class StatementSubstitution extends Substitution {
     const { name } = json;
 
     if (this.name === name) {
-      statementSubstitutionn = instantiate((context) => {
+      instantiate((context) => {
         const { string } = json,
               statementSubstitutionNode = instantiateStatementSubstitution(string, context),
               node = statementSubstitutionNode,  ///
@@ -353,9 +355,7 @@ export default define(class StatementSubstitution extends Substitution {
 
         context = null;
 
-        const statementSubstitutionn = new StatementSubstitution(context, string, node, targetStatement, replacementStatement);
-
-        return statementSubstitutionn;
+        statementSubstitutionn = new StatementSubstitution(context, string, node, targetStatement, replacementStatement);
       }, context);
     }
 
@@ -365,35 +365,37 @@ export default define(class StatementSubstitution extends Substitution {
   static fromStatementAndMetavariable(statement, metavariable, context) {
     statement = stripBracketsFromStatement(statement, context); ///
 
-    const santisedContext = sanitisedContextFromContext(context);
-
-    context = santisedContext;  ///
+    let statementSubstitution;
 
-    return instantiate((context) => {
-      const statementSubstitutionString = statementSubstitutionStringFromStatementAndMetavariable(statement, metavariable, context),
-            string = statementSubstitutionString, ///
-            statementSubstitutionNode = instantiateStatementSubstitution(string, context),
-            statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context);
+    simplify((context) => {
+      instantiate((context) => {
+        const statementSubstitutionString = statementSubstitutionStringFromStatementAndMetavariable(statement, metavariable, context),
+              string = statementSubstitutionString, ///
+              statementSubstitutionNode = instantiateStatementSubstitution(string, context);
 
-      return statementSubstitution;
+        statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context);
+      }, context);
     }, context);
+
+    return statementSubstitution;
   }
 
   static fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context) {
     statement = stripBracketsFromStatement(statement, context); ///
 
-    const santisedContext = sanitisedContextFromContext(context);
-
-    context = santisedContext;  ///
+    let statementSubstitution;
 
-    return instantiate((context) => {
-      const statementSubstitutionString = statementSubstitutionStringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution),
-            string = statementSubstitutionString, ///
-            statementSubstitutionNode = instantiateStatementSubstitution(string, context),
-            statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context);
+    simplify((context) => {
+      instantiate((context) => {
+        const statementSubstitutionString = statementSubstitutionStringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution),
+              string = statementSubstitutionString, ///
+              statementSubstitutionNode = instantiateStatementSubstitution(string, context);
 
-      return statementSubstitution;
+        statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context);
+      }, context);
     }, context);
+
+    return statementSubstitution;
   }
 });
 

package/src/element/substitution/term.js

@@ -3,9 +3,9 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
+import { simplify, instantiate } from "../../utilities/context";
 import { stripBracketsFromTerm } from "../../utilities/brackets";
 import { instantiateTermSubstitution } from "../../process/instantiate";
-import { instantiate, sanitisedContextFromContext } from "../../utilities/context";
 import { termSubstitutionStringFromTermAndVariable } from "../../utilities/string";
 import { termSubstitutionFromStatementNode, termSubstitutionFromTermSubstitutionNode } from "../../utilities/element";
 
@@ -184,7 +184,7 @@ export default define(class TermSubstitution extends Substitution {
     const { name } = json;
 
     if (this.name === name) {
-      termSubstitutionn = instantiate((context) => {
+      instantiate((context) => {
         const { string } = json,
               termSubstitutionNode = instantiateTermSubstitution(string, context),
               node = termSubstitutionNode,  ///
@@ -193,9 +193,7 @@ export default define(class TermSubstitution extends Substitution {
 
         context = null;
 
-        const termSubstitutionn = new TermSubstitution(context, string, node, targetTerm, replacementTerm);
-
-        return termSubstitutionn;
+        termSubstitutionn = new TermSubstitution(context, string, node, targetTerm, replacementTerm);
       }, context);
     }
 
@@ -212,18 +210,19 @@ export default define(class TermSubstitution extends Substitution {
   static fromTermAndVariable(term, variable, context) {
     term = stripBracketsFromTerm(term, context); ///
 
-    const santisedContext = sanitisedContextFromContext(context);
-
-    context = santisedContext;  ///
+    let termSubstitution;
 
-    return instantiate((context) => {
-      const termSubstitutionString = termSubstitutionStringFromTermAndVariable(term, variable),
-            string = termSubstitutionString,  ///
-            termSubstitutionNode = instantiateTermSubstitution(string, context),
-            termSubstitution = termSubstitutionFromTermSubstitutionNode(termSubstitutionNode, context);
+    simplify((context) => {
+      instantiate((context) => {
+        const termSubstitutionString = termSubstitutionStringFromTermAndVariable(term, variable),
+              string = termSubstitutionString,  ///
+              termSubstitutionNode = instantiateTermSubstitution(string, context);
 
-      return termSubstitution;
+        termSubstitution = termSubstitutionFromTermSubstitutionNode(termSubstitutionNode, context);
+      }, context);
     }, context);
+
+    return termSubstitution;
   }
 });