occam-verify-cli 0.0.959 → 0.0.961

package/src/unifier/metaLevel.js

@@ -2,8 +2,8 @@
 
 import shim from "../shim";
 import Unifier from "../unifier";
-import unifyVariableAgainstTerm from "../unify/variableAgainstTerm";
-import unifyMetavariableAgainstStatement from "../unify/metavariableAgainstStatement";
+import unifyVariableWithTerm from "../unify/variableWithTerm";
+import unifyMetavariableWithStatement from "../unify/metavariableWithStatement";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -31,15 +31,15 @@ class MetaLevelUnifier extends Unifier {
       nodeQueryA: statementNodeQuery,
       nodeQueryB: statementNodeQuery,
       unify: (statementNodeA, statementNodeB, substitutions, localContextA, localContextB) => {
-        let statementUnifiedAgainstStatement;
+        let statementUnifiedWithStatement;
 
         const metavariableNodeA = metavariableNodeQuery(statementNodeA);
 
         if (metavariableNodeA !== null) {
           const substitutionNodeA = substitutionNodeQuery(statementNodeA),
-                metavariableUnifiedAgainstStatement = unifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB);
+                metavariableUnifiedWithStatement = unifyMetavariableWithStatement(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB);
 
-          statementUnifiedAgainstStatement = metavariableUnifiedAgainstStatement;  ///
+          statementUnifiedWithStatement = metavariableUnifiedWithStatement;  ///
         } else {
           const nonTerminalNodeA = statementNodeA, ///
                 nonTerminalNodeB = statementNodeB, ///
@@ -49,10 +49,10 @@ class MetaLevelUnifier extends Unifier {
                 childNodesB = nonTerminalNodeBChildNodes, ///
                 childNodesVerified = metaLevelUnifier.unifyChildNodes(childNodesA, childNodesB, substitutions, localContextA, localContextB);
 
-          statementUnifiedAgainstStatement = childNodesVerified; ///
+          statementUnifiedWithStatement = childNodesVerified; ///
         }
 
-        return statementUnifiedAgainstStatement;
+        return statementUnifiedWithStatement;
       }
     },
     {
@@ -60,9 +60,9 @@ class MetaLevelUnifier extends Unifier {
       nodeQueryB: termNodeQuery,
       unify: (termVariableNodeA, termNodeB, substitutions, localContextA, localContextB) => {
         const variableNodeA = termVariableNodeA, ///
-              variableUnifiedAgainstTerm = unifyVariableAgainstTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB);
+              variableUnifiedWithTerm = unifyVariableWithTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB);
 
-        return variableUnifiedAgainstTerm;
+        return variableUnifiedWithTerm;
       }
     }
   ];

package/src/unifier/statementWithCombinator.js

@@ -0,0 +1,55 @@
+"use strict";
+
+import Unifier from "../unifier";
+import unifyTermWithType from "../unify/termWithType";
+import unifyStatementWithMetaType from "../unify/statementWithMetaType";
+
+import { nodeQuery } from "../utilities/query";
+
+const termNodeQuery = nodeQuery("/term!"),
+      typeNodeQuery = nodeQuery("/type!"),
+      metaTypeNodeQuery = nodeQuery("/metaType!"),
+      statementNodeQuery = nodeQuery("/statement!");
+
+class StatementWithCombinatorUnifier extends Unifier {
+  unify(statementNode, combinatorStatementNode, assignments, derived, localContext) {
+    let statementUnifiedWithCombinator;
+
+    const nonTerminalNodeA = statementNode, ///
+          nonTerminalNodeB = combinatorStatementNode, ///
+          nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, assignments, derived, localContext);
+
+    statementUnifiedWithCombinator = nonTerminalNodeUnified; ///
+
+    return statementUnifiedWithCombinator;
+  };
+
+  static maps = [
+    {
+      nodeQueryA: statementNodeQuery,
+      nodeQueryB: metaTypeNodeQuery,
+      unify: (statementNodeA, metaTypeNodeB, assignments, derived, localContext) => {
+        const metaTypeNode = metaTypeNodeB, ///
+              statementNode = statementNodeA, ///
+              statementUnifiedWithMetaType = unifyStatementWithMetaType(statementNode, metaTypeNode, assignments, derived, localContext);
+
+        return statementUnifiedWithMetaType;
+      }
+    },
+    {
+      nodeQueryA: termNodeQuery,
+      nodeQueryB: typeNodeQuery,
+      unify: (termNodeA, typeNodeB, assignments, derived, localContext) => {
+        const termNode = termNodeA, ///
+              typeNode = typeNodeB, ///
+              termUnifiedWithType = unifyTermWithType(termNode, typeNode, localContext);
+
+        return termUnifiedWithType;
+      }
+    }
+  ];
+}
+
+const statementWithCombinatorUnifier = new StatementWithCombinatorUnifier();
+
+export default statementWithCombinatorUnifier;

package/src/unifier/{termAgainstConstructor.js → termWithConstructor.js}

@@ -1,24 +1,24 @@
 "use strict";
 
 import Unifier from "../unifier";
-import unifyTermAgainstType from "../unify/termAgainstType";
+import unifyTermWithType from "../unify/termWithType";
 
 import { nodeQuery } from "../utilities/query";
 
 const termNodeQuery = nodeQuery("/term"),
       typeNodeQuery = nodeQuery("/type");
 
-class TermAgainstConstructorUnifier extends Unifier {
+class TermWithConstructorUnifier extends Unifier {
   unify(termNode, constructorTermNode, localContext) {
-    let termUnifiedAgainstConstructor;
+    let termUnifiedWithConstructor;
 
     const nonTerminalNodeA = termNode, ///
           nonTerminalNodeB = constructorTermNode, ///
           nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext);
 
-    termUnifiedAgainstConstructor = nonTerminalNodeUnified; ///
+    termUnifiedWithConstructor = nonTerminalNodeUnified; ///
 
-    return termUnifiedAgainstConstructor;
+    return termUnifiedWithConstructor;
   };
 
   static maps = [
@@ -28,14 +28,14 @@ class TermAgainstConstructorUnifier extends Unifier {
       unify: (termNodeA, typeNodeB, localContext) => {
         const termNode = termNodeA, ///
               typeNode = typeNodeB, ///
-              termUnifiedAgainstType = unifyTermAgainstType(termNode, typeNode, localContext);
+              termUnifiedWithType = unifyTermWithType(termNode, typeNode, localContext);
 
-        return termUnifiedAgainstType;
+        return termUnifiedWithType;
       }
     }
   ];
 }
 
-const termAgainstConstructorUnifier = new TermAgainstConstructorUnifier();
+const termWithConstructorUnifier = new TermWithConstructorUnifier();
 
-export default termAgainstConstructorUnifier;
+export default termWithConstructorUnifier;

package/src/unify/{conclusionAgainstStatement.js → conclusionWithStatement.js}

@@ -2,7 +2,7 @@
 
 import LocalContext from "../context/local";
 
-export default function unifyConclusionAgainstStatement(conclusionA, statementNodeB, substitutions, fileContextA, localContextB) {
+export default function unifyConclusionWithStatement(conclusionA, statementNodeB, substitutions, fileContextA, localContextB) {
   let conclusionUnified = false;
 
   const conclusionAStatementNode = conclusionA.getStatementNode();
@@ -15,7 +15,7 @@ export default function unifyConclusionAgainstStatement(conclusionA, statementNo
 
     substitutions.snapshot();
 
-    localContextB.trace(`Unifying the '${statementStringB}' statement against the conclusion's '${statementStringA}' statement...`, statementNodeB);
+    localContextB.trace(`Unifying the '${statementStringB}' statement with the conclusion's '${statementStringA}' statement...`, statementNodeB);
 
     const statementUnified = conclusionA.unifyStatement(statementNodeB, substitutions, localContextA, localContextB);
 
@@ -26,7 +26,7 @@ export default function unifyConclusionAgainstStatement(conclusionA, statementNo
         substitutions.rollback(localContextA, localContextB);
 
     if (conclusionUnified) {
-      localContextB.debug(`...unified the '${statementStringB}' statement against the conclusion's '${statementStringA}' statement.`, statementNodeB);
+      localContextB.debug(`...unified the '${statementStringB}' statement with the conclusion's '${statementStringA}' statement.`, statementNodeB);
     }
   }
 

package/src/unify/{consequentAgainstStatement.js → consequentWithStatement.js}

@@ -2,7 +2,7 @@
 
 import LocalContext from "../context/local";
 
-export default function unifyConsequentAgainstStatement(consequentA, statementNodeB, substitutions, fileContextA, localContextB) {
+export default function unifyConsequentWithStatement(consequentA, statementNodeB, substitutions, fileContextA, localContextB) {
   let consequentUnified = false;
 
   const consequentAStatementNode = consequentA.getStatementNode();
@@ -15,7 +15,7 @@ export default function unifyConsequentAgainstStatement(consequentA, statementNo
 
     substitutions.snapshot();
 
-    localContextB.trace(`Unifying the '${statementStringB}' statement against the consequent's '${statementStringA}' statement...`, statementNodeB);
+    localContextB.trace(`Unifying the '${statementStringB}' statement with the consequent's '${statementStringA}' statement...`, statementNodeB);
 
     const statementUnified = consequentA.unifyStatement(statementNodeB, substitutions, localContextA, localContextB);
 
@@ -26,7 +26,7 @@ export default function unifyConsequentAgainstStatement(consequentA, statementNo
         substitutions.rollback(localContextA, localContextB);
 
     if (consequentUnified) {
-      localContextB.debug(`...unified the '${statementStringB}' statement against the consequent's '${statementStringA}' statement.`, statementNodeB);
+      localContextB.debug(`...unified the '${statementStringB}' statement with the consequent's '${statementStringA}' statement.`, statementNodeB);
     }
   }
 

package/src/unify/{metavariableAgainstStatement.js → metavariableWithStatement.js}

@@ -1,15 +1,15 @@
 "use strict";
 
 import TermForVariableSubstitution from "../substitution/termForVariable";
-import unifyStatementAgainstStatement from "../unify/statementAtainstStatement";
+import unifyStatementWithStatement from "../unify/statementAtainstStatement";
 import StatementForMetavariableSubstitution from "../substitution/statementForMetavariable";
 
 import { nodeQuery } from "../utilities/query";
 
 const metavariableNodeQuery = nodeQuery("/statement/metavariable");
 
-export default function unifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB) {
-  let metavariableUnifiedAgainstStatement = false;
+export default function unifyMetavariableWithStatement(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB) {
+  let metavariableUnifiedWithStatement = false;
 
   const substitution = substitutions.findSubstitution((substitution) => {
     const substitutionMatchesMetavariableNodeA = substitution.matchMetavariableNode(metavariableNodeA);
@@ -28,10 +28,10 @@ export default function unifyMetavariableAgainstStatement(metavariableNodeA, sta
             localContext = localContextB,  ///
             substitution = termForVariableSubstitution, ///
             statementNodeA = substitutionStatementNode, ///
-            statementUnifiedAgainstStatement = unifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContext, localContext);
+            statementUnifiedWithStatement = unifyStatementWithStatement(statementNodeA, statementNodeB, substitution, substitutions, localContext, localContext);
 
-      if (statementUnifiedAgainstStatement) {
-        metavariableUnifiedAgainstStatement = true;
+      if (statementUnifiedWithStatement) {
+        metavariableUnifiedWithStatement = true;
       }
     } else {
       const substitutionSubstitution = substitution.getSubstitution();
@@ -43,16 +43,16 @@ export default function unifyMetavariableAgainstStatement(metavariableNodeA, sta
 
         const localContext = localContextB,  ///
               substitution = substitutionSubstitution,
-              statementUnifiedAgainstStatement = unifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContext, localContext);
+              statementUnifiedWithStatement = unifyStatementWithStatement(statementNodeA, statementNodeB, substitution, substitutions, localContext, localContext);
 
-        if (statementUnifiedAgainstStatement) {
-          metavariableUnifiedAgainstStatement = true;
+        if (statementUnifiedWithStatement) {
+          metavariableUnifiedWithStatement = true;
         }
       } else {
         const substitutionMatchesStatementNodeB = substitution.matchStatementNode(statementNodeB);
 
         if (substitutionMatchesStatementNodeB) {
-          metavariableUnifiedAgainstStatement = true;
+          metavariableUnifiedWithStatement = true;
         }
       }
     }
@@ -72,11 +72,11 @@ export default function unifyMetavariableAgainstStatement(metavariableNodeA, sta
         substitutions.addSubstitution(substitution, localContextA, localContextB);
       }
 
-      metavariableUnifiedAgainstStatement = true;
+      metavariableUnifiedWithStatement = true;
     }
   }
 
-  return metavariableUnifiedAgainstStatement;
+  return metavariableUnifiedWithStatement;
 }
 
 function metavariableFromStatementNode(statementNode, localContext) {

package/src/unify/{premiseAgainstProofStep.js → premiseWithProofStep.js}

@@ -2,7 +2,7 @@
 
 import { subproofNodeAsSubproofString } from "../utilities/unify";
 
-export default function unifyPremiseAgainstProofStep(premiseA, proofStepB, substitutions, localContextA, localContextB) {
+export default function unifyPremiseWithProofStep(premiseA, proofStepB, substitutions, localContextA, localContextB) {
   let premiseUnified = false;
 
   const premiseAStatementNode = premiseA.getStatementNode();
@@ -20,12 +20,12 @@ export default function unifyPremiseAgainstProofStep(premiseA, proofStepB, subst
     if (subproofNodeB !== null) {
       const subproofStringB = subproofNodeAsSubproofString(subproofNodeB, localContextB);
 
-      localContextB.trace(`Unifying the '${subproofStringB}' subproof against the premise's '${statementStringA}' statement...`, subproofNodeB);
+      localContextB.trace(`Unifying the '${subproofStringB}' subproof with the premise's '${statementStringA}' statement...`, subproofNodeB);
 
       const subproofUnified = premiseA.unifySubproof(subproofNodeB, substitutions, localContextA, localContextB);
 
       if (subproofUnified) {
-        localContextB.debug(`...unified the '${subproofStringB}' subproof against the premise's '${statementStringA}' statement.`, subproofNodeB);
+        localContextB.debug(`...unified the '${subproofStringB}' subproof with the premise's '${statementStringA}' statement.`, subproofNodeB);
 
         premiseUnified = true;
       }
@@ -34,12 +34,12 @@ export default function unifyPremiseAgainstProofStep(premiseA, proofStepB, subst
     if (statementNodeB !== null) {
       const statementStringB = localContextB.nodeAsString(statementNodeB);
 
-      localContextB.trace(`Unifying the '${statementStringB}' statement against the premise's '${statementStringA}' statement...`, statementNodeB);
+      localContextB.trace(`Unifying the '${statementStringB}' statement with the premise's '${statementStringA}' statement...`, statementNodeB);
 
       const statementUnified = premiseA.unifyStatement(statementNodeB, substitutions, localContextA, localContextB);
 
       if (statementUnified) {
-        localContextB.debug(`...unified the '${statementStringB}' statement against the premise's '${statementStringA}' statement.`, statementNodeB);
+        localContextB.debug(`...unified the '${statementStringB}' statement with the premise's '${statementStringA}' statement.`, statementNodeB);
 
         premiseUnified = true;
       }

package/src/unify/{premisesAgainstProofSteps.js → premisesWithProofSteps.js}

@@ -1,18 +1,18 @@
 "use strict";
 
 import LocalContext from "../context/local";
-import unifyPremiseAgainstProofStep from "../unify/premiseAgainstProofStep";
+import unifyPremiseWithProofStep from "../unify/premiseWithProofStep";
 
 import { reverse, correlate } from "../utilities/array";
 
-export default function unifyPremisesAgainstProofSteps(premisesA, proofStepsB, substitutions, fileContextA, localContextB) {
+export default function unifyPremisesWithProofSteps(premisesA, proofStepsB, substitutions, fileContextA, localContextB) {
   premisesA = reverse(premisesA); ///
 
   proofStepsB = reverse(proofStepsB); ///
 
   const premisesUnified = correlate(premisesA, proofStepsB, (premiseA, proofStepB) => {
     const localContextA = LocalContext.fromFileContext(fileContextA),
-          premiseUnified = unifyPremiseAgainstProofStep(premiseA, proofStepB, substitutions, localContextA, localContextB);
+          premiseUnified = unifyPremiseWithProofStep(premiseA, proofStepB, substitutions, localContextA, localContextB);
 
     if (premiseUnified) {
       return true;

package/src/unify/statementAtainstStatement.js

@@ -1,30 +1,30 @@
 "use strict";
 
+import Substitutions from "../substitutions";
 import metaLevelUnifier from "../unifier/metaLevel";
 import TermForVariableSubstitution from "../substitution/termForVariable";
 
 import { push } from "../utilities/array";
 
-export default function unifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB) {
-  let statementUnifiedAgainstStatement = false;
+export default function unifyStatementWithStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB) {
+  let statementUnifiedWithStatement = false;
 
-  const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionAndSubstitutions(substitution, substitutions),
-        transformed = termForVariableSubstitution.isTransformed(substitution);
+  const transformedSubstitutions = Substitutions.fromNothing(),
+        transformedSubstitution = substitution.transformed(substitutions);
 
-  let substitutionsA = []; ///
-
-  if (transformed) {
-    const substitutionA = termForVariableSubstitution;  ///
-
-    substitutionsA.push(substitutionA);
+  if (transformedSubstitution !== null) {
+    transformedSubstitutions.addSubstitution(transformedSubstitution, localContextA, localContextB);
   }
 
   const nodeA = statementNodeA,  ///
         nodeB = statementNodeB,  ///
-        unified = metaLevelUnifier.unify(nodeA, nodeB, substitutionsA, localContextA, localContextB);
+        unified = metaLevelUnifier.unify(nodeA, nodeB, transformedSubstitutions, localContextA, localContextB);
 
   if (unified) {
-    if (!transformed) {
+    if (transformedSubstitution === null) {
+
+      debugger
+
       const substitutionB = termForVariableSubstitution,  ///
             substitutionsB = [
               substitutionB
@@ -35,10 +35,10 @@ export default function unifyStatementAgainstStatement(statementNodeA, statement
       push(substitutions, substitutionsA);
     }
 
-    statementUnifiedAgainstStatement = true;
+    statementUnifiedWithStatement = true;
   }
 
-  return statementUnifiedAgainstStatement;
+  return statementUnifiedWithStatement;
 }
 
 function transformSubstitutions(substitutionsA, substitutionsB) {

package/src/unify/statementWithBracketedCombinator.js

@@ -0,0 +1,22 @@
+"use strict";
+
+import bracketedCombinator from "../ocmbinator/bracketed";
+import statementWithCombinatorUnifier from "../unifier/statementWithCombinator";
+
+export default function unifyStatementWithBracketedCombinator(statementNode, assignments, derived, localContext) {
+  let statementUnifiedWithBracketedCombinator;
+
+  const statementString = localContext.nodeAsString(statementNode);
+
+  localContext.trace(`Unifying the '${statementString}' statement with the bracketed combinator...`, statementNode);
+
+  const bracketedCombinatorStatementNode = bracketedCombinator.getStatementNode();
+
+  statementUnifiedWithBracketedCombinator = statementWithCombinatorUnifier.unify(statementNode, bracketedCombinatorStatementNode, assignments, derived, localContext);
+
+  if (statementUnifiedWithBracketedCombinator) {
+    localContext.debug(`...unified the '${statementString}' statement with the bracketed combinator.`, statementNode);
+  }
+
+  return statementUnifiedWithBracketedCombinator;
+}

package/src/unify/statementWithCombinators.js

@@ -0,0 +1,38 @@
+"use strict";
+
+import statementWithCombinatorUnifier from "../unifier/statementWithCombinator";
+
+export default function unifyStatementWithCombinators(statementNode, assignments, derived, localContext) {
+  let statementUnifiedWithCombinators;
+
+  const combinators = localContext.getCombinators();
+
+  statementUnifiedWithCombinators = combinators.some((combinator) => {
+    const statementUnifiedWithCombinator = unifyStatementWithCombinator(statementNode, combinator, assignments, derived, localContext);
+
+    if (statementUnifiedWithCombinator) {
+      return true;
+    }
+  });
+
+  return statementUnifiedWithCombinators;
+}
+
+function unifyStatementWithCombinator(statementNode, combinator, assignments, derived, localContext) {
+  let statementUnifiedWithCombinator;
+
+  const statementString = localContext.nodeAsString(statementNode),
+        combinatorString = combinator.getString();
+
+  localContext.trace(`Unifying the '${statementString}' statement with the '${combinatorString}' combinator...`, statementNode);
+
+  const combinatorStatementNode = combinator.getStatementNode();
+
+  statementUnifiedWithCombinator = statementWithCombinatorUnifier.unify(statementNode, combinatorStatementNode, assignments, derived, localContext);
+
+  if (statementUnifiedWithCombinator) {
+    localContext.debug(`...unified the '${statementString}' statement with the '${combinatorString}' combinator.`, statementNode);
+  }
+
+  return statementUnifiedWithCombinator;
+}

package/src/unify/statementWithMetaType.js

@@ -0,0 +1,14 @@
+"use strict";
+
+import verifyStatementGivenMetaType from "../verify/statementGivenMetaType";
+
+export default function unifyStatementWithMetaType(statementNode, metaTypeNode, assignments, derived, localContext) {
+  let statementUnifiedWithMetaType;
+
+  const metaType = localContext.findMetaTypeByMetaTypeNode(metaTypeNode),
+        statementVerifiedGivenMetaType = verifyStatementGivenMetaType(statementNode, metaType, assignments, derived, localContext);
+
+  statementUnifiedWithMetaType = statementVerifiedGivenMetaType;  ///
+
+  return statementUnifiedWithMetaType;
+}

package/src/unify/{suppositionAgainstProofStep.js → suppositionWithProffStep.js}

@@ -2,7 +2,7 @@
 
 import { subproofNodeAsSubproofString } from "../utilities/unify";
 
-export default function unifySuppositionAgainstProofStep(suppositionA, proofStepB, substitutions, localContextA, localContextB) {
+export default function unifySuppositionWithProofStep(suppositionA, proofStepB, substitutions, localContextA, localContextB) {
   let suppositionUnified = false;
 
   const suppositionAStatementNode = suppositionA.getStatementNode();
@@ -20,12 +20,12 @@ export default function unifySuppositionAgainstProofStep(suppositionA, proofStep
     if (subproofNodeB !== null) {
       const subproofStringB = subproofNodeAsSubproofString(subproofNodeB, localContextB);
 
-      localContextB.trace(`Unifying the '${subproofStringB}' subproof against the supposition's '${statementStringA}' statement...`, subproofNodeB);
+      localContextB.trace(`Unifying the '${subproofStringB}' subproof with the supposition's '${statementStringA}' statement...`, subproofNodeB);
 
       const subproofUnified = suppositionA.unifySubproof(subproofNodeB, substitutions, localContextA, localContextB);
 
       if (subproofUnified) {
-        localContextB.debug(`...unified the '${subproofStringB}' subproof against the supposition's '${statementStringA}' statement.`, subproofNodeB);
+        localContextB.debug(`...unified the '${subproofStringB}' subproof with the supposition's '${statementStringA}' statement.`, subproofNodeB);
 
         suppositionUnified = true;
       }
@@ -34,12 +34,12 @@ export default function unifySuppositionAgainstProofStep(suppositionA, proofStep
     if (statementNodeB !== null) {
       const statementStringB = localContextB.nodeAsString(statementNodeB);
 
-      localContextB.trace(`Unifying the '${statementStringB}' statement against the supposition's '${statementStringA}' statement...`, statementNodeB);
+      localContextB.trace(`Unifying the '${statementStringB}' statement with the supposition's '${statementStringA}' statement...`, statementNodeB);
 
       const statementUnified = suppositionA.unifyStatement(statementNodeB, substitutions, localContextA, localContextB);
 
       if (statementUnified) {
-        localContextB.debug(`...unified the '${statementStringB}' statement against the supposition's '${statementStringA}' statement.`, statementNodeB);
+        localContextB.debug(`...unified the '${statementStringB}' statement with the supposition's '${statementStringA}' statement.`, statementNodeB);
 
         suppositionUnified = true;
       }

package/src/unify/{suppositionsAgainstProofSteps.js → suppositionsWithProofSteps.js}

@@ -1,18 +1,18 @@
 "use strict";
 
 import LocalContext from "../context/local";
-import unifySuppositionAgainstProofStep from "./suppositionAgainstProofStep";
+import unifySuppositionWithProofStep from "./suppositionWithProffStep";
 
 import { reverse, correlate } from "../utilities/array";
 
-export default function unifySuppositionsAgainstProofSteps(suppositionsA, proofStepsB, substitutions, fileContextA, localContextB) {
+export default function unifySuppositionsWithProofSteps(suppositionsA, proofStepsB, substitutions, fileContextA, localContextB) {
   suppositionsA = reverse(suppositionsA); ///
 
   proofStepsB = reverse(proofStepsB); ///
 
   const suppositionsUnified = correlate(suppositionsA, proofStepsB, (suppositionA, proofStepB) => {
     const localContextA = LocalContext.fromFileContext(fileContextA),
-          suppositionUnified = unifySuppositionAgainstProofStep(suppositionA, proofStepB, substitutions, localContextA, localContextB);
+          suppositionUnified = unifySuppositionWithProofStep(suppositionA, proofStepB, substitutions, localContextA, localContextB);
 
     if (suppositionUnified) {
       return true;

package/src/unify/termWithBracketedConstructor.js

@@ -0,0 +1,36 @@
+"use strict";
+
+import bracketedConstructor from "../constructor/bracketed";
+
+import { nodeQuery } from "../utilities/query";
+
+const termNodeQuery = nodeQuery("/term/argument/term");
+
+export default function unifyTermWithBracketedConstructor(termNode, terms, localContext, verifyAhead) {
+  let termUnifiedWithBracketedConstructor;
+
+  const termString = localContext.nodeAsString(termNode),
+        bracketedTerms = [];
+
+  localContext.trace(`Unifying the '${termString}' term with the bracketed constructor...`, termNode);
+
+  termUnifiedWithBracketedConstructor = unifyTermWithConstructor(termNode, bracketedTerms, bracketedConstructor, localContext, () => {
+    let verifiedAhead;
+
+    const bracketedTermNode = termNode; ///
+
+    termNode = termNodeQuery(bracketedTermNode); ///
+
+    const termVVerified = verifyTerm(termNode, terms, localContext, verifyAhead);
+
+    verifiedAhead = termVVerified;  ///
+
+    return verifiedAhead;
+  });
+
+  if (termUnifiedWithBracketedConstructor) {
+    localContext.debug(`...unified the '${termString}' term with the bracketed constructor.`, termNode);
+  }
+
+  return termUnifiedWithBracketedConstructor;
+}

package/src/unify/termWithConstructors.js

@@ -0,0 +1,63 @@
+"use strict";
+
+import Term from "../term";
+import termWithConstructorUnifier from "../unifier/termWithConstructor";
+
+import { nodeQuery } from "../utilities/query";
+
+const variableNodeQuery = nodeQuery("/term/variable!");
+
+export default function unifyTermWithConstructors(termNode, terms, localContext, verifyAhead) {
+  let termUnifiedWithConstructors = false;
+
+  const variableNode = variableNodeQuery(termNode);
+
+  if (variableNode === null) {
+    const constructors = localContext.getConstructors();
+
+    termUnifiedWithConstructors = constructors.some((constructor) => {
+      const termUnifiedWithConstructor = unifyTermWithConstructor(termNode, terms, constructor, localContext, verifyAhead);
+
+      if (termUnifiedWithConstructor) {
+        return true;
+      }
+    });
+  }
+
+  return termUnifiedWithConstructors;
+}
+
+function unifyTermWithConstructor(termNode, terms, constructor, localContext, verifyAhead) {
+  let termUnifiedWithConstructor = false;
+
+  const termString = localContext.nodeAsString(termNode),
+        constructorString = constructor.getString(),
+        constructorTermNode = constructor.getTermNode();
+
+  localContext.trace(`Unifying the '${termString}' term with the '${constructorString}' constructor...`, termNode);
+
+  const termNodeA = termNode,  ///
+        constructorTermNodeB = constructorTermNode,  ///
+        unified = termWithConstructorUnifier.unify(termNodeA, constructorTermNodeB, localContext);
+
+  if (unified) {
+    let verifiedAhead;
+
+    const type = constructor.getType(),
+          term = Term.fromTermNodeAndType(termNode, type);
+
+    terms.push(term);
+
+    verifiedAhead = verifyAhead();
+
+    terms.pop();
+
+    termUnifiedWithConstructor = verifiedAhead;  ///
+  }
+
+  if (termUnifiedWithConstructor) {
+    localContext.debug(`...unified the '${termString}' term with the '${constructorString}' constructor.`, termNode);
+  }
+
+  return termUnifiedWithConstructor;
+}