occam-verify-cli 0.0.1033 → 0.0.1035

package/src/equality.js

@@ -121,14 +121,14 @@ export default class Equality {
 
     const equalityString = this.string; ///
 
-    localContext.trace(`Verifying the '${equalityString}' equality when stated...`);
+    localContext.trace(`Verifying the stated '${equalityString}' equality...`);
 
     const termsVerified = this.verifyTerms(localContext);
 
     verifiedWhenStated = termsVerified; ///
 
     if (verifiedWhenStated) {
-      localContext.debug(`...verified the '${equalityString}' equality when stated.`);
+      localContext.debug(`...verified the stated '${equalityString}' equality.`);
     }
 
     return verifiedWhenStated;
@@ -139,7 +139,7 @@ export default class Equality {
 
     const equalityString = this.string; ///
 
-    localContext.trace(`Verifying the '${equalityString}' equality when derived...`);
+    localContext.trace(`Verifying the derived '${equalityString}' equality...`);
 
     const termsVerified = this.verifyTerms(localContext);
 
@@ -150,7 +150,7 @@ export default class Equality {
     }
 
     if (verifiedWhenDerived) {
-      localContext.debug(`...verified the '${equalityString}' equality when derived.`);
+      localContext.debug(`...verified the derived '${equalityString}' equality.`);
     }
 
     return verifiedWhenDerived;

package/src/premise.js

@@ -12,8 +12,9 @@ import { assignAssignments } from "./utilities/assignments";
 const unqualifiedStatementNodeQuery = nodeQuery("/premise/unqualifiedStatement");
 
 export default class Premise {
-  constructor(fileContext, unqualifiedStatement) {
+  constructor(fileContext, subproofAssertion, unqualifiedStatement) {
     this.fileContext = fileContext;
+    this.subproofAssertion = subproofAssertion;
     this.unqualifiedStatement = unqualifiedStatement;
   }
 
@@ -21,6 +22,10 @@ export default class Premise {
     return this.fileContext;
   }
 
+  getSubproofAssertion() {
+    return this.subproofAssertion;
+  }
+
   getUnqualifiedStatement() {
     return this.unqualifiedStatement;
   }
@@ -90,12 +95,8 @@ export default class Premise {
 
     localContext.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement...`);
 
-    const statement = this.unqualifiedStatement.getStatement(),
-          statementNode = statement.getNode(),
-          subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, this.fileContext);
-
-    if (subproofAssertion !== null) {
-      subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, localContext);
+    if (this.subproofAssertion !== null) {
+      subproofUnified = this.subproofAssertion.unifySubproof(subproof, substitutions, localContext);
     }
 
     if (subproofUnified) {
@@ -142,30 +143,42 @@ export default class Premise {
 
   toJSON() {
     const unqualifiedStatementJSON = this.unqualifiedStatement.toJSON(),
-          unqualifiedStatement = unqualifiedStatementJSON,  ///
-          json = {
-            unqualifiedStatement
-          };
+      subproofAssertionJSON = (this.subproofAssertion !== null) ?
+        this.subproofAssertion.toJSON() :
+        null,
+      unqualifiedStatement = unqualifiedStatementJSON,  ///
+      subproofAssertion = subproofAssertionJSON,  ///
+      json = {
+        unqualifiedStatement,
+        subproofAssertion
+      };
 
     return json;
   }
 
   static fromJSON(json, fileContext) {
-    let { unqualifiedStatement } = json;
+    let { subproofAssertion, unqualifiedStatement } = json;
 
     json = unqualifiedStatement;  ///
 
     unqualifiedStatement = UnqualifiedStatement.fromJSON(json, fileContext);
 
-    const premise = new Premise(fileContext, unqualifiedStatement);
+    json = subproofAssertion; ///
+
+    subproofAssertion = (json !== null) ?
+                          SubproofAssertion.fromJSON(json, fileContext) :
+                            null;
+
+    const premise = new Premise(fileContext, subproofAssertion, unqualifiedStatement);
 
     return premise;
   }
 
-  static fromPremiseNode(premiseNode, fileContext) {
-    const unqualifiedStatementNode = unqualifiedStatementNodeQuery(premiseNode),
+  static fromSuppositionNode(suppositionNode, fileContext) {
+    const unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
           unqualifiedStatement = UnqualifiedStatement.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
-          premise = new Premise(fileContext, unqualifiedStatement);
+          subproofAssertion = SubproofAssertion.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
+          premise = new Premise(fileContext, subproofAssertion, unqualifiedStatement);
 
     return premise
   }

package/src/substitution/termForVariable.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import shim from "../shim";
 import Substitution from "../substitution";
 
 import { nodeQuery } from "../utilities/query";
@@ -25,12 +26,6 @@ export default class TermForVariableSubstitution extends Substitution {
     return this.variableNode;
   }
 
-  getNode() {
-    const node = this.termNode; ///
-
-    return node;
-  }
-
   transformed(substitutions) {
     let transformedSubstitution = null;
 
@@ -88,6 +83,22 @@ export default class TermForVariableSubstitution extends Substitution {
     return unifiedWithEquivalence;
   }
 
+  static fromTernAndVariable(term, variable, localContext) {
+    let termNode = term.getNode();
+
+    termNode = stripBracketsFromTerm(termNode); ///
+
+    const { Term } = shim;
+
+    term = Term.fromTermNode(termNode, localContext)
+
+    const string = stringFromTermAndVariable(term, variable),
+          variableNode = variable.getNode(),
+          termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode);
+
+    return termForVariableSubstitution;
+  }
+
   static fromSubstitutionNode(substitutionNode) {
     let termForVariableSubstitution = null;
 
@@ -106,15 +117,6 @@ export default class TermForVariableSubstitution extends Substitution {
 
     return termForVariableSubstitution;
   }
-
-  static fromTernNodeAndVariableNode(termNode, variableNode, localContextA, localContextB) {
-    termNode = stripBracketsFromTerm(termNode); ///
-
-    const string = stringFromTermNodeAndVariableNode(termNode, variableNode, localContextA, localContextB),
-          termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode);
-
-    return termForVariableSubstitution;
-  }
 }
 
 function transformTermNode(termNode, substitutions) {
@@ -162,12 +164,10 @@ function transformVariableNode(variableNode, substitutions) {
   return transformedVariableNode;
 }
 
-function stringFromTermNodeAndVariableNode(termNode, variableNode, localContextA, localContextB) {
-  const termNodeB = termNode,  ///
-        termStringB = localContextB.nodeAsString(termNodeB),
-        variableNodeA = variableNode,  ///
-        variableStringA = localContextA.nodeAsString(variableNodeA),
-        string = `[${termStringB} for ${variableStringA}]`;
+function stringFromTermAndVariable(term, variable) {
+  const termString = term.getString(),
+        variableString = variable.getString(),
+        string = `[${termString} for ${variableString}]`;
 
   return string;
 }

package/src/supposition.js

@@ -12,8 +12,9 @@ import { assignAssignments } from "./utilities/assignments";
 const unqualifiedStatementNodeQuery = nodeQuery("/supposition/unqualifiedStatement");
 
 export default class Supposition {
-  constructor(fileContext, unqualifiedStatement) {
+  constructor(fileContext, subproofAssertion, unqualifiedStatement) {
     this.fileContext = fileContext;
+    this.subproofAssertion = subproofAssertion;
     this.unqualifiedStatement = unqualifiedStatement;
   }
 
@@ -21,6 +22,10 @@ export default class Supposition {
     return this.fileContext;
   }
 
+  getSubproofAssertion() {
+    return this.subproofAssertion;
+  }
+
   getUnqualifiedStatement() {
     return this.unqualifiedStatement;
   }
@@ -90,12 +95,8 @@ export default class Supposition {
 
     localContext.trace(`Unifying the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement...`);
 
-    const statement = this.unqualifiedStatement.getStatement(),
-          statementNode = statement.getNode(),
-          subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, this.fileContext);
-
-    if (subproofAssertion !== null) {
-      subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, localContext);
+    if (this.subproofAssertion !== null) {
+      subproofUnified = this.subproofAssertion.unifySubproof(subproof, substitutions, localContext);
     }
 
     if (subproofUnified) {
@@ -142,22 +143,33 @@ export default class Supposition {
 
   toJSON() {
     const unqualifiedStatementJSON = this.unqualifiedStatement.toJSON(),
+          subproofAssertionJSON = (this.subproofAssertion !== null) ?
+                                     this.subproofAssertion.toJSON() :
+                                       null,
           unqualifiedStatement = unqualifiedStatementJSON,  ///
+          subproofAssertion = subproofAssertionJSON,  ///
           json = {
-            unqualifiedStatement
+            unqualifiedStatement,
+            subproofAssertion
           };
 
     return json;
   }
 
   static fromJSON(json, fileContext) {
-    let { unqualifiedStatement } = json;
+    let { subproofAssertion, unqualifiedStatement } = json;
 
     json = unqualifiedStatement;  ///
 
     unqualifiedStatement = UnqualifiedStatement.fromJSON(json, fileContext);
 
-    const supposition = new Supposition(fileContext, unqualifiedStatement);
+    json = subproofAssertion; ///
+
+    subproofAssertion = (json !== null) ?
+                          SubproofAssertion.fromJSON(json, fileContext) :
+                            null;
+
+    const supposition = new Supposition(fileContext, subproofAssertion, unqualifiedStatement);
 
     return supposition;
   }
@@ -165,7 +177,8 @@ export default class Supposition {
   static fromSuppositionNode(suppositionNode, fileContext) {
     const unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
           unqualifiedStatement = UnqualifiedStatement.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
-          supposition = new Supposition(fileContext, unqualifiedStatement);
+          subproofAssertion = SubproofAssertion.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
+          supposition = new Supposition(fileContext, subproofAssertion, unqualifiedStatement);
 
     return supposition
   }

package/src/term.js

@@ -248,9 +248,9 @@ class Term {
     return term;
   }
 
-  static fromTermNodeAndType(termNode, type, fileContext) {
+  static fromTermNodeAndType(termNode, type, localContext) {
     const node = termNode,  ///
-          string = fileContext.nodeAsString(node),
+          string = localContext.nodeAsString(node),
           term = new Term(string, node, type);
 
     return term;

package/src/theorem.js

@@ -1,7 +1,93 @@
 "use strict";
 
+import Label from "./label";
+import Proof from "./proof";
+import Consequent from "./consequent";
+import Supposition from "./supposition";
+import LocalContext from "./context/local";
+import Substitutions from "./substitutions";
 import TopLevelAssertion from "./topLevelAssertion";
 
+import { nodeQuery, nodesQuery } from "./utilities/query";
+import { labelsStringFromLabels } from "./topLevelAssertion";
+
+const proofNodeQuery = nodeQuery("/theorem/proof"),
+      labelNodesQuery = nodesQuery("/theorem/label"),
+      consequentNodeQuery = nodeQuery("/theorem/consequent"),
+      suppositionNodesQuery = nodesQuery("/theorem/supposition");
+
 export default class Theorem extends TopLevelAssertion {
-  static fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext) { return TopLevelAssertion.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(Theorem, labels, suppositions, consequent, substitutions, fileContext); }
+  verify() {
+    let verified = false;
+
+    const labelsString = labelsStringFromLabels(this.labels);
+
+    this.fileContext.trace(`Verifying the '${labelsString}' theorem...`);
+
+    const labelsVerifiedAtTopLevel = this.labels.every((label) => {
+      const labelVVerifiedAtTopLevel = label.verifyAtTopLevel(this.fileContext);
+
+      if (labelVVerifiedAtTopLevel) {
+        return true;
+      }
+    });
+
+    if (labelsVerifiedAtTopLevel) {
+      const localContext = LocalContext.fromFileContext(this.fileContext),
+            suppositionsVerified = this.suppositions.every((supposition) => {
+              const suppositionVerified = supposition.verify(localContext);
+
+              if (suppositionVerified) {
+                return true;
+              }
+            });
+
+      if (suppositionsVerified) {
+        const consequentVerified = this.consequent.verify(localContext);
+
+        if (consequentVerified) {
+          const substitutions = Substitutions.fromNothing(),
+                proofVerified = this.proof.verify(substitutions, this.consequent, localContext);
+
+          if (proofVerified) {
+            const theorem = this;  ///
+
+            this.fileContext.addTheorem(theorem);
+
+            verified = true;
+          }
+        }
+      }
+    }
+
+    if (verified) {
+      this.fileContext.debug(`...verified the '${labelsString}' theorem.`);
+    }
+
+    return verified;
+  }
+
+  static fromJSON(json, fileContext) { return TopLevelAssertion.fromJSON(Theorem, json, fileContext); }
+
+  static fromTheoremNode(theoremNode, fileContext) {
+    const proofNode = proofNodeQuery(theoremNode),
+          labelNodes = labelNodesQuery(theoremNode),
+          consequentNode = consequentNodeQuery(theoremNode),
+          suppositionNodes = suppositionNodesQuery(theoremNode),
+          labels = labelNodes.map((labelNode) => {
+            const label = Label.fromLabelNode(labelNode, fileContext);
+
+            return label;
+          }),
+          suppositions = suppositionNodes.map((suppositionNode) => {
+            const supposition = Supposition.fromSuppositionNode(suppositionNode, fileContext);
+
+            return supposition;
+          }),
+          consequent = Consequent.fromConsequentNode(consequentNode, fileContext),
+          proof = Proof.fromProofNode(proofNode, fileContext),
+          theorem = new Theorem(fileContext, labels, suppositions, consequent, proof);
+
+    return theorem;
+  }
 }

package/src/unifier/intrinsicLevel.js

@@ -2,9 +2,9 @@
 
 import shim from "../shim";
 import Unifier from "../unifier";
-import unifyVariableWithTerm from "../unify/variableWithTerm";
 
 import { nodeQuery } from "../utilities/query";
+import { variableNameFromVariableNode } from "../utilities/name";
 
 const termNodeQuery = nodeQuery("/term!"),
       termVariableNodeQuery = nodeQuery("/term/variable!");
@@ -27,10 +27,23 @@ class IntrinsicLevelUnifier extends Unifier {
       nodeQueryA: termVariableNodeQuery,
       nodeQueryB: termNodeQuery,
       unify: (termVariableNodeA, termNodeB, substitutions, localContextA, localContextB) => {
+        let termUnified = false;
+
         const variableNodeA = termVariableNodeA, ///
-              variableUnifiedWithTerm = unifyVariableWithTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB);
+              variableNameA = variableNameFromVariableNode(variableNodeA),
+              variableA = localContextA.findVariableByVariableName(variableNameA);
+
+        if (variableA !== null) {
+          const { Term } = shim,
+                termB = Term.fromTermNode(termNodeB, localContextB),
+                localContext = localContextB, ///
+                variable = variableA, ///
+                term = termB; ///
+
+          termUnified = variable.unifyTerm(term, substitutions, localContext);
+        }
 
-        return variableUnifiedWithTerm;
+        return termUnified;
       }
     }
   ];

package/src/unifier/metaLevel.js

@@ -2,12 +2,12 @@
 
 import shim from "../shim";
 import Unifier from "../unifier";
-import unifyVariableWithTerm from "../unify/variableWithTerm";
 import unifyMetavariableWithFrame from "../unify/metavariableWithFrame";
 import unifyMetavariableWithStatement from "../unify/metavariableWithStatement";
 import unifyMetavariableWithStatementGivenSubstitution from "../unify/metavariableWithStatementGivenSubstitution";
 
 import { nodeQuery } from "../utilities/query";
+import { variableNameFromVariableNode } from "../utilities/name";
 
 const termNodeQuery = nodeQuery("/term!"),
       frameNodeQuery = nodeQuery("/frame!"),
@@ -70,6 +70,8 @@ class MetaLevelUnifier extends Unifier {
       nodeQueryA: frameMetavariableNodeQuery,
       nodeQueryB: frameNodeQuery,
       unify: (frameMetavariableNodeA, frameNodeB, substitutions, localContextA, localContextB) => {
+        debugger
+
         const metavariableNodeA = frameMetavariableNodeA, ///
               metavariableUnifiedWithFrame = unifyMetavariableWithFrame(metavariableNodeA, frameNodeB, substitutions, localContextA, localContextB);
 
@@ -80,10 +82,23 @@ class MetaLevelUnifier extends Unifier {
       nodeQueryA: termVariableNodeQuery,
       nodeQueryB: termNodeQuery,
       unify: (termVariableNodeA, termNodeB, substitutions, localContextA, localContextB) => {
+        let termUnified = false;
+
         const variableNodeA = termVariableNodeA, ///
-              variableUnifiedWithTerm = unifyVariableWithTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB);
+              variableNameA = variableNameFromVariableNode(variableNodeA),
+              variableA = localContextA.findVariableByVariableName(variableNameA);
+
+        if (variableA !== null) {
+          const { Term } = shim,
+                termB = Term.fromTermNode(termNodeB, localContextB),
+                localContext = localContextB, ///
+                variable = variableA, ///
+                term = termB; ///
+
+          termUnified = variable.unifyTerm(term, substitutions, localContext);
+        }
 
-        return variableUnifiedWithTerm;
+        return termUnified;
       }
     }
   ];

package/src/utilities/array.js

@@ -2,7 +2,7 @@
 
 import { arrayUtilities } from "necessary";
 
-export const { first, last, extract, tail, push, find, clear, match, prune, filter, compress, separate } = arrayUtilities;
+export const { first, last, front, tail, push, find, match, clear, prune, extract, filter, compress, separate } = arrayUtilities;
 
 export function reverse(array) {
   array = [ ///

package/src/utilities/unify.js

@@ -3,24 +3,9 @@
 import { nodeQuery } from "../utilities/query";
 import { metavariableNameFromMetavariableNode}  from "../utilities/name";
 
-const termVariableNodeQuery = nodeQuery("/term/variable"),
-      frameMetavariableNodeQuery = nodeQuery("/frame/metavariable"),
+const frameMetavariableNodeQuery = nodeQuery("/frame/metavariable"),
       statementMetavariableNodeQuery = nodeQuery("/statement/metavariable");
 
-export function variableFromTermNode(termNode, localContext) {
-  let variable = null;
-
-  const termVariableNode = termVariableNodeQuery(termNode);
-
-  if (termVariableNode !== null) {
-    const variableNode = termVariableNode;  ///
-
-    variable = localContext.findVariableByVariableNode(variableNode);
-  }
-
-  return variable;
-}
-
 export function metavariableFromFrameNode(frameNode, localContext) {
   let metavariable = null;
 

package/src/variable.js

@@ -2,14 +2,16 @@
 
 import shim from "./shim";
 import LocalContext from "./context/local";
+import TermForVariableSubstitution from "./substitution/termForVariable";
 
 import { nodeQuery } from "./utilities/query";
+import { objectType } from "./type";
 import { variableNameFromVariableNode} from "./utilities/name";
 import { variableNodeFromVariableString } from "./utilities/node";
-import {objectType} from "./type";
 
 const typeNodeQuery = nodeQuery("/variableDeclaration/type"),
-      variableNodeQuery = nodeQuery("/variableDeclaration/variable");
+      variableNodeQuery = nodeQuery("/variableDeclaration/variable"),
+      termVariableNodeQuery = nodeQuery("/term/variable");
 
 export default class Variable {
   constructor(string, node, name, type) {
@@ -133,6 +135,47 @@ export default class Variable {
     return verifiedAtTopLevel;
   }
 
+  unifyTerm(term, substitutions, localContext) {
+    let termUnified = false;
+
+    const termString = term.getString(),
+          variableString = this.string; ///
+
+    localContext.trace(`Unifying the '${termString}' term with the '${variableString}' variable...`);
+
+    const termNode = term.getNode(),
+          variableNode = this.node, ///
+          substitution = substitutions.findSubstitutionByVariableNode(variableNode);
+
+    if (substitution !== null) {
+      const termNodeMatches = substitution.matchTermNode(termNode);
+
+      if (termNodeMatches) {
+        termUnified = true;
+      }
+    } else {
+      const variable = this,  ///
+            termVariable = termVariableFromTermNode(termNode, localContext);
+
+      if (termVariable === variable) {
+        termUnified = true;
+      } else {
+        const termForVariableSubstitution = TermForVariableSubstitution.fromTernAndVariable(term, variable, localContext),
+              substitution = termForVariableSubstitution;  ///
+
+        substitutions.addSubstitution(substitution, localContext);
+
+        termUnified = true;
+      }
+    }
+
+    if (termUnified) {
+      localContext.trace(`...unified the '${termString}' term with the '${variableString}' variable.`);
+    }
+
+    return termUnified;
+  }
+
   toJSON() {
     const typeJSON = this.type.toJSON(),
           string = this.string,
@@ -213,3 +256,17 @@ function typeFromJSON(json, fileContext) {
 
   return type;
 }
+
+function termVariableFromTermNode(termNode, localContext) {
+  let termVariable = null;
+
+  const termVariableNode = termVariableNodeQuery(termNode);
+
+  if (termVariableNode !== null) {
+    const termVariableName = variableNameFromVariableNode(termVariableNode);
+
+    termVariable = localContext.findVariableByVariableName(termVariableName);
+  }
+
+  return termVariable;
+}

package/src/verifier/topLevel.js

@@ -4,6 +4,7 @@ import Rule from "../rule";
 import Error from "../error";
 import Axiom from "../axiom";
 import Lemma from "../lemma";
+import Theorem from "../theorem";
 import TypeDeclaration from "../declaration/type";
 import VariableDeclaration from "../declaration/variable";
 import CombinatorDeclaration from "../declaration/combinator";
@@ -11,7 +12,6 @@ import ConstructorDeclaration from "../declaration/constructor";
 import MetavariableDeclaration from "../declaration/metavariable";
 
 import Verifier from "../verifier";
-import verifyTheorem from "../verify/theorem";
 import verifyMetaLemma from "../verify/metaLemma";
 import verifyConjecture from "../verify/conjecture";
 import verifyMetatheorem from "../verify/metatheorem";
@@ -84,7 +84,8 @@ class TopLevelVerifier extends Verifier {
     {
       nodeQuery: theoremNodeQuery,
       verify: (theoremNode, fileContext) => {
-        const theoremVerified = verifyTheorem(theoremNode, fileContext);
+        const theorem = Theorem.fromTheoremNode(theoremNode, fileContext),
+              theoremVerified = theorem.verify();
 
         return theoremVerified;
       }

package/lib/unify/variableWithTerm.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return unifyVariableWithTerm;
-    }
-});
-var _termForVariable = /*#__PURE__*/ _interop_require_default(require("../substitution/termForVariable"));
-var _unify = require("../utilities/unify");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-function unifyVariableWithTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB) {
-    var variableUnifiedWithTerm = false;
-    var substitution = substitutions.findSubstitutionByVariableNode(variableNodeA);
-    if (substitution !== null) {
-        var termNodeMatches = substitution.matchTermNode(termNodeB);
-        if (termNodeMatches) {
-            variableUnifiedWithTerm = true;
-        }
-    } else {
-        var variableA = localContextA.findVariableByVariableNode(variableNodeA), variableB = (0, _unify.variableFromTermNode)(termNodeB, localContextB);
-        if (variableA === variableB) {
-            variableUnifiedWithTerm = true;
-        } else {
-            var termNode = termNodeB, variableNode = variableNodeA, termForVariableSubstitution = _termForVariable.default.fromTernNodeAndVariableNode(termNode, variableNode, localContextA, localContextB), substitution1 = termForVariableSubstitution; ///
-            substitutions.addSubstitution(substitution1, localContextA, localContextB);
-            variableUnifiedWithTerm = true;
-        }
-    }
-    return variableUnifiedWithTerm;
-}
-
-//# sourceMappingURL=data:application/json;base64,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