occam-verify-cli 0.0.932 → 0.0.934

package/src/context/local.js

@@ -2,7 +2,6 @@
 
 import Variable from "../variable";
 import Equivalence from "../equivalence";
-import contextMixins from "../mixins/context";
 
 import { last, reverse } from "../utilities/array";
 import { mergeEquivalences, findEquivalenceByTerm, groundedTermsAndDefinedVariablesFromFromEquivalences } from "../utilities/equivalences";
@@ -89,6 +88,18 @@ class LocalContext {
     return lastProofStep;
   }
 
+  getAxioms() { return this.context.getAxioms(); }
+
+  getLemmas() { return this.context.getLemmas(); }
+
+  getTheorems() { return this.context.getTheorems(); }
+
+  getConjectures() { return this.context.getConjectures(); }
+
+  getCombinators() { return this.context.getCombinators(); }
+
+  getConstructors() { return this.context.getConstructors(); }
+
   addEquality(equality) {
     let equalityAdded;
 
@@ -217,20 +228,23 @@ class LocalContext {
     return metavariableAdded;
   }
 
-  matchStatementNode(statementNode) {
+  unifyStatement(statementNode) {
     let proofSteps = this.getProofSteps();
 
     proofSteps = reverse(proofSteps); ///
 
-    const matchesStatementNode = proofSteps.some((proofStep) => {
-      const proofStepMatchesStatementNode = proofStep.matchStatementNode(statementNode);
+    const localContext = this,  ///
+          equivalences = this.getEquivalences();
 
-      if (proofStepMatchesStatementNode) {
+    const statementUnified = proofSteps.some((proofStep) => {
+      const statementUnified = proofStep.unifyStatement(statementNode, equivalences, localContext);
+
+      if (statementUnified) {
         return true;
       }
     });
 
-    return matchesStatementNode;
+    return statementUnified;
   }
 
   getTermType(term) {
@@ -305,6 +319,14 @@ class LocalContext {
     return judgementPresent;
   }
 
+  isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }
+
+  isTypePresentByTypeNode(typeNode) { return this.context.isTypePresentByTypeNode(typeNode); }
+
+  isMetavariablePresentByName(name) { return this.context.isMetavariablePresentByName(name); }
+
+  isLabelPresentByMetavariableNode(metavariableNode) { return this.context.isLabelPresentByMetavariableNode(metavariableNode); }
+
   isMetavariablePresentByMetavariableNode(metavariableNode) {
     const metavariable = this.findMetavariableByMetavariableNode(metavariableNode),
           metavariablePresent = (metavariable !== null);
@@ -354,6 +376,46 @@ class LocalContext {
     return metavariable;
   }
 
+  findTypeByTypeName(typeName) { return this.context.findTypeByTypeName(typeName); }
+
+  findTypeByTypeNode(typeNode) { return this.context.findTypeByTypeNode(typeNode); }
+
+  findMetavariableByName(name) { return this.context.findMetavariableByName(name); }
+
+  findLabelByMetavariableNode(metavariableNode) { return this.context.findLabelByMetavariableNode(metavariableNode); }
+
+  findMetaTypeByMetaTypeNode(metaTypeNode) { return this.context.findMetaTypeByMetaTypeNode(metaTypeNode); }
+
+  findRuleByMetavariableNode(metavariableNode) { return this.context.findRuleByMetavariableNode(metavariableNode); }
+
+  findAxiomByMetavariableNode(metavariableNode) { return this.context.findAxiomByMetavariableNode(metavariableNode); }
+
+  findLemmaByMetavariableNode(metavariableNode) { return this.context.findLemmaByMetavariableNode(metavariableNode); }
+
+  findTheoremByMetavariableNode(metavariableNode) { return this.context.findTheoremByMetavariableNode(metavariableNode); }
+
+  findMetaLemmaByMetavariableNode(metavariableNode) { return this.context.findMetaLemmaByMetavariableNode(metavariableNode); }
+
+  findConjectureByMetavariableNode(metavariableNode) { return this.context.findConjectureByMetavariableNode(metavariableNode); }
+
+  findMetatheoremByMetavariableNode(metavariableNode) { return this.context.findMetatheoremByMetavariableNode(metavariableNode); }
+
+  nodeAsString(node) { return this.context.nodeAsString(node); }
+
+  nodesAsString(node) { return this.context.nodesAsString(node); }
+
+  trace(node, message) { this.context.trace(node, message); }
+
+  debug(node, message) { this.context.debug(node, message); }
+
+  info(node, message) { this.context.info(node, message); }
+
+  warning(node, message) { this.context.warning(node, message); }
+
+  error(node, message) { this.context.error(node, message); }
+
+  fatal(node, message) { this.context.fatal(node, message); }
+
   static fromFileContext(fileContext) {
     const context = fileContext,  ///
           variables = [],
@@ -402,6 +464,4 @@ class LocalContext {
   }
 }
 
-Object.assign(LocalContext.prototype, contextMixins);
-
 export default LocalContext;

package/src/declaration.js

@@ -42,8 +42,8 @@ export default class Declaration {
   }
 
   matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem) {
-    const metaConsequent = metaLemmaMetatheorem.getMetaConsequent(),
-          statementNode = metaConsequent.getStatementNode(),
+    const consequent = metaLemmaMetatheorem.getConsequent(),
+          statementNode = consequent.getStatementNode(),
           matches = this.statementNode.match(statementNode),
           matchesMetaLemmaOrMetaTheorem = matches;  ///
 

package/src/equality.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import equalityNodesVerifier from "./verifier/nodes/equality";
+import equalityUnifier from "./unifier/equality";
 
 export default class Equality {
   constructor(node, leftTerm, rightTerm) {
@@ -33,12 +33,12 @@ export default class Equality {
           rightTermNode = this.rightTerm.getNode(),
           nonTerminalNodeA = leftTermNode,  ///
           nonTerminalNodeB = rightTermNode, ///
-          nonTerminalNodeVerified = equalityNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, () => {
+          nonTerminalNodeUnified = equalityUnifier.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;
           }),
-          equal = nonTerminalNodeVerified;  ///
+          equal = nonTerminalNodeUnified;  ///
 
     return equal;
   }

package/src/equivalence.js

@@ -95,6 +95,25 @@ export default class Equivalence {
     return matchesTermNode;
   }
 
+  matchVariableNode(variableNode) {
+    const variableNodeA = variableNode, ///
+          matchesVariableNode = this.terms.some((term) => {
+            const termNode = term.getNode(),
+                  variableNode = variableNodeQuery(termNode);
+
+            if (variableNode !== null) {
+              const variableNodeB = variableNode, ///
+                    variableNodeAMatchesVariableNodeB = variableNodeA.match(variableNodeB);
+
+              if (variableNodeAMatchesVariableNodeB) {
+                return true;
+              }
+            }
+          });
+
+    return matchesVariableNode;
+  }
+
   matchTermNodes(termNodes) {
     const matchesTermNodes = termNodes.every((termNode) => {
       const matchesTermNode = this.matchTermNode(termNode);

package/src/metaLemma.js

@@ -5,5 +5,5 @@ import TopLevelAssertion from "./topLevelAssertion";
 export default class MetaLemma extends TopLevelAssertion {
   static fromJSONAndFileContext(json, fileContext) { return TopLevelAssertion.fromJSONAndFileContext(MetaLemma, json, fileContext); }
 
-  static fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(labels, metaSuppositions, metaConsequent, substitutions, fileContext) { return TopLevelAssertion.fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(MetaLemma, labels, metaSuppositions, metaConsequent, substitutions, fileContext); }
+  static fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext) { return MetaLemma.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(Metatheorem, labels, suppositions, consequent, substitutions, fileContext); }
 }

package/src/metatheorem.js

@@ -5,5 +5,5 @@ import TopLevelAssertion from "./topLevelAssertion";
 export default class Metatheorem extends TopLevelAssertion {
   static fromJSONAndFileContext(json, fileContext) { return TopLevelAssertion.fromJSONAndFileContext(Metatheorem, json, fileContext); }
 
-  static fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, fileContext) { return TopLevelAssertion.fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(Metatheorem, labels, suppositions, consequent, fileContext); }
+  static fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext) { return TopLevelAssertion.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(Metatheorem, labels, suppositions, consequent, substitutions, fileContext); }
 }

package/src/premise.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import LocalContext from "./context/local";
-import metaLevelNodesVerifier from "./verifier/nodes/metaLevel";
+import metaLevelUnifier from "./unifier/metaLevel";
 
 import { match } from "./utilities/array";
 import { nodeAsString } from "./utilities/string";
@@ -31,13 +31,13 @@ export default class Premise {
             nonTerminalNodeB = statementNode,  ///
             localContextA = LocalContext.fromFileContext(fileContextA),
             localContextB = localContext,  ///
-            nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+            nonTerminalNodeUnified = metaLevelUnifier.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
               const verifiedAhead = true;
 
               return verifiedAhead;
             });
 
-      matchesStatementNode = nonTerminalNodeVerified; ///
+      matchesStatementNode = nonTerminalNodeUnified; ///
     }
 
     return matchesStatementNode;
@@ -64,13 +64,13 @@ export default class Premise {
                 nonTerminalNodeB = subproofStatementNode, ///
                 localContextA = LocalContext.fromFileContext(fileContextA),
                 localContextB = localContext,  ///
-                nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+                nonTerminalNodeUnified = metaLevelUnifier.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
                   const verifiedAhead = true;
 
                   return verifiedAhead;
                 });
 
-          if (nonTerminalNodeVerified) {
+          if (nonTerminalNodeUnified) {
             return true;
           }
         });

package/src/proofStep.js

@@ -1,5 +1,7 @@
 "use strict";
 
+import metaLevelUnifier from "./unifier/metaLevel";
+
 export default class ProofStep {
   constructor(subproofNode, statementNode) {
     this.subproofNode = subproofNode;
@@ -14,14 +16,30 @@ export default class ProofStep {
     return this.statementNode;
   }
 
-  matchStatementNode(statementNode) {
-    let matchesStatementNode = false;
+  unifyStatement(statementNode, equivalences, localContext) {
+    let statementUnified = false;
 
     if (this.statementNode !== null) {
-      matchesStatementNode = this.statementNode.match(statementNode);
+      let statementUnifiedAgainstStatement = false;
+
+      if (!statementUnifiedAgainstStatement) {
+        const statementNodeA = statementNode, ///
+              statementNodeB = this.statementNode;  ///
+
+        statementUnifiedAgainstStatement = unifyStatementAgainstStatement(statementNodeA, statementNodeB, equivalences, localContext);
+      }
+
+      if (!statementUnifiedAgainstStatement) {
+        const statementNodeA = statementNode, ///
+              statementNodeB = this.statementNode;  ///
+
+        statementUnifiedAgainstStatement = unifyStatementAgainstStatement(statementNodeA, statementNodeB, equivalences, localContext);
+      }
+
+      statementUnified = statementUnifiedAgainstStatement;  ///
     }
 
-    return matchesStatementNode;
+    return statementUnified;
   }
 
   static fromSubproofNode(subproofNode) {
@@ -38,3 +56,38 @@ export default class ProofStep {
     return proofStep;
   }
 }
+
+function unifyStatementAgainstStatement(statementNodeA, statementNodeB, equivalences, localContext) {
+  let statementUnifiedAgainstStatement = false;
+
+  const nonTerminalNodeA = statementNodeA,  ///
+        nonTerminalNodeB = statementNodeB,  ///
+        substitutions = [],
+        localContextA = localContext, ///
+        localContextB = localContext,  ///
+        nonTerminalNodeUnified = metaLevelUnifier.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+          const verifiedAhead = true;
+
+          return verifiedAhead;
+        });
+
+  if (nonTerminalNodeUnified) {
+    const substitutionsUnified = substitutions.every((substitution) => {
+      const substitutionUnified = equivalences.some((equivalence) => {
+        const substitutionUnifiedAgainstEquivalence = substitution.unifyAgainstEquivalence(equivalence, substitutions, localContext);
+
+        if (substitutionUnifiedAgainstEquivalence) {
+          return true;
+        }
+      });
+
+      if (substitutionUnified) {
+        return true;
+      }
+    });
+
+    statementUnifiedAgainstStatement = substitutionsUnified;  ///
+  }
+
+  return statementUnifiedAgainstStatement;
+}

package/src/shim.js

@@ -0,0 +1,5 @@
+"use strict"
+
+const shim = {};
+
+export default shim;

package/src/substitution/statementForMetavariable.js

@@ -1,12 +1,16 @@
 "use strict";
 
+import shim from "../shim";
 import Substitution from "../substitution";
 import TermForVariableSubstitution from "./termForVariable";
-import verifyStatementAgainstStatement from "../verify/statementAtainstStatement";
+import unifyStatementAgainstStatement from "../unify/statementAtainstStatement";
 
+import { nodeQuery } from "../utilities/query";
 import { bracketedStatementChildNodeFromStatementNode } from "../utilities/match";
 import { statementNodeFromStatementString, metavariableNodeFromMetavariableString } from "../utilities/node";
 
+const metavariableNodeQuery = nodeQuery("/statement/metavariable!");
+
 export default class StatementForMetavariableSubstitution extends Substitution {
   constructor(metavariableNode, statementNode, substitution) {
     super();
@@ -56,6 +60,33 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return matchesMetavariableNode;
   }
 
+  unifyAgainstEquivalence(equivalence, substitutions, localContext) {
+    let unifiedAgainstEquivalence = false;  ///
+
+    const metavariableNode = metavariableNodeQuery(this.statementNode);
+
+    if (metavariableNode !== null) {
+      substitutions = [ ///
+        ...substitutions
+      ];
+
+      const { metaLevelUnifier } = shim,
+            nonTerminalNodeA = this.metavariableNode, ///
+            nonTerminalNodeB = metavariableNode, ///
+            localContextA = localContext, ///
+            localContextB = localContext,  ///
+            nonTerminalNodeUnified = metaLevelUnifier.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+              const verifiedAhead = true;
+
+              return verifiedAhead;
+            });
+
+      unifiedAgainstEquivalence = nonTerminalNodeUnified; ///
+    }
+
+    return unifiedAgainstEquivalence;
+  }
+
   static fromJSONAndFileContext(json, fileContext) {
     const { metavariable, statement } = json,
             metavariableString = metavariable,  ///
@@ -120,7 +151,7 @@ function matchStatementNode(statementNodeA, statementNodeB, substitution, substi
 
     statementNodeMatches = statementNodeAMatchesStatementNodeB; ///
   } else {
-    const statementVerifiedAgainstStatement = verifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
+    const statementVerifiedAgainstStatement = unifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
 
     statementNodeMatches = statementVerifiedAgainstStatement; ///
   }

package/src/substitution/termForVariable.js

@@ -45,6 +45,22 @@ export default class TermForVariableSubstitution extends Substitution {
     return matchesVariableNode;
   }
 
+  unifyAgainstEquivalence(equivalence, substitutions, localContext) {
+    let unifiedAgainstEquivalence;
+
+    const equivalenceMatchesVariableNode = equivalence.matchVariableNode(this.variableNode);
+
+    if (equivalenceMatchesVariableNode) {
+      const equivalenceMatchesTermNode = equivalence.matchTermNode(this.termNode);
+
+      if (equivalenceMatchesTermNode) {
+        unifiedAgainstEquivalence = true;
+      }
+    }
+
+    return unifiedAgainstEquivalence;
+  }
+
   static fromSubstitutionNode(substitutionNode) {
     const termNode = termNodeQuery(substitutionNode),
           variableNode = variableNodeQuery(substitutionNode),

package/src/supposition.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import LocalContext from "./context/local";
-import metaLevelNodesVerifier from "./verifier/nodes/metaLevel";
+import metaLevelUnifier from "./unifier/metaLevel";
 
 import { match } from "./utilities/array";
 import { nodeAsString } from "./utilities/string";
@@ -31,13 +31,13 @@ export default class Supposition {
             nonTerminalNodeB = statementNode,  ///
             localContextA = LocalContext.fromFileContext(fileContextA),
             localContextB = localContext,  ///
-            nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+            nonTerminalNodeUnified = metaLevelUnifier.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
               const verifiedAhead = true;
 
               return verifiedAhead;
             });
 
-      matchesStatementNode = nonTerminalNodeVerified; ///
+      matchesStatementNode = nonTerminalNodeUnified; ///
     }
 
     return matchesStatementNode;
@@ -64,13 +64,13 @@ export default class Supposition {
                 nonTerminalNodeB = subproofStatementNode, ///
                 localContextA = LocalContext.fromFileContext(fileContextA),
                 localContextB = localContext,  ///
-                nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+                nonTerminalNodeUnified = metaLevelUnifier.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
                   const verifiedAhead = true;
 
                   return verifiedAhead;
                 });
 
-          if (nonTerminalNodeVerified) {
+          if (nonTerminalNodeUnified) {
             return true;
           }
         });

package/src/unifier/equality.js

@@ -0,0 +1,84 @@
+"use strict";
+
+import Unifier from "../unifier";
+import unifyTermAgainstTerm from "../unify/termAgainstTerm";
+
+import { unify } from "../unifier";
+import { nodeQuery } from "../utilities/query";
+
+const termNodeQuery = nodeQuery("/term!"),
+      nonTerminalNodeQuery = nodeQuery("/*");
+
+class EqualityUnifier extends Unifier {
+  unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, unifyAhead) {
+    let nonTerminalNodUnified;
+
+    const nodeQueryMaps = [
+      {
+        nodeQueryA: termNodeQuery,
+        nodeQueryB: termNodeQuery,
+        unify: (nodeA, nodeB, localContext, unifyAhead) => {
+          let nonTerminalNodUnified;
+
+          const termNodeA = nodeA,  ///
+                termNodeB = nodeB,  ///
+                termNodUnifiedAgainstTermNode =
+
+                  this.unifyTermNodeAgainstTermNode(termNodeA, termNodeB, localContext, unifyAhead);
+
+          nonTerminalNodUnified = termNodUnifiedAgainstTermNode; ///
+
+          return nonTerminalNodUnified;
+        }
+      },
+      {
+        nodeQueryA: nonTerminalNodeQuery,
+        nodeQueryB: nonTerminalNodeQuery,
+        unify: (nodeA, nodeB, localContext, unifyAhead) => {
+          let nonTerminalNodUnified;
+
+          const nonTerminalNodeA = nodeA, ///
+                nonTerminalNodeB = nodeB; ///
+
+          nonTerminalNodUnified =
+
+            super.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, unifyAhead);
+
+          return nonTerminalNodUnified;
+        }
+      }
+    ];
+
+    const nodesVerified = unify(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, localContext, unifyAhead);
+
+    nonTerminalNodUnified = nodesVerified;  ///
+
+    return nonTerminalNodUnified;
+  }
+
+  unifyTermNodeAgainstTermNode(termNodeA, termNodeB, localContext, unifyAhead) {
+    let termNodUnifiedAgainstTermNode;
+
+    const termVerifiedAgainstTerm = unifyTermAgainstTerm(termNodeA, termNodeB, localContext, unifyAhead);
+
+    if (termVerifiedAgainstTerm) {
+      termNodUnifiedAgainstTermNode = true;
+    } else {
+      const nonTerminalNodeA = termNodeA, ///
+            nonTerminalNodeB = termNodeB, ///
+            nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
+            nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
+            childNodesA = nonTerminalNodeAChildNodes, ///
+            childNodesB = nonTerminalNodeBChildNodes, ///
+            childNodesVerified = this.unifyChildNodes(childNodesA, childNodesB, localContext, unifyAhead);
+
+      termNodUnifiedAgainstTermNode = childNodesVerified; ///
+    }
+
+    return termNodUnifiedAgainstTermNode;
+  }
+}
+
+const equalityUnifier = new EqualityUnifier();
+
+export default equalityUnifier;

package/src/unifier/metaLevel.js

@@ -0,0 +1,114 @@
+"use strict";
+
+import shim from "../shim";
+import Unifier from "../unifier";
+import unifyVariableAgainstTerm from "../unify/variableAgainstTerm";
+import unifyMetavariableAgainstStatement from "../unify/metavariableAgainstStatement";
+
+import { unify } from "../unifier";
+import { nodeQuery } from "../utilities/query";
+
+const termNodeQuery = nodeQuery("/term!"),
+      statementNodeQuery = nodeQuery("/statement!"),
+      nonTerminalNodeQuery = nodeQuery("/*"),
+      termVariableNodeQuery = nodeQuery("/term/variable!"),
+      statementSubstitutionNodeQuery = nodeQuery("/statement/substitution!"),
+      statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!");
+
+class MetaLevelUnifier extends Unifier {
+  unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, unifyAhead) {
+    let nonTerminalNodeUnified;
+
+    const nodeQueryMaps = [
+      {
+        nodeQueryA: statementMetavariableNodeQuery,
+        nodeQueryB: statementNodeQuery,
+        unify: (nodeA, nodeB, substitutions, localContextA, localContextB, unifyAhead) => {
+          let nonTerminalNodeUnified;
+
+          const statementNodeA = nonTerminalNodeA,  ///
+                statementNodeB = nodeB, ///
+                statementMetavariableNodeA = nodeA, ///
+                statementSubstitutionNodeA = statementSubstitutionNodeQuery(statementNodeA),
+                metavariableNodeUnifiedAgainstStatementNode =
+
+                  this.unifyStatementMetavariableNodeAgainstStatementNode(statementMetavariableNodeA, statementSubstitutionNodeA, statementNodeB, substitutions, localContextA, localContextB, unifyAhead);
+
+          nonTerminalNodeUnified = metavariableNodeUnifiedAgainstStatementNode;  ///
+
+          return nonTerminalNodeUnified;
+        }
+      },
+      {
+        nodeQueryA: termVariableNodeQuery,
+        nodeQueryB: termNodeQuery,
+        unify: (nodeA, nodeB, substitutions, localContextA, localContextB, unifyAhead) => {
+          let nonTerminalNodeUnified;
+
+          const termNodeB = nodeB,  ///
+                termVariableNodeA = nodeA,  ///
+                termVariableNodeUnifiedAgainstTermNode =
+
+                  this.unifyTermVariableNodeAgainstTermNode(termVariableNodeA, termNodeB, substitutions, localContextA, localContextB, unifyAhead);
+
+          nonTerminalNodeUnified = termVariableNodeUnifiedAgainstTermNode;  ///
+
+          return nonTerminalNodeUnified;
+        }
+      },
+      {
+        nodeQueryA: nonTerminalNodeQuery,
+        nodeQueryB: nonTerminalNodeQuery,
+        unify: (nodeA, nodeB, substitutions, localContextA, localContextB, unifyAhead) => {
+          let nonTerminalNodeUnified;
+
+          const nonTerminalNodeA = nodeA, ///
+                nonTerminalNodeB = nodeB; ///
+
+          nonTerminalNodeUnified =
+
+            super.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, unifyAhead);
+
+          return nonTerminalNodeUnified;
+        }
+      }
+    ];
+
+    const nodesUnified = unify(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, unifyAhead);
+
+    nonTerminalNodeUnified = nodesUnified;  ///
+
+    return nonTerminalNodeUnified;
+  }
+
+  unifyStatementMetavariableNodeAgainstStatementNode(statementMetavariableNodeA, statementSubstitutionNodeA, statementNodeB, substitutions, localContextA, localContextB, unifyAhead) {
+    let metavariableNodeUnifiedAgainstStatementNode;
+
+    const substitutionNode = statementSubstitutionNodeA,  ///
+          metavariableNodeA = statementMetavariableNodeA, ///
+          metavariableUnifiedAgainstStatement = unifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNode, substitutions, localContextA, localContextB, unifyAhead);
+
+    metavariableNodeUnifiedAgainstStatementNode = metavariableUnifiedAgainstStatement;  ///
+
+    return metavariableNodeUnifiedAgainstStatementNode;
+  }
+
+  unifyTermVariableNodeAgainstTermNode(termVariableNodeA, termNodeB, substitutions, localContextA, localContextB, unifyAhead) {
+    let termVariableNodeUnifiedAgainstTermNode;
+
+    const variableNodeA = termVariableNodeA, ///
+          termUnifiedAgainstVariable = unifyVariableAgainstTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB, unifyAhead);
+
+    termVariableNodeUnifiedAgainstTermNode = termUnifiedAgainstVariable;  ///
+
+    return termVariableNodeUnifiedAgainstTermNode;
+  }
+}
+
+const metaLevelUnifier = new MetaLevelUnifier();
+
+Object.assign(shim, {
+  metaLevelUnifier
+});
+
+export default metaLevelUnifier;