occam-verify-cli 0.0.959 → 0.0.960

package/src/releaseContext/{verify.js → initialise.js}

@@ -1,7 +1,7 @@
 "use strict";
 
-export default function verifyReleaseContext(dependency, dependentName, dependentReleased, context) {
-  let releaseContextVerified = false;
+export default function initialiseReleaseContext(dependency, dependentName, dependentReleased, context) {
+  let releaseContextInitialised = false;
 
   const { releaseContextMap } = context,
         dependencyName = dependency.getName(),
@@ -11,44 +11,37 @@ export default function verifyReleaseContext(dependency, dependentName, dependen
   if (releaseContext === null) {
     const { log } = context;
 
-    log.error(`Unable to verify the '${dependencyName}' dependency's context because it has not been created.`);
+    log.warning(`Unable to initialise the '${dependencyName}' ontext because it has not been created.`);
   } else {
-    const verified = releaseContext.isVerified();
+    releaseContextInitialised = releaseContext.isInitialised();
 
-    if (verified) {
-      releaseContextVerified = true;
-    } else {
+    if (!releaseContextInitialised) {
       const released = releaseContext.isReleased();
 
       if (!released && dependentReleased) {
         const { log } = context;
 
-        log.error(`Unable to verify the '${dependencyName}' dependency's context because its '${dependentName}' dependent is a package.`);
+        log.warning(`Unable to initialise the '${dependencyName}' dependency's context because its '${dependentName}' dependent is a package.`);
       } else {
-        const dependencies = releaseContext.getDependencies();
+        const dependencyReleaseContextsInitialised = initialiseDependencyReleaseContexts(dependency, releaseContext, released, context);
 
-        dependentName = dependencyName;  ///
+        if (dependencyReleaseContextsInitialised) {
+          const { log } = context,
+                releaseContexts = retrieveReleaseContexts(releaseContext, releaseContextMap);
 
-        dependentReleased = released;  ///
+          log.debug(`Initialising the '${dependencyName}' context...`);
 
-        releaseContextVerified = dependencies.everyDependency((dependency) => {  ///
-          const releaseContextVerified = verifyReleaseContext(dependency, dependentName, dependentReleased, context);
+          releaseContextInitialised = releaseContext.initialise(releaseContexts);
 
-          if (releaseContextVerified) {
-            return true;
-          }
-        });
-
-        if (releaseContextVerified) {
-          const releaseContexts = retrieveReleaseContexts(releaseContext, releaseContextMap);
-
-          releaseContext.verify(releaseContexts);
+          releaseContextInitialised ?
+            log.info(`...initialised the '${dependencyName}' context.`) :
+              log.warning(`...unable to initialise the '${dependencyName}' context.`);
         }
       }
     }
   }
 
-  return releaseContextVerified;
+  return releaseContextInitialised;
 }
 
 function retrieveReleaseContexts(releaseContext, releaseContextMap) {
@@ -87,3 +80,19 @@ function retrieveReleaseContexts(releaseContext, releaseContextMap) {
 
   return releaseContexts;
 }
+
+function initialiseDependencyReleaseContexts(dependency, releaseContext, released, context) {
+  const dependencyName = dependency.getName(),
+        dependentName = dependencyName,  ///
+        dependencies = releaseContext.getDependencies(),
+        dependentReleased = released,  ///
+        dependencyReleaseContextsInitialised = dependencies.everyDependency((dependency) => {  ///
+          const releaseContextInitialised = initialiseReleaseContext(dependency, dependentName, dependentReleased, context);
+
+          if (releaseContextInitialised) {
+            return true;
+          }
+        });
+
+  return dependencyReleaseContextsInitialised;
+}

package/src/rule.js

@@ -1,8 +1,8 @@
 "use strict";
 
 import Substitutions from "./substitutions";
-import unifyPremisesAgainstProofSteps from "./unify/premisesAgainstProofSteps";
-import unifyConclusionAgainstStatement from "./unify/conclusionAgainstStatement";
+import unifyPremisesWithProofSteps from "./unify/premisesWithProofSteps";
+import unifyConclusionWithStatement from "./unify/conclusionWithStatement";
 
 export default class Rule {
   constructor(labels, premises, conclusion, fileContext) {
@@ -37,11 +37,11 @@ export default class Rule {
           proofStepsB = proofSteps, ///
           fileContextA = this.fileContext,  ///
           localContextB = localContext, ///
-          premisesUnified = unifyPremisesAgainstProofSteps(premisesA, proofStepsB, substitutions, fileContextA, localContextB);
+          premisesUnified = unifyPremisesWithProofSteps(premisesA, proofStepsB, substitutions, fileContextA, localContextB);
 
     if (premisesUnified) {
       const conclusionA = this.conclusion,  ///
-            conclusionUnified = unifyConclusionAgainstStatement(conclusionA, statementNode, substitutions, fileContextA, localContextB);
+            conclusionUnified = unifyConclusionWithStatement(conclusionA, statementNode, substitutions, fileContextA, localContextB);
 
       statementUnified = conclusionUnified;  ///
     }

package/src/substitution/statementForMetavariable.js

@@ -3,7 +3,7 @@
 import shim from "../shim";
 import Substitution from "../substitution";
 import TermForVariableSubstitution from "./termForVariable";
-import unifyStatementAgainstStatement from "../unify/statementAtainstStatement";
+import unifyStatementWithStatement from "../unify/statementAtainstStatement";
 
 import { nodeQuery } from "../utilities/query";
 import { matchStatementModuloBrackets, bracketedStatementChildNodeFromStatementNode } from "../utilities/match";
@@ -74,8 +74,8 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return statementNodeMatches;
   }
 
-  unifyAgainstEquivalence(equivalence, substitutions, localContextA, localContextB) {
-    let unifiedAgainstEquivalence = false;  ///
+  unifyWithEquivalence(equivalence, substitutions, localContextA, localContextB) {
+    let unifiedWithEquivalence = false;  ///
 
     const metavariableNode = metavariableNodeQuery(this.statementNode);
 
@@ -89,10 +89,10 @@ export default class StatementForMetavariableSubstitution extends Substitution {
             nodeB = metavariableNode, ///
             unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
 
-      unifiedAgainstEquivalence = unified; ///
+      unifiedWithEquivalence = unified; ///
     }
 
-    return unifiedAgainstEquivalence;
+    return unifiedWithEquivalence;
   }
 
   asString(localContextA, localContextB) {
@@ -156,9 +156,9 @@ function unifyStatement(statementNodeA, statementNodeB, substitution, substituti
 
     statementUnified = statementNodeAMatchesStatementNodeB; ///
   } else {
-    const statementUnifiedAgainstStatement = unifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
+    const statementUnifiedWithStatement = unifyStatementWithStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
 
-    statementUnified = statementUnifiedAgainstStatement; ///
+    statementUnified = statementUnifiedWithStatement; ///
   }
 
   return statementUnified;

package/src/substitution/termForVariable.js

@@ -51,8 +51,8 @@ export default class TermForVariableSubstitution extends Substitution {
     return matchesVariableNode;
   }
 
-  unifyAgainstEquivalence(equivalence, substitutions, localContextA, localContextB) {
-    let unifiedAgainstEquivalence;
+  unifyWithEquivalence(equivalence, substitutions, localContextA, localContextB) {
+    let unifiedWithEquivalence;
 
     const equivalenceMatchesVariableNode = equivalence.matchVariableNode(this.variableNode);
 
@@ -60,11 +60,11 @@ export default class TermForVariableSubstitution extends Substitution {
       const equivalenceMatchesTermNode = equivalence.matchTermNode(this.termNode);
 
       if (equivalenceMatchesTermNode) {
-        unifiedAgainstEquivalence = true;
+        unifiedWithEquivalence = true;
       }
     }
 
-    return unifiedAgainstEquivalence;
+    return unifiedWithEquivalence;
   }
 
   asString(localContextA, localContextB) {

package/src/substitution.js

@@ -25,15 +25,15 @@ export default class Substitution {
     return matchesMetavariableNode;
   }
 
-  unifyAgainstEquivalences(equivalences, substitutions, localContextA, localContextB) {
-    const unifiedAgainstEquivalences = equivalences.some((equivalence) => {
-      const substitutionUnifiedAgainstEquivalence = this.unifyAgainstEquivalence(equivalence, substitutions, localContextA, localContextB);
+  unifyWithEquivalences(equivalences, substitutions, localContextA, localContextB) {
+    const unifiedWithEquivalences = equivalences.some((equivalence) => {
+      const substitutionUnifiedWithEquivalence = this.unifyWithEquivalence(equivalence, substitutions, localContextA, localContextB);
 
-      if (substitutionUnifiedAgainstEquivalence) {
+      if (substitutionUnifiedWithEquivalence) {
         return true;
       }
     });
 
-    return unifiedAgainstEquivalences;
+    return unifiedWithEquivalences;
   }
 }

package/src/substitutions.js

@@ -55,17 +55,17 @@ export default class Substitutions {
     localContextB.trace(`Removed the '${substitutionString}' substitution.`, substitutionNode);
   }
 
-  unifyAgainstEquivalences(equivalences, localContextA, localContextB) {
-    const unifiedAgainstEquivalences = this.everySubstitution((substitution) => {
+  unifyWithEquivalences(equivalences, localContextA, localContextB) {
+    const unifiedWithEquivalences = this.everySubstitution((substitution) => {
       const substitutions = this, ///
-            substitutionUnifiedAgainstEquivalence = substitution.unifyAgainstEquivalences(equivalences, substitutions, localContextA, localContextB);
+            substitutionUnifiedWithEquivalence = substitution.unifyWithEquivalences(equivalences, substitutions, localContextA, localContextB);
 
-      if (substitutionUnifiedAgainstEquivalence) {
+      if (substitutionUnifiedWithEquivalence) {
         return true;
       }
     });
 
-    return unifiedAgainstEquivalences;
+    return unifiedWithEquivalences;
   }
 
   snapshot() {

package/src/topLevelAssertion.js

@@ -1,8 +1,8 @@
 "use strict";
 
 import Substitutions from "./substitutions";
-import unifyConsequentAgainstStatement from "./unify/consequentAgainstStatement";
-import unifySuppositionsAgainstProofSteps from "./unify/suppositionsAgainstProofSteps";
+import unifyConsequentWithStatement from "./unify/consequentWithStatement";
+import unifySuppositionsWithProofSteps from "./unify/suppositionsWithProofSteps";
 
 export default class TopLevelAssertion {
   constructor(labels, suppositions, consequent, substitutions, fileContext) {
@@ -42,11 +42,11 @@ export default class TopLevelAssertion {
           fileContextA = this.fileContext,  ///
           suppositionsA = this.suppositions,  ///
           localContextB = localContext, ///
-          suppositionsUnified = unifySuppositionsAgainstProofSteps(suppositionsA, proofStepsB, substitutions, fileContextA, localContextB);
+          suppositionsUnified = unifySuppositionsWithProofSteps(suppositionsA, proofStepsB, substitutions, fileContextA, localContextB);
 
     if (suppositionsUnified) {
       const consequentA = this.consequent,  ///
-            consequentUnified = unifyConsequentAgainstStatement(consequentA, statementNode, substitutions, fileContextA, localContext);
+            consequentUnified = unifyConsequentWithStatement(consequentA, statementNode, substitutions, fileContextA, localContext);
 
       statementUnified = consequentUnified;  ///
     }

package/src/unifier/equality.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import Unifier from "../unifier";
-import unifyTermAgainstTerm from "../unify/termAgainstTerm";
+import unifyTermWithTerm from "../unify/termWithTerm";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -25,14 +25,14 @@ class EqualityUnifier extends Unifier {
       nodeQueryA: termNodeQuery,
       nodeQueryB: termNodeQuery,
       unify: (termNodeA, termNodeB, localContext) => {
-        let termUnifiedAgainstTerm;
+        let termUnifiedWithTerm;
 
         const leftTermNode = termNodeA, ///
               rightTermNode = termNodeB;  ///
 
-        termUnifiedAgainstTerm = unifyTermAgainstTerm(leftTermNode, rightTermNode, localContext);
+        termUnifiedWithTerm = unifyTermWithTerm(leftTermNode, rightTermNode, localContext);
 
-        if (!termUnifiedAgainstTerm) {
+        if (!termUnifiedWithTerm) {
           const nonTerminalNodeA = termNodeA, ///
                 nonTerminalNodeB = termNodeB, ///
                 nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
@@ -41,10 +41,10 @@ class EqualityUnifier extends Unifier {
                 childNodesB = nonTerminalNodeBChildNodes, ///
                 childNodesVerified = equalityUnifier.unifyChildNodes(childNodesA, childNodesB, localContext);
 
-          termUnifiedAgainstTerm = childNodesVerified; ///
+          termUnifiedWithTerm = childNodesVerified; ///
         }
 
-        return termUnifiedAgainstTerm;
+        return termUnifiedWithTerm;
       }
     }
   ];

package/src/unifier/intrinsicLevel.js

@@ -2,7 +2,7 @@
 
 import shim from "../shim";
 import Unifier from "../unifier";
-import unifyVariableAgainstTerm from "../unify/variableAgainstTerm";
+import unifyVariableWithTerm from "../unify/variableWithTerm";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -28,9 +28,9 @@ class IntrinsicLevelUnifier 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/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/{statementAgainstCombinator.js → statementWithCombinator.js}

@@ -1,8 +1,8 @@
 "use strict";
 
 import Unifier from "../unifier";
-import unifyTermAgainstType from "../unify/termAgainstType";
-import unifyStatementAgainstMetaType from "../unify/statementAgainstMetaType";
+import unifyTermWithType from "../unify/termWithType";
+import unifyStatementWithMetaType from "../unify/statementWithMetaType";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -11,17 +11,17 @@ const termNodeQuery = nodeQuery("/term!"),
       metaTypeNodeQuery = nodeQuery("/metaType!"),
       statementNodeQuery = nodeQuery("/statement!");
 
-class StatementAgainstCombinatorUnifier extends Unifier {
+class StatementWithCombinatorUnifier extends Unifier {
   unify(statementNode, combinatorStatementNode, localContext) {
-    let statementUnifiedAgainstCombinator;
+    let statementUnifiedWithCombinator;
 
     const nonTerminalNodeA = statementNode, ///
           nonTerminalNodeB = combinatorStatementNode, ///
           nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext);
 
-    statementUnifiedAgainstCombinator = nonTerminalNodeUnified; ///
+    statementUnifiedWithCombinator = nonTerminalNodeUnified; ///
 
-    return statementUnifiedAgainstCombinator;
+    return statementUnifiedWithCombinator;
   };
 
   static maps = [
@@ -31,9 +31,9 @@ class StatementAgainstCombinatorUnifier extends Unifier {
       unify: (statementNodeA, metaTypeNodeB, localContext) => {
         const metaTypeNode = metaTypeNodeB, ///
               statementNode = statementNodeA, ///
-              statementUnifiedAgainstMetaType = unifyStatementAgainstMetaType(statementNode, metaTypeNode, localContext);
+              statementUnifiedWithMetaType = unifyStatementWithMetaType(statementNode, metaTypeNode, localContext);
 
-        return statementUnifiedAgainstMetaType;
+        return statementUnifiedWithMetaType;
       }
     },
     {
@@ -42,14 +42,14 @@ class StatementAgainstCombinatorUnifier 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 statementAgainstCombinatorUnifier = new StatementAgainstCombinatorUnifier();
+const statementWithCombinatorUnifier = new StatementWithCombinatorUnifier();
 
-export default statementAgainstCombinatorUnifier;
+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;
       }