occam-verify-cli 1.0.564 → 1.0.570

package/src/element/rule.js

@@ -3,8 +3,6 @@
 import { Element } from "occam-languages";
 import { arrayUtilities } from "necessary";
 
-import elements from "../elements";
-
 import { scope } from "../utilities/context";
 import { define } from "../elements";
 import { labelsFromJSON,
@@ -13,6 +11,7 @@ import { labelsFromJSON,
          labelsToLabelsJSON,
          premisesToPremisesJSON,
          conclusionToConclusionJSON } from "../utilities/json";
+import { subproofOrProofAssertionsStringFromSubproofOrProofAssertions } from "../utilities/string";
 
 const { reverse, extract, backwardsEvery } = arrayUtilities;
 
@@ -97,8 +96,7 @@ export default define(class Rule extends Element {
     if (this.proof === null) {
       proofVerifies = true;
     } else {
-      const { Substitutions } = elements,
-            substitutions = Substitutions.fromNothing(context);
+      const substitutions = [];
 
       proofVerifies = this.proof.verify(substitutions, this.conclusion, context);
     }
@@ -106,30 +104,38 @@ export default define(class Rule extends Element {
     return proofVerifies;
   }
 
-  unifyStatementWithConclusion(statement, substitutions, context) {
+  unifyStatementWithConclusion(statement, context) {
     let statementUnifiesWithConclusion = false;
 
-    const statementUnifies = this.conclusion.unifyStatement(statement, substitutions, context);
+    const ruleString = this.getString(),
+          statementString = statement.getString(),
+          conclusionString = this.conclusion.getString();
+
+    context.trace(`Unifying the '${statementString}' statement with the '${ruleString}' rule's '${conclusionString}' conclusion...`);
+
+    const statementUnifies = this.conclusion.unifyStatement(statement, context);
 
     if (statementUnifies) {
       statementUnifiesWithConclusion = true;
     }
 
+    if (statementUnifiesWithConclusion) {
+      context.debug(`...unified the '${statementString}' statement with the '${ruleString}' rule's '${conclusionString}' conclusion.`);
+    }
+
     return statementUnifiesWithConclusion;
   }
 
   unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, context) {
     let statementAndSubproofOrProofAssertionsUnify = false;
 
-    const { Substitutions } = elements,
-          substitutions = Substitutions.fromNothing(context),
-          statementUnifiesWithConclusion = this.unifyStatementWithConclusion(statement, substitutions, context);
+    const statementUnifiesWithConclusion = this.unifyStatementWithConclusion(statement, context);
 
     if (statementUnifiesWithConclusion) {
-      const subproofOrProofAssertionsUnifiesWithPremises = this.unifySubproofOrProofAssertionsWithPremises(subproofOrProofAssertions, substitutions, context);
+      const subproofOrProofAssertionsUnifiesWithPremises = this.unifySubproofOrProofAssertionsWithPremises(subproofOrProofAssertions, context);
 
       if (subproofOrProofAssertionsUnifiesWithPremises) {
-        const substitutionsResolved = substitutions.areResolved();
+        const substitutionsResolved = context.areSubstitutionsResolved();
 
         if (substitutionsResolved) {
           statementAndSubproofOrProofAssertionsUnify = true;
@@ -140,12 +146,12 @@ export default define(class Rule extends Element {
     return statementAndSubproofOrProofAssertionsUnify;
   }
 
-  unifySubproofOrProofAssertionsWithPremise(subproofOrProofAssertions, premise, substitutions, context) {
+  unifySubproofOrProofAssertionsWithPremise(subproofOrProofAssertions, premise, context) {
     let subproofOrProofAssertionsUnifiesWithPremise = false;
 
     if (!subproofOrProofAssertionsUnifiesWithPremise) {
       const subproofOrProofAssertion = extract(subproofOrProofAssertions, (subproofOrProofAssertion) => {
-        const subproofOrProofAssertionUnifies = premise.unifySubproofOrProofAssertion(subproofOrProofAssertion, substitutions, context);
+        const subproofOrProofAssertionUnifies = premise.unifySubproofOrProofAssertion(subproofOrProofAssertion, context);
 
         if (subproofOrProofAssertionUnifies) {
           return true;
@@ -158,7 +164,7 @@ export default define(class Rule extends Element {
     }
 
     if (!subproofOrProofAssertionsUnifiesWithPremise) {
-      const premiseUnifiesIndependently = premise.unifyIndependently(substitutions, context);
+      const premiseUnifiesIndependently = premise.unifyIndependently(context);
 
       if (premiseUnifiesIndependently) {
         subproofOrProofAssertionsUnifiesWithPremise = true;
@@ -168,11 +174,13 @@ export default define(class Rule extends Element {
     return subproofOrProofAssertionsUnifiesWithPremise;
   }
 
-  unifySubproofOrProofAssertionsWithPremises(subproofOrProofAssertions, substitutions, context) {
+  unifySubproofOrProofAssertionsWithPremises(subproofOrProofAssertions, context) {
+    let subproofOrProofAssertionsUnifiesWithPremises;
+
     subproofOrProofAssertions = reverse(subproofOrProofAssertions); ///
 
-    const subproofOrProofAssertionsUnifiesWithPremises = backwardsEvery(this.premises, (premise) => {
-      const stepUnifiesWithPremise = this.unifySubproofOrProofAssertionsWithPremise(subproofOrProofAssertions, premise, substitutions, context);
+    subproofOrProofAssertionsUnifiesWithPremises = backwardsEvery(this.premises, (premise) => {
+      const stepUnifiesWithPremise = this.unifySubproofOrProofAssertionsWithPremise(subproofOrProofAssertions, premise, context);
 
       if (stepUnifiesWithPremise) {
         return true;

package/src/element/statement.js

@@ -17,7 +17,8 @@ export default define(class Statement extends Element {
 
   isSingular() {
     const node = this.getNode(),
-          singular = node.isSingular();
+          statementNode = node, ///
+          singular = statementNode.isSingular();
 
     return singular;
   }
@@ -106,10 +107,12 @@ export default define(class Statement extends Element {
   }
 
   isEqualTo(statement) {
-    const node = this.getNode(),
-          statementNode = statement.getNode(),
-          nodeMatchesStatementNode = node.match(statementNode),
-          equalTo = nodeMatchesStatementNode; ///
+    const statementA = this, ///
+          statementB = statement, ///
+          statementANode = statementA.getNode(),
+          statementBNode = statementB.getNode(),
+          statementANodeMatchesStatementBNode = statementANode.match(statementBNode),
+          equalTo = statementANodeMatchesStatementBNode; ///
 
     return equalTo;
   }
@@ -223,7 +226,7 @@ export default define(class Statement extends Element {
     return subproofUnifies;
   }
 
-  unifyStatement(statement, substitutions, generalContext, specificContext) {
+  unifyStatement(statement, generalContext, specificContext) {
     let statementUnifies;
 
     const context = specificContext,  ///
@@ -234,7 +237,7 @@ export default define(class Statement extends Element {
 
     context.trace(`Unifying the '${specificStatementString}' statement with the '${generalStatementString}' statement...`);
 
-    statementUnifies = unifyStatement(generalStatement, specificStatement, substitutions, generalContext, specificContext);
+    statementUnifies = unifyStatement(generalStatement, specificStatement, generalContext, specificContext);
 
     if (statementUnifies) {
       context.debug(`...unified the '${specificStatementString}' statement with the '${generalStatementString}' statement.`);

package/src/element/subproof.js

@@ -90,9 +90,8 @@ export default define(class Subproof extends Element {
       const axiomSatisfiable = axiom.isSatisfiable();
 
       if (axiomSatisfiable) {
-        const { Substitutions } = elements,
-              subproof = this,  ///
-              substitutions = Substitutions.fromNothing(context),
+        const subproof = this,  ///
+              substitutions = [],
               statementUnifies = axiom.unifySubproof(subproof, substitutions, context);
 
         if (statementUnifies) {

package/src/element/substitution/frame.js

@@ -149,8 +149,6 @@ export default define(class FrameSubstitution extends Substitution {
             frameSubstitutionNode = instantiateFrameSubstitution(string, context),
             frameSubstitution = frameSubstitutionFromFrameSubstitutionNode(frameSubstitutionNode, context);
 
-      frameSubstitution.validate(context);
-
       return frameSubstitution;
     }, context);
   }

package/src/element/substitution/reference.js

@@ -136,8 +136,6 @@ export default define(class ReferenceSubstitution extends Substitution {
             referenceSubstitutionNode = instantiateReferenceSubstitution(string, context),
             referenceSubstitution = referenceSubstitutionFromReferenceSubstitutionNode(referenceSubstitutionNode, context);
 
-      referenceSubstitution.validate(context);
-
       return referenceSubstitution;
     }, context);
   }

package/src/element/substitution/statement.js

@@ -1,6 +1,5 @@
 "use strict";
 
-import elements from "../../elements";
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
@@ -182,8 +181,7 @@ export default define(class StatementSubstitution extends Substitution {
 
     context = specificContext;  ///
 
-    const { Substitutions } = elements,
-          substitutions = Substitutions.fromNothing(context);
+    const substitutions = [];
 
     statementUnifies = this.replacementStatement.unifyStatement(statement, substitutions, generalContext, specificContext);
 
@@ -294,8 +292,6 @@ export default define(class StatementSubstitution extends Substitution {
             statementSubstitutionNode = instantiateStatementSubstitution(string, context),
             statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context);
 
-      statementSubstitution.validate(context);
-
       return statementSubstitution;
     }, context);
   }
@@ -309,8 +305,6 @@ export default define(class StatementSubstitution extends Substitution {
             statementSubstitutionNode = instantiateStatementSubstitution(string, context),
             statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, substitution, context);
 
-      statementSubstitution.validate(context);
-
       return statementSubstitution;
     }, context);
   }

package/src/element/substitution/term.js

@@ -156,8 +156,6 @@ export default define(class TermSubstitution extends Substitution {
             termSubstitutionNode = instantiateTermSubstitution(string, context),
             termSubstitution = termSubstitutionFromTermSubstitutionNode(termSubstitutionNode, context);
 
-      termSubstitution.validate(context);
-
       return termSubstitution;
     }, context);
   }

package/src/element/substitution.js

@@ -50,6 +50,17 @@ export default class Substitution extends Element {
     return metavariableEqualToMetavariable;
   }
 
+  isEqualTo(substitution) {
+    const substitutionA = this, ///
+          substitutionB = substitution, ///
+          substitutionANode = substitutionA.getNode(),
+          substitutionBNode = substitutionB.getNode(),
+          substitutionANodeMatchesSubstitutionBNode = substitutionANode.match(substitutionBNode),
+          equalTo = substitutionANodeMatchesSubstitutionBNode; ///
+
+    return equalTo;
+  }
+
   compareTerm(term, context) {
     const comparesToTerm = false;
 

package/src/element/substitutions.js

@@ -77,8 +77,6 @@ export default define(class Substitutions extends Element {
 
   mapSubstitution(callback) { return this.array.map(callback); }
 
-  findSubstitution(callback) { return this.array.find(callback) }
-
   someSubstitution(callback) { return this.array.some(callback); }
 
   everySubstitution(callback) { return this.array.every(callback); }
@@ -136,23 +134,6 @@ export default define(class Substitutions extends Element {
     return substitutions;
   }
 
-  findSimpleSubstitutionByMetavariable(metavariable) {
-    const simpleSubstitution = this.findSubstitution((substitution) => {
-      const substitutionSimple = substitution.isSimple();
-
-      if (substitutionSimple) {
-        const simpleSubstitution = substitution,  ///
-              simpleSubstitutionMetavariableEqualToMetavariable = simpleSubstitution.isMetavariableEqualToMetavariable(metavariable);
-
-        if (simpleSubstitutionMetavariableEqualToMetavariable) {
-          return true;
-        }
-      }
-    }) || null;
-
-    return simpleSubstitution;
-  }
-
   findComplexSubstitutionsByMetavariable(metavariable) {
     const complexSubstitutions = this.findSubstitutions((substitution) => {
       const substitutionComplex = substitution.isComplex();
@@ -170,25 +151,6 @@ export default define(class Substitutions extends Element {
     return complexSubstitutions;
   }
 
-  findSubstitutionByMetavariableAndSubstitution(metavariable, substitution) {
-    const substitutionA = substitution; ///
-
-    substitution = this.findSubstitution((substitution) => {  ///
-      const substitutionMetavariableEqualToMetavariable = substitution.isMetavariableEqualToMetavariable(metavariable);
-
-      if (substitutionMetavariableEqualToMetavariable) {
-        const substitutionB = substitution, ///
-              substitutionBSubstitutionComparesToSubstitutionA = substitutionB.compareSubstitution(substitutionA);
-
-        if (substitutionBSubstitutionComparesToSubstitutionA) {
-          return true;
-        }
-      }
-    }) || null;
-
-    return substitution;
-  }
-
   isSubstitutionPresentByVariable(variable) {
     const substitution = this.findSubstitutionByVariable(variable),
           substitutionPresent = (substitution !== null);
@@ -196,21 +158,6 @@ export default define(class Substitutions extends Element {
     return substitutionPresent;
   }
 
-  isSimpleSubstitutionPresentByMetavariable(metavariable) {
-    const simpleSubstitution = this.findSimpleSubstitutionByMetavariable(metavariable),
-          simpleSubstitutionPresent = (simpleSubstitution !== null);
-
-    return simpleSubstitutionPresent;
-  }
-
-  isSubstitutionPresentByMetavariableAndSubstitution(metavariable, substitution) {
-    substitution = this.findSubstitutionByMetavariableAndSubstitution(metavariable, substitution);  ///
-
-    const substitutionPresent = (substitution !== null);
-
-    return substitutionPresent;
-  }
-
   addSubstitution(substitution, context) {
     const substitutionString = substitution.getString(),
           substitutionsString = this.asString();  ///

package/src/element/term.js

@@ -26,7 +26,8 @@ export default define(class Term extends Element {
 
   isSingular() {
     const node = this.getNode(),
-          singular = node.isSingular();
+          termNode = node,  ///
+          singular = termNode.isSingular();
 
     return singular;
   }
@@ -76,10 +77,12 @@ export default define(class Term extends Element {
   }
 
   isEqualTo(term) {
-    const node = this.getNode(),
-          termNode = term.getNode(),
-          nodeMatchesTermNode = node.match(termNode),
-          equalTo = nodeMatchesTermNode; ///
+    const termA = this, ///
+          termB = term, ///
+          termANode = termA.getNode(),
+          termBNode = termB.getNode(),
+          termANodeMatchesTermBNode = termANode.match(termBNode),
+          equalTo = termANodeMatchesTermBNode; ///
 
     return equalTo;
   }

package/src/element/topLevelAssertion/axiom.js

@@ -235,8 +235,11 @@ export default define(class Axiom extends TopLevelAssertion {
   async verify() {
     let verifies;
 
-    const context = this.getContext(),
-          axiomString = this.getString(); ///
+    const context = this.getContext();
+
+    await this.break(context);
+
+    const axiomString = this.getString(); ///
 
     context.trace(`Verifying the '${axiomString}' axiom...`);
 

package/src/element/topLevelAssertion/conjecture.js

@@ -8,8 +8,11 @@ export default define(class Conjecture extends TopLevelAssertion {
   async verify() {
     let verifies;
 
-    const context = this.getContext(),
-          conjectureString = this.getString();  ///
+    const context = this.getContext();
+
+    await this.break(context);
+
+    const conjectureString = this.getString();  ///
 
     context.trace(`Verifying the '${conjectureString}' conjecture...`);
 

package/src/element/topLevelAssertion/lemma.js

@@ -8,14 +8,17 @@ export default define(class Lemma extends TopLevelAssertion {
   async verify() {
     let verifies;
 
-    const context = this.getContext(),
-          lemmaString = this.getString(); ///
+    const context = this.getContext();
+
+    await this.break(context);
+
+    const lemmaString = this.getString(); ///
 
     (lemmaString === null) ?
       context.trace(`Verifying a lemma...`) :
         context.trace(`Verifying the '${lemmaString}' lemma...`);
 
-    verifies = super.verify();
+    verifies = await super.verify();
 
     if (verifies) {
       const lemma = this; ///

package/src/element/topLevelAssertion/theorem.js

@@ -8,8 +8,11 @@ export default define(class Theorem extends TopLevelAssertion {
   async verify() {
     let verifies;
 
-    const context = this.getContext(),
-          theoremString = this.getString();  ///
+    const context = this.getContext();
+
+    await this.break(context);
+
+    const theoremString = this.getString();  ///
 
     context.trace(`Verifying the '${theoremString}' theorem...`);
 

package/src/element/topLevelAssertion.js

@@ -2,8 +2,9 @@
 
 import { Element } from "occam-languages";
 import { arrayUtilities } from "necessary";
+import { asynchronousUtilities } from "occam-languages";
 
-import { scope, attempt } from "../utilities/context";
+import { asyncScope, asyncAttempt } from "../utilities/context";
 import { labelsFromJSON,
          deductionFromJSON,
          signatureFromJSON,
@@ -15,7 +16,8 @@ import { labelsFromJSON,
          hypothesesToHypothesesJSON,
          suppositionsToSuppositionsJSON } from "../utilities/json";
 
-const { extract, reverse, correlate, backwardsEvery } = arrayUtilities;
+const { asyncEvery } = asynchronousUtilities,
+      { extract, reverse, correlate, backwardsEvery } = arrayUtilities;
 
 export default class TopLevelAssertion extends Element {
   constructor(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses) {
@@ -120,22 +122,35 @@ export default class TopLevelAssertion extends Element {
     return correlatesToHypotheses;
   }
 
-  verify() {
+  verifyLabels() {
+    const labelsVerify = this.labels.every((label) => {
+      const nameOnly = true,
+            labelVerifies = label.verify(nameOnly);
+
+      if (labelVerifies) {
+        return true;
+      }
+    });
+
+    return labelsVerify;
+  }
+
+  async verify() {
     let verifies = false;
 
     const context = this.getContext();
 
-    scope((context) => {
+    await asyncScope(async (context) => {
       const labelsVerify = this.verifyLabels();
 
       if (labelsVerify) {
-        const suppositionsVerify = this.verifySuppositions(context);
+        const suppositionsVerify = await this.verifySuppositions(context);
 
         if (suppositionsVerify) {
-          const deductionVerifies = this.verifyDeduction(context);
+          const deductionVerifies = await this.verifyDeduction(context);
 
           if (deductionVerifies) {
-            const proofVerifies = this.verifyProof(context);
+            const proofVerifies = await this.verifyProof(context);
 
             if (proofVerifies) {
               verifies = true;
@@ -148,22 +163,9 @@ export default class TopLevelAssertion extends Element {
     return verifies;
   }
 
-  verifyLabels() {
-    const labelsVerify = this.labels.every((label) => {
-      const nameOnly = true,
-            labelVerifies = label.verify(nameOnly);
-
-      if (labelVerifies) {
-        return true;
-      }
-    });
-
-    return labelsVerify;
-  }
-
-  verifySuppositions(context) {
-    const suppositionsVerify = this.suppositions.every((supposition) => {
-      const suppositionVerifies = this.verifySupposition(supposition, context);
+  async verifySuppositions(context) {
+    const suppositionsVerify = await asyncEvery(this.suppositions, async (supposition) => {
+      const suppositionVerifies = await this.verifySupposition(supposition, context);
 
       if (suppositionVerifies) {
         return true;
@@ -173,24 +175,24 @@ export default class TopLevelAssertion extends Element {
     return suppositionsVerify;
   }
 
-  verifySupposition(supposition, context) {
-    const suppositionVerifies = supposition.verify(context);
+  async verifySupposition(supposition, context) {
+    const suppositionVerifies = await supposition.verify(context);
 
     return suppositionVerifies;
   }
 
-  verifyDeduction(context) {
-    const deductionVerifies = this.deduction.verify(context);
+  async verifyDeduction(context) {
+    const deductionVerifies = await this.deduction.verify(context);
 
     return deductionVerifies;
   }
 
-  verifyProof(context) {
+  async verifyProof(context) {
     let proofVerifies = true; ///
 
     if (this.proof !== null) {
-      proofVerifies = attempt((context) => {
-        const proofVerifies = this.proof.verify(this.deduction, context);
+      proofVerifies = await asyncAttempt(async (context) => {
+        const proofVerifies = await this.proof.verify(this.deduction, context);
 
         return proofVerifies;
       }, context);
@@ -211,8 +213,8 @@ export default class TopLevelAssertion extends Element {
     return statementUnifiesWithDeduction;
   }
 
-  unifyStatementAndStepsOrSubproofs(statement, subproofOrProofAssertions, substitutions, context) {
-    let statementAndStepsOrSubproofsUnifies = false;
+  unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, substitutions, context) {
+    let statementAndSubproofOrProofAssertionsUnify = false;
 
     const correlatesToHypotheses = this.correlateHypotheses(context);
 
@@ -220,22 +222,22 @@ export default class TopLevelAssertion extends Element {
       const statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, context);
 
       if (statementUnifiesWithDeduction) {
-        const subproofOrProofAssertionsUnifyWithSuppositions = this.unifyStepsOrSubproofsWithSuppositions(subproofOrProofAssertions, substitutions, context);
+        const subproofOrProofAssertionsUnifyWithSuppositions = this.unifySubproofOrProofAssertionsWithSuppositions(subproofOrProofAssertions, substitutions, context);
 
         if (subproofOrProofAssertionsUnifyWithSuppositions) {
           const substitutionsResolved = substitutions.areResolved();
 
           if (substitutionsResolved) {
-            statementAndStepsOrSubproofsUnifies = true;
+            statementAndSubproofOrProofAssertionsUnify = true;
           }
         }
       }
     }
 
-    return statementAndStepsOrSubproofsUnifies;
+    return statementAndSubproofOrProofAssertionsUnify;
   }
 
-  unifyStepsOrSubproofsWithSupposition(subproofOrProofAssertions, supposition, substitutions, generalContext, specificContext) {
+  unifySubproofOrProofAssertionsWithSupposition(subproofOrProofAssertions, supposition, substitutions, generalContext, specificContext) {
     let subproofOrProofAssertionsUnifiesWithSupposition = false;
 
     if (!subproofOrProofAssertionsUnifiesWithSupposition) {
@@ -264,11 +266,11 @@ export default class TopLevelAssertion extends Element {
     return subproofOrProofAssertionsUnifiesWithSupposition;
   }
 
-  unifyStepsOrSubproofsWithSuppositions(subproofOrProofAssertions, substitutions, generalContext, specificContext) {
+  unifySubproofOrProofAssertionsWithSuppositions(subproofOrProofAssertions, substitutions, generalContext, specificContext) {
     subproofOrProofAssertions = reverse(subproofOrProofAssertions); ///
 
     const subproofOrProofAssertionsUnifyWithSuppositions = backwardsEvery(this.suppositions, (supposition) => {
-      const subproofOrProofAssertionsUnifiesWithSupposition = this.unifyStepsOrSubproofsWithSupposition(subproofOrProofAssertions, supposition, substitutions, generalContext, specificContext);
+      const subproofOrProofAssertionsUnifiesWithSupposition = this.unifySubproofOrProofAssertionsWithSupposition(subproofOrProofAssertions, supposition, substitutions, generalContext, specificContext);
 
       if (subproofOrProofAssertionsUnifiesWithSupposition) {
         return true;

package/src/element/topLevelMetaAssertion/metaLemma.js

@@ -8,8 +8,11 @@ export default define(class MetaLemma extends TopLevelMetaAssertion {
   async verify() {
     let verifies;
 
-    const context = this.getContext(),
-          metaLemmaString = this.getString(); ///
+    const context = this.getContext();
+
+    this.break(context);
+
+    const metaLemmaString = this.getString(); ///
 
     context.trace(`Verifying the '${metaLemmaString}' meta-lemma...`);
 

package/src/element/topLevelMetaAssertion/metatheorem.js

@@ -8,8 +8,11 @@ export default define(class Metatheorem extends TopLevelMetaAssertion {
   async verify() {
     let verifies;
 
-    const context = this.getContext(),
-          metaLemmaString = this.getString(); ///
+    const context = this.getContext();
+
+    this.break(context);
+
+    const metaLemmaString = this.getString(); ///
 
     context.trace(`Verifying the '${metaLemmaString}' metatheorem...`);
 

package/src/element/variable.js

@@ -116,11 +116,12 @@ export default define(class Variable extends Element {
 
     context.trace(`Unifying the '${termString}' term with the '${variableString}' variable...`);
 
-    let variable;
+    let variable,
+        substitution;
 
     variable = this; ///
 
-    const substitution = substitutions.findSubstitutionByVariable(variable);
+    substitution = substitutions.findSubstitutionByVariable(variable);
 
     if (substitution !== null) {
       const substitutionComparesToTerm = substitution.compareTerm(term, context);
@@ -148,11 +149,12 @@ export default define(class Variable extends Element {
             termTypeEqualToOrSubTypeOfVariableType = termType.isEqualToOrSubTypeOf(variableType);
 
       if (termTypeEqualToOrSubTypeOfVariableType) {
-        synthetically((context) => {
-          const { TermSubstitution } = elements;
+        const { TermSubstitution } = elements,
+              termSubstitution = TermSubstitution.fromTermAndVariable(term, variable, context);
 
-          TermSubstitution.fromTermAndVariable(term, variable, context);
-        }, generalContext, specificContext);
+        substitution = termSubstitution;  ///
+
+        context.addSubstitution(substitution);
 
         termUnifies = true;
       }