occam-verify-cli 0.0.959 → 0.0.960

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

@@ -5,8 +5,8 @@ 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 statementUnifiedWithtatement = false;
 
   const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionAndSubstitutions(substitution, substitutions),
         transformed = termForVariableSubstitution.isTransformed(substitution);
@@ -35,10 +35,10 @@ export default function unifyStatementAgainstStatement(statementNodeA, statement
       push(substitutions, substitutionsA);
     }
 
-    statementUnifiedAgainstStatement = true;
+    statementUnifiedWithtatement = true;
   }
 
-  return statementUnifiedAgainstStatement;
+  return statementUnifiedWithtatement;
 }
 
 function transformSubstitutions(substitutionsA, substitutionsB) {

package/src/unify/{statementAgainstMetaType.js → statementWithMetaType.js}

@@ -8,8 +8,8 @@ import { FRAME_META_TYPE_NAME, STATEMENT_META_TYPE_NAME } from "../metaTypeNames
 const metavariableNodeQuery = nodeQuery("/statement/metavariable"),
       metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type!");
 
-export default function unifyStatementAgainstMetaType(statementNode, metaTypeNode, localContext) {
-  let statementUnifiedAgainstMetaType = false;
+export default function unifyStatementWithMetaType(statementNode, metaTypeNode, localContext) {
+  let statementUnifiedWithMetaType = false;
 
   const metaTypeTerminalNode = metaTypeTerminalNodeQuery(metaTypeNode),
         metaTypeTerminalNodeContent = metaTypeTerminalNode.getContent(),
@@ -26,7 +26,7 @@ export default function unifyStatementAgainstMetaType(statementNode, metaTypeNod
           const metavariableMetaTypeName = metavariable.getMetaTypeName();
 
           if (metavariableMetaTypeName === metaTypeName) {
-            statementUnifiedAgainstMetaType = true;
+            statementUnifiedWithMetaType = true;
           }
         }
       }
@@ -40,11 +40,11 @@ export default function unifyStatementAgainstMetaType(statementNode, metaTypeNod
             assignments = [],
             statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
 
-      statementUnifiedAgainstMetaType = statementVerified;
+      statementUnifiedWithMetaType = statementVerified;
 
       break;
     }
   }
 
-  return statementUnifiedAgainstMetaType;
+  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/{termAgainstTerm.js → termWithTerm.js}

@@ -2,15 +2,15 @@
 
 import { areTermNodesEqual } from "../utilities/equivalences";
 
-export default function unifyTermAgainstTerm(leftTermNode, rightTermNode, localContext) {
-  let termUnifiedAgainstTerm = false;
+export default function unifyTermWithTerm(leftTermNode, rightTermNode, localContext) {
+  let termUnifiedWithTerm = false;
 
   const equivalences = localContext.getEquivalences(),
         termNodesEqual = areTermNodesEqual(leftTermNode, rightTermNode, equivalences);
 
   if (termNodesEqual) {
-    termUnifiedAgainstTerm = true;
+    termUnifiedWithTerm = true;
   }
 
-  return termUnifiedAgainstTerm;
+  return termUnifiedWithTerm;
 }

package/src/unify/{termAgainstType.js → termWithType.js}

@@ -4,8 +4,8 @@ import shim from "../shim";
 
 import { first } from "../utilities/array";
 
-export default function unifyTermAgainstType(termNode, typeNode, localContext) {
-  let termUnifiedAgainstType;
+export default function unifyTermWithType(termNode, typeNode, localContext) {
+  let termUnifiedWithType;
 
   const { verifyTerm } = shim,
         terms = [],
@@ -25,7 +25,7 @@ export default function unifyTermAgainstType(termNode, typeNode, localContext) {
           return verifiedAhead;
         });
 
-  termUnifiedAgainstType = termVerified; ///
+  termUnifiedWithType = termVerified; ///
 
-  return termUnifiedAgainstType;
+  return termUnifiedWithType;
 }

package/src/unify/{variableAgainstTerm.js → variableWithTerm.js}

@@ -6,8 +6,8 @@ import { nodeQuery } from "../utilities/query";
 
 const variableNodeQuery = nodeQuery("/term/variable");
 
-export default function unifyVariableAgainstTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB) {
-  let variableUnifiedAgainstTerm = false;
+export default function unifyVariableWithTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB) {
+  let variableUnifiedWithTerm = false;
 
   const substitution = substitutions.findSubstitution((substitution) => {
     const substitutionMatchesVariableNodeA = substitution.matchVariableNode(variableNodeA);
@@ -21,7 +21,7 @@ export default function unifyVariableAgainstTerm(variableNodeA, termNodeB, subst
     const substitutionMatchesTermNodeB = substitution.matchTermNode(termNodeB);
 
     if (substitutionMatchesTermNodeB) {
-      variableUnifiedAgainstTerm = true;
+      variableUnifiedWithTerm = true;
     }
   } else {
     const variableA = localContextA.findVariableByVariableNode(variableNodeA);
@@ -38,11 +38,11 @@ export default function unifyVariableAgainstTerm(variableNodeA, termNodeB, subst
         substitutions.addSubstitution(substitution, localContextA, localContextB);
       }
 
-      variableUnifiedAgainstTerm = true;
+      variableUnifiedWithTerm = true;
     }
   }
 
-  return variableUnifiedAgainstTerm;
+  return variableUnifiedWithTerm;
 }
 
 function variableFromTermNode(termNode, localContext) {

package/src/verify/error.js

@@ -5,7 +5,7 @@ export default function verifyError(errorNode, fileContext) {
 
   const errorString = fileContext.nodeAsString(errorNode)
 
-  fileContext.debug(`The '${errorString}' cannot be verified.`, errorNode);
+  fileContext.debug(`The '${errorString}' error cannot be verified.`, errorNode);
 
   return errorVerified;
 }

package/src/verify/judgement.js

@@ -70,10 +70,10 @@ function verifyDerivedJudgement(judgementNode, assignments, derived, localContex
                   metaLemmaMetatheorem = (metaLemma || metatheorem);  ///
 
             if (metaLemmaMetatheorem !== null) {
-              const metaLemmaMetatheoremUnifiedAgainstDeclaration = declaration.unifyMetaLemmaOrMetaTheorem(metaLemmaMetatheorem),
-                    metaLemmaMetatheoremUnifiedAgainstJudgement = judgement.unifyMetaLemmaOrMetaTheorem(metaLemmaMetatheorem);
+              const metaLemmaMetatheoremUnifiedWithDeclaration = declaration.unifyMetaLemmaOrMetaTheorem(metaLemmaMetatheorem),
+                    metaLemmaMetatheoremUnifiedWithJudgement = judgement.unifyMetaLemmaOrMetaTheorem(metaLemmaMetatheorem);
 
-              derivedJudgementVerified = (metaLemmaMetatheoremUnifiedAgainstDeclaration && metaLemmaMetatheoremUnifiedAgainstJudgement);
+              derivedJudgementVerified = (metaLemmaMetatheoremUnifiedWithDeclaration && metaLemmaMetatheoremUnifiedWithJudgement);
             } else {
               const metavariableString = localContext.nodeAsString(metavariableNode);
 

package/src/verify/metavariable.js

@@ -1,8 +1,8 @@
 "use strict";
 
 import { nodeQuery } from "../utilities/query";
+import { unifyTermWithTermType } from "../metavariable";
 import { nameFromMetavariableNode } from "../utilities/name";
-import { unifyTermAgainstTermType } from "../metavariable";
 
 const termNodeQuery = nodeQuery("/metavariable/argument/term"),
       typeNodeQuery = nodeQuery("/metavariable/argument/type");
@@ -43,9 +43,9 @@ export default function verifyMetavariable(metavariableNode, localContext) {
 
         localContext.debug(`No term was found when the metavariable's term type is '${termTypeName}'.`, termNode);
       } else {
-        const termUnifiedAgainstTermType = unifyTermAgainstTermType(termNode, termType, localContext);
+        const termUnifiedWithTermType = unifyTermWithTermType(termNode, termType, localContext);
 
-        metavariableVerified = termUnifiedAgainstTermType; ///
+        metavariableVerified = termUnifiedWithTermType; ///
       }
     }
   }

package/src/verify/statement/qualified.js

@@ -3,7 +3,7 @@
 import verifyEquality from "../equality";
 import verifyJudgement from "../judgement";
 import verifyTypeAssertion from "../assertion/type";
-import unifyMetavariableAgainstStatement from "../../unify/metavariableAgainstStatement";
+import unifyMetavariableWithStatement from "../../unify/metavariableWithStatement";
 
 import { nodeQuery } from "../../utilities/query";
 
@@ -21,12 +21,12 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, substit
   localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement...`, qualifiedStatementNode);
 
   const unifyQualifiedStatementFunctions = [
-    unifyQualifiedStatementAAgainstRule,
-    unifyQualifiedStatementAAgainstAxiom,
-    unifyQualifiedStatementAAgainstLemma,
-    unifyQualifiedStatementAAgainstTheorem,
-    unifyQualifiedStatementAAgainstConjecture,
-    unifyQualifiedStatementAAgainstReference
+    unifyQualifiedStatementAWithRule,
+    unifyQualifiedStatementAWithAxiom,
+    unifyQualifiedStatementAWithLemma,
+    unifyQualifiedStatementAWithTheorem,
+    unifyQualifiedStatementAWithConjecture,
+    unifyQualifiedStatementAWithReference
   ];
 
   const qualifiedStatementUnified = unifyQualifiedStatementFunctions.some((unifyQualifiedStatementFunction) => {  ///
@@ -52,8 +52,8 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, substit
   return qualifiedStatementVerified;
 }
 
-function unifyQualifiedStatementAAgainstRule(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementUnifiedAgainstRule = false;
+function unifyQualifiedStatementAWithRule(qualifiedStatementNode, substitutions, localContext) {
+  let qualifiedStatementUnifiedWithRule = false;
 
   const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
         rule = localContext.findRuleByMetavariableNode(metavariableNode);
@@ -63,22 +63,22 @@ function unifyQualifiedStatementAAgainstRule(qualifiedStatementNode, substitutio
           metavariableString = localContext.nodeAsString(metavariableNode),
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' rule...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' rule...`, qualifiedStatementNode);
 
     const ruleMatchesStatement = rule.unifyStatement(statementNode, localContext);
 
-    qualifiedStatementUnifiedAgainstRule = ruleMatchesStatement;  ///
+    qualifiedStatementUnifiedWithRule = ruleMatchesStatement;  ///
 
-    if (qualifiedStatementUnifiedAgainstRule) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' rule.`, qualifiedStatementNode);
+    if (qualifiedStatementUnifiedWithRule) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' rule.`, qualifiedStatementNode);
     }
   }
 
-  return qualifiedStatementUnifiedAgainstRule;
+  return qualifiedStatementUnifiedWithRule;
 }
 
-function unifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementUnifiedAgainstAxiom = false;
+function unifyQualifiedStatementAWithAxiom(qualifiedStatementNode, substitutions, localContext) {
+  let qualifiedStatementUnifiedWithAxiom = false;
 
   const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
         axiom = localContext.findAxiomByMetavariableNode(metavariableNode);
@@ -88,22 +88,22 @@ function unifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, substituti
           metavariableString = localContext.nodeAsString(metavariableNode),
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' axiom...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' axiom...`, qualifiedStatementNode);
 
     const axiomMatchesStatement = axiom.unifyStatement(statementNode, localContext);
 
-    qualifiedStatementUnifiedAgainstAxiom = axiomMatchesStatement; ///
+    qualifiedStatementUnifiedWithAxiom = axiomMatchesStatement; ///
 
-    if (qualifiedStatementUnifiedAgainstAxiom) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' axiom.`, qualifiedStatementNode);
+    if (qualifiedStatementUnifiedWithAxiom) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' axiom.`, qualifiedStatementNode);
     }
   }
 
-  return qualifiedStatementUnifiedAgainstAxiom;
+  return qualifiedStatementUnifiedWithAxiom;
 }
 
-function unifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementUnifiedAgainstLemma = false;
+function unifyQualifiedStatementAWithLemma(qualifiedStatementNode, substitutions, localContext) {
+  let qualifiedStatementUnifiedWithLemma = false;
 
   const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
         lemma = localContext.findLemmaByMetavariableNode(metavariableNode);
@@ -113,22 +113,22 @@ function unifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, substituti
           metavariableString = localContext.nodeAsString(metavariableNode),
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' lemma...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' lemma...`, qualifiedStatementNode);
 
     const lemmaMatchesStatement = lemma.unifyStatement(statementNode, localContext);
 
-    qualifiedStatementUnifiedAgainstLemma = lemmaMatchesStatement; ///
+    qualifiedStatementUnifiedWithLemma = lemmaMatchesStatement; ///
 
-    if (qualifiedStatementUnifiedAgainstLemma) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' lemma.`, qualifiedStatementNode);
+    if (qualifiedStatementUnifiedWithLemma) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' lemma.`, qualifiedStatementNode);
     }
   }
 
-  return qualifiedStatementUnifiedAgainstLemma;
+  return qualifiedStatementUnifiedWithLemma;
 }
 
-function unifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementUnifiedAgainstTheorem = false;
+function unifyQualifiedStatementAWithTheorem(qualifiedStatementNode, substitutions, localContext) {
+  let qualifiedStatementUnifiedWithTheorem = false;
 
   const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
         theorem = localContext.findTheoremByMetavariableNode(metavariableNode);
@@ -138,22 +138,22 @@ function unifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, substitu
           metavariableString = localContext.nodeAsString(metavariableNode),
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' theorem...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' theorem...`, qualifiedStatementNode);
 
     const theoremMatchesStatement = theorem.unifyStatement(statementNode, localContext);
 
-    qualifiedStatementUnifiedAgainstTheorem = theoremMatchesStatement; ///
+    qualifiedStatementUnifiedWithTheorem = theoremMatchesStatement; ///
 
-    if (qualifiedStatementUnifiedAgainstTheorem) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' theorem.`, qualifiedStatementNode);
+    if (qualifiedStatementUnifiedWithTheorem) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' theorem.`, qualifiedStatementNode);
     }
   }
 
-  return qualifiedStatementUnifiedAgainstTheorem;
+  return qualifiedStatementUnifiedWithTheorem;
 }
 
-function unifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementUnifiedAgainstConjecture = false;
+function unifyQualifiedStatementAWithConjecture(qualifiedStatementNode, substitutions, localContext) {
+  let qualifiedStatementUnifiedWithConjecture = false;
 
   const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
         conjecture = localContext.findConjectureByMetavariableNode(metavariableNode);
@@ -163,29 +163,29 @@ function unifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, subst
           metavariableString = localContext.nodeAsString(metavariableNode),
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' conjecture...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' conjecture...`, qualifiedStatementNode);
 
     const conjectureMatchesStatement = conjecture.unifyStatement(statementNode, localContext);
 
-    qualifiedStatementUnifiedAgainstConjecture = conjectureMatchesStatement; ///
+    qualifiedStatementUnifiedWithConjecture = conjectureMatchesStatement; ///
 
-    if (qualifiedStatementUnifiedAgainstConjecture) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' conjecture.`, qualifiedStatementNode);
+    if (qualifiedStatementUnifiedWithConjecture) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' conjecture.`, qualifiedStatementNode);
     }
   }
 
-  return qualifiedStatementUnifiedAgainstConjecture;
+  return qualifiedStatementUnifiedWithConjecture;
 }
 
-function unifyQualifiedStatementAAgainstReference(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementUnifiedAgainstReference = false;
+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 against the '${metavariableString}' reference...`, qualifiedStatementNode);
+  localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' reference...`, qualifiedStatementNode);
 
   if (metavariablePresent) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
@@ -194,20 +194,20 @@ function unifyQualifiedStatementAAgainstReference(qualifiedStatementNode, substi
           statementNodeB = statementNode, ///
           substitutionNodeA = null,
           metavariableNodeA = metavariableNode, ///
-          metavariableUnifiedAgainstStatement = unifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB, () => {
+          metavariableUnifiedWithStatement = unifyMetavariableWithStatement(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;
           });
 
-    qualifiedStatementUnifiedAgainstReference = metavariableUnifiedAgainstStatement; ///
+    qualifiedStatementUnifiedWithReference = metavariableUnifiedWithStatement; ///
   }
 
-  if (qualifiedStatementUnifiedAgainstReference) {
-    localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' reference.`, qualifiedStatementNode);
+  if (qualifiedStatementUnifiedWithReference) {
+    localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' reference.`, qualifiedStatementNode);
   }
 
-  return qualifiedStatementUnifiedAgainstReference;
+  return qualifiedStatementUnifiedWithReference;
 }
 
 function verifyStatedStatement(statementNode, assignments, derived, localContext) {

package/src/verify/statement.js

@@ -9,7 +9,7 @@ import verifyTypeAssertion from "../verify/assertion/type";
 import verifyDefinedAssertion from "../verify/assertion/defined";
 import verifySubproofAssertion from "../verify/assertion/subproof";
 import verifyContainedAssertion from "../verify/assertion/contained";
-import statementAgainstCombinatorUnifier from "../unifier/statementAgainstCombinator";
+import statementWithCombinatorUnifier from "../unifier/statementWithCombinator";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -28,9 +28,9 @@ function verifyStatement(statementNode, assignments, derived, localContext) {
 
   localContext.trace(`Verifying the '${statementString}' statement...`, statementNode);
 
-  const statementUnifiedAgainstCombinators = unifyStatementAgainstCombinators(statementNode, assignments, derived, localContext);
+  const statementUnifiedWithCombinators = unifyStatementWithCombinators(statementNode, assignments, derived, localContext);
 
-  if (statementUnifiedAgainstCombinators) {
+  if (statementUnifiedWithCombinators) {
     statementVerified = true;
   } else {
     const verifyStatementFunctions = [
@@ -41,7 +41,7 @@ function verifyStatement(statementNode, assignments, derived, localContext) {
       verifyStatementAsDefinedAssertion,
       verifyStatementAsSubproofAssertion,
       verifyStatementAsContainedAssertion,
-      unifyStatementAgainstCombinators
+      unifyStatementWithCombinators
     ];
 
     statementVerified = verifyStatementFunctions.some((verifyStatementFunction) => {
@@ -220,8 +220,8 @@ function verifyStatementAsContainedAssertion(statementNode, assignments, derived
   return statementVerifiedAsContainedAssertion;
 }
 
-function unifyStatementAgainstCombinators(statementNode, assignments, derived, localContext) {
-  let statementUnifiedAgainstCombinators = false;
+function unifyStatementWithCombinators(statementNode, assignments, derived, localContext) {
+  let statementUnifiedWithCombinators = false;
 
   const equalityNode = equalityNodeQuery(statementNode),
         judgementNode = judgementNodeQuery(statementNode),
@@ -246,33 +246,33 @@ function unifyStatementAgainstCombinators(statementNode, assignments, derived, l
       ...combinators
     ];
 
-    statementUnifiedAgainstCombinators = combinators.some((combinator) => {
-      const statementUnifiedAgainstCombinator = unifyStatementAgainstCombinator(statementNode, combinator, localContext);
+    statementUnifiedWithCombinators = combinators.some((combinator) => {
+      const statementUnifiedWithCombinator = unifyStatementWithCombinator(statementNode, combinator, localContext);
 
-      if (statementUnifiedAgainstCombinator) {
+      if (statementUnifiedWithCombinator) {
         return true;
       }
     });
   }
 
-  return statementUnifiedAgainstCombinators;
+  return statementUnifiedWithCombinators;
 }
 
-function unifyStatementAgainstCombinator(statementNode, combinator, localContext) {
-  let statementUnifiedAgainstCombinator;
+function unifyStatementWithCombinator(statementNode, combinator, localContext) {
+  let statementUnifiedWithCombinator;
 
   const statementString = localContext.nodeAsString(statementNode),
         combinatorString = combinator.getString();
 
-  localContext.trace(`Unifying the '${statementString}' statement against the '${combinatorString}' combinator...`, statementNode);
+  localContext.trace(`Unifying the '${statementString}' statement with the '${combinatorString}' combinator...`, statementNode);
 
   const combinatorStatementNode = combinator.getStatementNode();
 
-  statementUnifiedAgainstCombinator = statementAgainstCombinatorUnifier.unify(statementNode, combinatorStatementNode, localContext);
+  statementUnifiedWithCombinator = statementWithCombinatorUnifier.unify(statementNode, combinatorStatementNode, localContext);
 
-  if (statementUnifiedAgainstCombinator) {
-    localContext.debug(`...unified the '${statementString}' statement against the '${combinatorString}' combinator.`, statementNode);
+  if (statementUnifiedWithCombinator) {
+    localContext.debug(`...unified the '${statementString}' statement with the '${combinatorString}' combinator.`, statementNode);
   }
 
-  return statementUnifiedAgainstCombinator;
+  return statementUnifiedWithCombinator;
 }

package/src/verify/statementAsCombinator.js

@@ -8,7 +8,7 @@ export default function verifyStatementAsCombinator(statementNode, fileContext)
 
   const statementString = fileContext.nodeAsString(statementNode);
 
-  fileContext.trace(`Verifying the '${statementString}' statement as a combinator....`, statementNode);
+  fileContext.trace(`Verifying the '${statementString}' statement as a combinator...`, statementNode);
 
   statementVerifiedAsCombinator = statementAsCombinatorVerifier.verify(statementNode, fileContext);