occam-verify-cli 0.0.968 → 0.0.972

package/src/unify/metavariableWithStatement.js

@@ -1,76 +1,34 @@
 "use strict";
 
-import TermForVariableSubstitution from "../substitution/termForVariable";
-import unifyStatementWithStatement from "../unify/statementAtainstStatement";
 import StatementForMetavariableSubstitution from "../substitution/statementForMetavariable";
 
-import { nodeQuery } from "../utilities/query";
+import { metavariableFromStatementNode } from "../utilities/unify";
 
-const metavariableNodeQuery = nodeQuery("/statement/metavariable");
-
-export default function unifyMetavariableWithStatement(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB) {
+export default function unifyMetavariableWithStatement(metavariableNodeA, statementNodeB, substitutions, localContextA, localContextB) {
   let metavariableUnifiedWithStatement = false;
 
-  const substitution = substitutions.findSubstitution((substitution) => {
-    const substitutionMatchesMetavariableNodeA = substitution.matchMetavariableNode(metavariableNodeA);
-
-    if (substitutionMatchesMetavariableNodeA) {
-      return true;
-    }
-  }) || null;
+  const simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariableNode(metavariableNodeA),
+        substitution = simpleSubstitution;  ///
 
   if (substitution !== null) {
-    const substitutionStatementNode = substitution.getStatementNode();
-
-    if (substitutionNodeA !== null) {
-      const substitutionNode = substitutionNodeA, ///
-            termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionNode(substitutionNode),
-            localContext = localContextB,  ///
-            substitution = termForVariableSubstitution, ///
-            statementNodeA = substitutionStatementNode, ///
-            statementUnifiedWithStatement = unifyStatementWithStatement(statementNodeA, statementNodeB, substitution, substitutions, localContext, localContext);
-
-      if (statementUnifiedWithStatement) {
-        metavariableUnifiedWithStatement = true;
-      }
-    } else {
-      const substitutionSubstitution = substitution.getSubstitution();
-
-      if (substitutionSubstitution !== null) {
-        const statementNodeA = statementNodeB; ///
-
-        statementNodeB = substitutionStatementNode; ///
-
-        const localContext = localContextB,  ///
-              substitution = substitutionSubstitution,
-              statementUnifiedWithStatement = unifyStatementWithStatement(statementNodeA, statementNodeB, substitution, substitutions, localContext, localContext);
-
-        if (statementUnifiedWithStatement) {
-          metavariableUnifiedWithStatement = true;
-        }
-      } else {
-        const substitutionMatchesStatementNodeB = substitution.matchStatementNode(statementNodeB);
+    const statementNodeMatches = substitution.matchStatementNode(statementNodeB);
 
-        if (substitutionMatchesStatementNodeB) {
-          metavariableUnifiedWithStatement = true;
-        }
-      }
+    if (statementNodeMatches) {
+      metavariableUnifiedWithStatement = true;
     }
   } else {
-    const metavariableA = localContextA.findMetavariableByMetavariableNode(metavariableNodeA);
-
-    if (metavariableA !== null) {
-      const metavariableB = metavariableFromStatementNode(statementNodeB, localContextB);
+    const metavariableA = localContextA.findMetavariableByMetavariableNode(metavariableNodeA),
+          metavariableB = metavariableFromStatementNode(statementNodeB, localContextB);
 
-      if (metavariableA !== metavariableB) {
-        const statementNode = statementNodeB, ///
-              substitutionNode = substitutionNodeA, ///
-              metavariableNode = metavariableNodeA, ///
-              statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNodeStatementNodeAndSubstitutionNode(metavariableNode, statementNode, substitutionNode),
-              substitution = statementForMetavariableSubstitution;  ///
+    if (metavariableA === metavariableB) {
+      metavariableUnifiedWithStatement = true;
+    } else {
+      const statementNode = statementNodeB, ///
+            metavariableNode = metavariableNodeA, ///
+            statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementNodeAndMetavariableNode(statementNode, metavariableNode),
+            substitution = statementForMetavariableSubstitution;  ///
 
-        substitutions.addSubstitution(substitution, localContextA, localContextB);
-      }
+      substitutions.addSubstitution(substitution, localContextA, localContextB);
 
       metavariableUnifiedWithStatement = true;
     }
@@ -78,15 +36,3 @@ export default function unifyMetavariableWithStatement(metavariableNodeA, statem
 
   return metavariableUnifiedWithStatement;
 }
-
-function metavariableFromStatementNode(statementNode, localContext) {
-  let metavariable = null;
-
-  const metavariableNode = metavariableNodeQuery(statementNode)
-
-  if (metavariableNode !== null) {
-    metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode);
-  }
-
-  return metavariable;
-}

package/src/unify/metavariableWithStatementGivenSubstitution.js

@@ -0,0 +1,39 @@
+"use strict";
+
+import StatementForMetavariableSubstitution from "../substitution/statementForMetavariable";
+
+import { metavariableFromStatementNode } from "../utilities/unify";
+
+export default function unifyMetavariableWithStatementGivenSubstitution(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB) {
+  let metavariableUnifiedWithStatementGivenSubstitution = false;
+
+  const complexSubstitution = substitutions.findComplexSubstitutionByMetavariableNodeAndSubstitutionNode(metavariableNodeA, substitutionNodeA),
+        substitution = complexSubstitution; ///
+
+  if (substitution !== null) {
+    const statementNodeMatches = substitution.matchStatementNode(statementNodeB);
+
+    if (statementNodeMatches) {
+      metavariableUnifiedWithStatementGivenSubstitution = true;
+    }
+  } else {
+    const metavariableA = localContextA.findMetavariableByMetavariableNode(metavariableNodeA),
+          metavariableB = metavariableFromStatementNode(statementNodeB, localContextB);
+
+    if (metavariableA === metavariableB) {
+      metavariableUnifiedWithStatementGivenSubstitution = false;  ///
+    } else {
+      const statementNode = statementNodeB, ///
+            substitutionNode = substitutionNodeA, ///
+            metavariableNode = metavariableNodeA, ///
+            statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementNodeMetavariableNodeAndSubstitutionNode(statementNode, metavariableNode, substitutionNode),
+            substitution = statementForMetavariableSubstitution;  ///
+
+      substitutions.addSubstitution(substitution, localContextA, localContextB);
+
+      metavariableUnifiedWithStatementGivenSubstitution = true;
+    }
+  }
+
+  return metavariableUnifiedWithStatementGivenSubstitution;
+}

package/src/unify/premiseWithProofStep.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import { subproofNodeAsSubproofString } from "../utilities/unify";
+import { subproofNodeAsSubproofString } from "../utilities/subproof";
 
 export default function unifyPremiseWithProofStep(premiseA, proofStepB, substitutions, localContextA, localContextB) {
   let premiseUnified = false;

package/src/unify/statement/qualified.js

@@ -0,0 +1,183 @@
+"use strict";
+
+import { nodeQuery } from "../../utilities/query";
+
+const statementNodeQuery = nodeQuery("/qualifiedStatement/statement!"),
+      metavariableNodeQuery = nodeQuery("/qualifiedStatement/reference/metavariable!");
+
+const unifyQualifiedStatementFunctions = [
+  unifyQualifiedStatementAWithRule,
+  unifyQualifiedStatementAWithAxiom,
+  unifyQualifiedStatementAWithLemma,
+  unifyQualifiedStatementAWithTheorem,
+  unifyQualifiedStatementAWithConjecture,
+  unifyQualifiedStatementAWithReference
+];
+
+export default function unifyQualifiedStatement(qualifiedStatementNode, substitutions, localContext) {
+  let qualifiedStatementUnified;
+
+  const qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+
+  localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement...`, qualifiedStatementNode);
+
+  qualifiedStatementUnified = unifyQualifiedStatementFunctions.some((unifyQualifiedStatementFunction) => {
+    const qualifiedStatementUnified = unifyQualifiedStatementFunction(qualifiedStatementNode, substitutions, localContext);
+
+    return qualifiedStatementUnified;
+  });
+
+  if (qualifiedStatementUnified) {
+    localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement.`, qualifiedStatementNode);
+  }
+
+  return qualifiedStatementUnified;
+}
+
+function unifyQualifiedStatementAWithRule(qualifiedStatementNode, substitutions, localContext) {
+  let qualifiedStatementUnifiedWithRule = false;
+
+  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
+        rule = localContext.findRuleByMetavariableNode(metavariableNode);
+
+  if (rule !== null) {
+    const statementNode = statementNodeQuery(qualifiedStatementNode),
+          metavariableString = localContext.nodeAsString(metavariableNode),
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' rule...`, qualifiedStatementNode);
+
+    const statementUnified = rule.unifyStatement(statementNode, localContext);
+
+    qualifiedStatementUnifiedWithRule = statementUnified;  ///
+
+    if (qualifiedStatementUnifiedWithRule) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' rule.`, qualifiedStatementNode);
+    }
+  }
+
+  return qualifiedStatementUnifiedWithRule;
+}
+
+function unifyQualifiedStatementAWithAxiom(qualifiedStatementNode, substitutions, localContext) {
+  let qualifiedStatementUnifiedWithAxiom = false;
+
+  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
+        axiom = localContext.findAxiomByMetavariableNode(metavariableNode);
+
+  if (axiom !== null) {
+    const statementNode = statementNodeQuery(qualifiedStatementNode),
+          metavariableString = localContext.nodeAsString(metavariableNode),
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' axiom...`, qualifiedStatementNode);
+
+    const statementUnified = axiom.unifyStatement(statementNode, localContext);
+
+    qualifiedStatementUnifiedWithAxiom = statementUnified; ///
+
+    if (qualifiedStatementUnifiedWithAxiom) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' axiom.`, qualifiedStatementNode);
+    }
+  }
+
+  return qualifiedStatementUnifiedWithAxiom;
+}
+
+function unifyQualifiedStatementAWithLemma(qualifiedStatementNode, substitutions, localContext) {
+  let qualifiedStatementUnifiedWithLemma = false;
+
+  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
+        lemma = localContext.findLemmaByMetavariableNode(metavariableNode);
+
+  if (lemma !== null) {
+    const statementNode = statementNodeQuery(qualifiedStatementNode),
+          metavariableString = localContext.nodeAsString(metavariableNode),
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' lemma...`, qualifiedStatementNode);
+
+    const statementUnified = lemma.unifyStatement(statementNode, localContext);
+
+    qualifiedStatementUnifiedWithLemma = statementUnified; ///
+
+    if (qualifiedStatementUnifiedWithLemma) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' lemma.`, qualifiedStatementNode);
+    }
+  }
+
+  return qualifiedStatementUnifiedWithLemma;
+}
+
+function unifyQualifiedStatementAWithTheorem(qualifiedStatementNode, substitutions, localContext) {
+  let qualifiedStatementUnifiedWithTheorem = false;
+
+  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
+        theorem = localContext.findTheoremByMetavariableNode(metavariableNode);
+
+  if (theorem !== null) {
+    const statementNode = statementNodeQuery(qualifiedStatementNode),
+          metavariableString = localContext.nodeAsString(metavariableNode),
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' theorem...`, qualifiedStatementNode);
+
+    const statementUnified = theorem.unifyStatement(statementNode, localContext);
+
+    qualifiedStatementUnifiedWithTheorem = statementUnified; ///
+
+    if (qualifiedStatementUnifiedWithTheorem) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' theorem.`, qualifiedStatementNode);
+    }
+  }
+
+  return qualifiedStatementUnifiedWithTheorem;
+}
+
+function unifyQualifiedStatementAWithConjecture(qualifiedStatementNode, substitutions, localContext) {
+  let qualifiedStatementUnifiedWithConjecture = false;
+
+  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
+        conjecture = localContext.findConjectureByMetavariableNode(metavariableNode);
+
+  if (conjecture !== null) {
+    const statementNode = statementNodeQuery(qualifiedStatementNode),
+          metavariableString = localContext.nodeAsString(metavariableNode),
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' conjecture...`, qualifiedStatementNode);
+
+    const statementUnified = conjecture.unifyStatement(statementNode, localContext);
+
+    qualifiedStatementUnifiedWithConjecture = statementUnified; ///
+
+    if (qualifiedStatementUnifiedWithConjecture) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' conjecture.`, qualifiedStatementNode);
+    }
+  }
+
+  return qualifiedStatementUnifiedWithConjecture;
+}
+
+function unifyQualifiedStatementAWithReference(qualifiedStatementNode, substitutions, localContext) {
+  let qualifiedStatementUnifiedWithReference = false;
+
+  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
+        metavariableString = localContext.nodeAsString(metavariableNode),
+        metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode),
+        qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+
+  localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' reference...`, qualifiedStatementNode);
+
+  if (metavariablePresent) {
+
+    debugger
+
+  }
+
+  if (qualifiedStatementUnifiedWithReference) {
+    localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' reference.`, qualifiedStatementNode);
+  }
+
+  return qualifiedStatementUnifiedWithReference;
+}

package/src/unify/statement/unqualified.js

@@ -0,0 +1,24 @@
+"use strict";
+
+import { nodeQuery } from "../../utilities/query";
+
+const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
+
+export default function unifyUnqualifiedStatement(unqualifiedStatementNode, localContext) {
+  let unqualifiedStatementUnified;
+
+  const unqualifiedStatementString = localContext.nodeAsString(unqualifiedStatementNode);
+
+  localContext.trace(`Unifying the '${unqualifiedStatementString}' unqualified statement...`, unqualifiedStatementNode);
+
+  const statementNode = statementNodeQuery(unqualifiedStatementNode),
+        statementUnified = localContext.unifyStatement(statementNode, localContext);
+
+  unqualifiedStatementUnified = statementUnified;  ///
+
+  if (unqualifiedStatementUnified) {
+    localContext.debug(`...unified the '${unqualifiedStatementString}' unqualified statement.`, unqualifiedStatementNode);
+  }
+
+  return unqualifiedStatementUnified;
+}

package/src/unify/statementWithBracketedCombinator.js

@@ -3,7 +3,7 @@
 import bracketedCombinator from "../ocmbinator/bracketed";
 import statementWithCombinatorUnifier from "../unifier/statementWithCombinator";
 
-export default function unifyStatementWithBracketedCombinator(statementNode, assignments, derived, localContext) {
+export default function unifyStatementWithBracketedCombinator(statementNode, assignments, stated, localContext) {
   let statementUnifiedWithBracketedCombinator;
 
   const statementString = localContext.nodeAsString(statementNode);
@@ -12,7 +12,7 @@ export default function unifyStatementWithBracketedCombinator(statementNode, ass
 
   const bracketedCombinatorStatementNode = bracketedCombinator.getStatementNode();
 
-  statementUnifiedWithBracketedCombinator = statementWithCombinatorUnifier.unify(statementNode, bracketedCombinatorStatementNode, assignments, derived, localContext);
+  statementUnifiedWithBracketedCombinator = statementWithCombinatorUnifier.unify(statementNode, bracketedCombinatorStatementNode, assignments, stated, localContext);
 
   if (statementUnifiedWithBracketedCombinator) {
     localContext.debug(`...unified the '${statementString}' statement with the bracketed combinator.`, statementNode);

package/src/unify/statementWithCombinators.js

@@ -2,13 +2,13 @@
 
 import statementWithCombinatorUnifier from "../unifier/statementWithCombinator";
 
-export default function unifyStatementWithCombinators(statementNode, assignments, derived, localContext) {
+export default function unifyStatementWithCombinators(statementNode, assignments, stated, localContext) {
   let statementUnifiedWithCombinators;
 
   const combinators = localContext.getCombinators();
 
   statementUnifiedWithCombinators = combinators.some((combinator) => {
-    const statementUnifiedWithCombinator = unifyStatementWithCombinator(statementNode, combinator, assignments, derived, localContext);
+    const statementUnifiedWithCombinator = unifyStatementWithCombinator(statementNode, combinator, assignments, stated, localContext);
 
     if (statementUnifiedWithCombinator) {
       return true;
@@ -18,7 +18,7 @@ export default function unifyStatementWithCombinators(statementNode, assignments
   return statementUnifiedWithCombinators;
 }
 
-function unifyStatementWithCombinator(statementNode, combinator, assignments, derived, localContext) {
+function unifyStatementWithCombinator(statementNode, combinator, assignments, stated, localContext) {
   let statementUnifiedWithCombinator;
 
   const statementString = localContext.nodeAsString(statementNode),
@@ -28,7 +28,7 @@ function unifyStatementWithCombinator(statementNode, combinator, assignments, de
 
   const combinatorStatementNode = combinator.getStatementNode();
 
-  statementUnifiedWithCombinator = statementWithCombinatorUnifier.unify(statementNode, combinatorStatementNode, assignments, derived, localContext);
+  statementUnifiedWithCombinator = statementWithCombinatorUnifier.unify(statementNode, combinatorStatementNode, assignments, stated, localContext);
 
   if (statementUnifiedWithCombinator) {
     localContext.debug(`...unified the '${statementString}' statement with the '${combinatorString}' combinator.`, statementNode);

package/src/unify/statementWithMetaType.js

@@ -2,11 +2,11 @@
 
 import verifyStatementGivenMetaType from "../verify/statementGivenMetaType";
 
-export default function unifyStatementWithMetaType(statementNode, metaTypeNode, assignments, derived, localContext) {
+export default function unifyStatementWithMetaType(statementNode, metaTypeNode, assignments, stated, localContext) {
   let statementUnifiedWithMetaType;
 
   const metaType = localContext.findMetaTypeByMetaTypeNode(metaTypeNode),
-        statementVerifiedGivenMetaType = verifyStatementGivenMetaType(statementNode, metaType, assignments, derived, localContext);
+        statementVerifiedGivenMetaType = verifyStatementGivenMetaType(statementNode, metaType, assignments, stated, localContext);
 
   statementUnifiedWithMetaType = statementVerifiedGivenMetaType;  ///
 

package/src/unify/statementWithSttaemetnGivenEquivalences.js

@@ -0,0 +1,51 @@
+"use strict";
+
+import Substitutions from "../substitutions";
+import intrinsicLevelUnifier from "../unifier/intrinsicLevel";
+
+export default function unifyStatementWithStatementGivenEquivalences(statementNodeA, statementNodeB, equivalences, localContextA, localContextB) {
+  let statementUnifiedWithStatementGivenEquivalences = false;
+
+  const statementStringA = localContextA.nodeAsString(statementNodeA),
+        statementStringB = localContextB.nodeAsString(statementNodeB);
+
+  localContextB.trace(`Unifying the '${statementStringB}' statement with the '${statementStringA}' statement given equivalences...`, statementNodeB);
+
+  if (!statementUnifiedWithStatementGivenEquivalences) {
+    const substitutions = Substitutions.fromNothing(),
+          nodeA = statementNodeA,  ///
+          nodeB = statementNodeB,  ///
+          unified = intrinsicLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+
+    if (unified) {
+      const substitutionsUnifiedWithEquivalences = substitutions.unifyWithEquivalences(equivalences, localContextA, localContextB);
+
+      statementUnifiedWithStatementGivenEquivalences = substitutionsUnifiedWithEquivalences;  ///
+    }
+  }
+
+  if (!statementUnifiedWithStatementGivenEquivalences) {
+    const localContext = localContextA; ///
+
+    localContextA = localContextB;  ///
+
+    localContextB = localContext; ///
+
+    const substitutions = Substitutions.fromNothing(),
+          nodeA = statementNodeB,  ///
+          nodeB = statementNodeA,  ///
+          unified = intrinsicLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+
+    if (unified) {
+      const substitutionsUnifiedWithEquivalences = substitutions.unifyWithEquivalences(equivalences, localContextA, localContextB);
+
+      statementUnifiedWithStatementGivenEquivalences = substitutionsUnifiedWithEquivalences;  ///
+    }
+  }
+
+  if (statementUnifiedWithStatementGivenEquivalences) {
+    localContextB.debug(`...unified the '${statementStringB}' statement with the '${statementStringA}' statement given equivalences.`, statementNodeB);
+  }
+
+  return statementUnifiedWithStatementGivenEquivalences;
+}

package/src/unify/suppositionWithProffStep.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import { subproofNodeAsSubproofString } from "../utilities/unify";
+import { subproofNodeAsSubproofString } from "../utilities/subproof";
 
 export default function unifySuppositionWithProofStep(suppositionA, proofStepB, substitutions, localContextA, localContextB) {
   let suppositionUnified = false;

package/src/unify/variableWithTerm.js

@@ -2,41 +2,32 @@
 
 import TermForVariableSubstitution from "../substitution/termForVariable";
 
-import { nodeQuery } from "../utilities/query";
-
-const variableNodeQuery = nodeQuery("/term/variable");
+import { variableFromTermNode } from "../utilities/unify";
 
 export default function unifyVariableWithTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB) {
   let variableUnifiedWithTerm = false;
 
-  const substitution = substitutions.findSubstitution((substitution) => {
-    const substitutionMatchesVariableNodeA = substitution.matchVariableNode(variableNodeA);
-
-    if (substitutionMatchesVariableNodeA) {
-      return true;
-    }
-  }) || null;
+  const substitution = substitutions.findSubstitutionByVariableNode(variableNodeA);
 
   if (substitution !== null) {
-    const substitutionMatchesTermNodeB = substitution.matchTermNode(termNodeB);
+    const termNodeMatches = substitution.matchTermNode(termNodeB);
 
-    if (substitutionMatchesTermNodeB) {
+    if (termNodeMatches) {
       variableUnifiedWithTerm = true;
     }
   } else {
-    const variableA = localContextA.findVariableByVariableNode(variableNodeA);
+    const variableA = localContextA.findVariableByVariableNode(variableNodeA),
+          variableB = variableFromTermNode(termNodeB, localContextB);
 
-    if (variableA !== null) {
-      const variableB = variableFromTermNode(termNodeB, localContextB);
-
-      if (variableA !== variableB) {
-        const termNode = termNodeB, ///
-              variableNode = variableNodeA, ///
-              termForVariableSubstitution = TermForVariableSubstitution.fromVariableNodeAndTermNode(variableNode, termNode),
-              substitution = termForVariableSubstitution;  ///
+    if (variableA === variableB) {
+      variableUnifiedWithTerm = true;
+    } else {
+      const termNode = termNodeB, ///
+            variableNode = variableNodeA, ///
+            termForVariableSubstitution = TermForVariableSubstitution.fromTernNodeAndVariableNode(termNode, variableNode),
+            substitution = termForVariableSubstitution;  ///
 
-        substitutions.addSubstitution(substitution, localContextA, localContextB);
-      }
+      substitutions.addSubstitution(substitution, localContextA, localContextB);
 
       variableUnifiedWithTerm = true;
     }
@@ -44,15 +35,3 @@ export default function unifyVariableWithTerm(variableNodeA, termNodeB, substitu
 
   return variableUnifiedWithTerm;
 }
-
-function variableFromTermNode(termNode, localContext) {
-  let variable = null;
-
-  const variableNode = variableNodeQuery(termNode);
-
-  if (variableNode !== null) {
-    variable = localContext.findVariableByVariableNode(variableNode);
-  }
-
-  return variable;
-}

package/src/utilities/array.js

@@ -2,7 +2,7 @@
 
 import { arrayUtilities } from "necessary";
 
-export const { first, second, last, extract, tail, push, match, prune, filter, compress, separate } = arrayUtilities;
+export const { first, second, last, extract, tail, push, find, match, prune, filter, compress, separate } = arrayUtilities;
 
 export function reverse(array) {
   array = [ ///
@@ -12,21 +12,6 @@ export function reverse(array) {
   return array;
 }
 
-export function compare(arrayA, arrayB) {
-  let compares = false;
-
-  const arrayALength = arrayA.length,
-        arrayBLength = arrayB.length;
-
-  if (arrayALength === arrayBLength) {
-    const correlates = correlate(arrayA, arrayB);
-
-    compares = correlates;  ///
-  }
-
-  return compares;
-}
-
 export function correlate(arrayA, arrayB, callback) {
   arrayB = [  ///
     ...arrayB

package/src/utilities/assertion.js

@@ -0,0 +1,19 @@
+"use strict";
+
+import { NOT } from "../constants";
+import { nodesQuery } from "../utilities/query";
+
+const operatorTerminalNodesQuery = nodesQuery("/*/@operator");
+
+export function isAssertionNegated(assertionNode) {
+  const operatorTerminalNodes = operatorTerminalNodesQuery(assertionNode),
+        assertionNegated = operatorTerminalNodes.some((operatorTerminalNode) => {
+          const content = operatorTerminalNode.getContent();
+
+          if (content === NOT) {
+            return true;
+          }
+        });
+
+  return assertionNegated;
+}