occam-verify-cli 0.0.941 → 0.0.943

package/src/verify/metavariable.js

@@ -1,116 +1,56 @@
 "use strict";
 
-import Metavariable from "../metavariable";
-import MetavariableAssignment from "../assignment/metavariable";
-
-import { first } from "../utilities/array";
 import { nodeQuery } from "../utilities/query";
 import { nameFromMetavariableNode } from "../utilities/name";
+import { verifyTermAgainstTermType } from "../metavariable";
 
-const termNodeQuery = nodeQuery("/argument/term"),
-      typeNodeQuery = nodeQuery("/argument/type"),
-      argumentNodeQuery = nodeQuery("/metavariable/argument!");
+const termNodeQuery = nodeQuery("/metavariable/argument/term"),
+      typeNodeQuery = nodeQuery("/metavariable/argument/type");
 
-export default function verifyMetavariable(metavariableNode, metaTypeNode, fileContext) {
+export default function verifyMetavariable(metavariableNode, localContext) {
   let metavariableVerified = false;
 
-  const metavariableString = fileContext.nodeAsString(metavariableNode);
+  const metavariableString = localContext.nodeAsString(metavariableNode);
 
-  fileContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
+  localContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
 
-  const metavariablePresent = fileContext.isMetavariablePresentByMetavariableNode(metavariableNode);
+  const name = nameFromMetavariableNode(metavariableNode),
+        metavariable = localContext.findMetavariableByName(name);
 
-  if (metavariablePresent) {
-    fileContext.debug(`The metavariable '${metavariableString}' is already present.`, metavariableNode);
+  if (metavariable === null) {
+    localContext.debug(`The metavariable '${metavariableString}' is not present.`, metavariableNode);
   } else {
-    const termTypes = [],
-          metaTypes = [],
-          argumentNode = argumentNodeQuery(metavariableNode),
-          argumentVerified = verifyArgument(argumentNode, termTypes, fileContext),
-          metaTypeVerified = verifyMetaType(metaTypeNode, metaTypes, fileContext);
-
-    if (argumentVerified && metaTypeVerified) {
-      let termType,
-          metaType;
-
-      const firstMetaType = first(metaTypes);
+    const typeNode = typeNodeQuery(metavariableNode);
 
-      metaType = firstMetaType; ///
-
-      const termTypesLength = termTypes.length;
+    if (typeNode !== null) {
+      const typeString = localContext.nodeAsString(typeNode);
 
-      if (termTypesLength === 0) {
-        termType = null;
+      localContext.debug(`The '${typeString}' type was found when a term should be present.`, typeNode);
+    } else {
+      const termType = metavariable.getTermType(),
+            termNode = termNodeQuery(metavariableNode),
+            typeString = localContext.nodeAsString(typeNode),
+            termString = localContext.nodeAsString(termNode);
+
+      if (false) {
+        ///
+      } else if ((termType === null) && (termNode === null)) {
+        metavariableVerified = true;
+      } else if ((termType === null) && (termNode !== null)) {
+        localContext.debug(`The '${termString}' term was found when none is expected.`, termNode);
+      } else if ((termType !== null) && (termNode === null)) {
+        localContext.debug(`No term was found when the metavariable's term type is '${typeString}'.`, termNode);
       } else {
-        const firstTermType = first(termTypes);
-
-        termType = firstTermType; ///
-      }
+        const termVerifiedAgainstTermType = verifyTermAgainstTermType(termNode, termType, localContext);
 
-      const node = metavariableNode,  ///
-            name = nameFromMetavariableNode(metavariableNode),
-            metavariable = Metavariable.fromNodeNameTermTypeAndMetaType(node, name, termType, metaType),
-            metavariableAssignment = MetavariableAssignment.fromMetavariable(metavariable),
-            metavariableAssigned = metavariableAssignment.assign(fileContext);
-
-      if (metavariableAssigned) {
-        metavariableVerified = true;
+        metavariableVerified = termVerifiedAgainstTermType; ///
       }
     }
   }
 
   if (metavariableVerified) {
-    fileContext.debug(`...verified the '${metavariableString}' metavariable.`, metavariableNode);
+    localContext.debug(`...verified the '${metavariableString}' metavariable.`, metavariableNode);
   }
 
   return metavariableVerified;
 }
-
-function verifyArgument(argumentNode, termTypes, fileContext) {
-  let argumentVerified = false;
-
-  if (argumentNode === null) {
-    argumentVerified = true;
-  } else {
-    const termNode = termNodeQuery(argumentNode);
-
-    if (termNode === null) {
-
-    } else {
-      const termString = fileContext.nodeAsString(termNode);
-
-      fileContext.debug(`The '${termString}' term was found when a type should have been present.`, termNode);
-    }
-    const typeNode = typeNodeQuery(argumentNode);
-
-    if (typeNode !== null) {
-      const type = fileContext.findTypeByTypeNode(typeNode);
-
-      if (type !== null) {
-        const termType = type;  ///
-
-        termTypes.push(termType);
-
-        argumentVerified = true;
-      } else {
-        const typeString = fileContext.nodeAsString(typeNode);
-
-        fileContext.debug(`The '${typeString}' type is not present.`, typeNode);
-      }
-    }
-  }
-
-  return argumentVerified;
-}
-
-function verifyMetaType(metaTypeNode, metaTypes, fileContext) {
-  let metaTypeVerified;
-
-  const metaType = fileContext.findMetaTypeByMetaTypeNode(metaTypeNode);
-
-  metaTypes.push(metaType);
-
-  metaTypeVerified = true;
-
-  return metaTypeVerified;
-}

package/src/verify/rule.js

@@ -9,6 +9,7 @@ import verifyConclusion from "../verify/conclusion";
 
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
+import Substitutions from "../substitutions";
 
 const proofNodeQuery = nodeQuery("/rule/proof!"),
       labelNodesQuery = nodesQuery("/rule/label"),
@@ -45,7 +46,7 @@ export default function verifyRule(ruleNode, fileContext) {
               conclusion = firstConclusion; ///
 
         if (proofNode !== null) {
-          const substitutions = [],
+          const substitutions = Substitutions.fromNothing(),
                 statementNode = conclusion.getStatementNode();
 
           proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);

package/src/verify/statement/qualified.js

@@ -20,24 +20,24 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, substit
 
   localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement...`, qualifiedStatementNode);
 
-  const verifyQualifiedStatementFunctions = [
-    verifyQualifiedStatementAAgainstRule,
-    verifyQualifiedStatementAAgainstAxiom,
-    verifyQualifiedStatementAAgainstLemma,
-    verifyQualifiedStatementAAgainstTheorem,
-    verifyQualifiedStatementAAgainstConjecture,
-    verifyQualifiedStatementAAgainstReference
+  const unifyQualifiedStatementFunctions = [
+    unifyQualifiedStatementAAgainstRule,
+    unifyQualifiedStatementAAgainstAxiom,
+    unifyQualifiedStatementAAgainstLemma,
+    unifyQualifiedStatementAAgainstTheorem,
+    unifyQualifiedStatementAAgainstConjecture,
+    unifyQualifiedStatementAAgainstReference
   ];
 
-  qualifiedStatementVerified = verifyQualifiedStatementFunctions.some((verifyQualifiedStatementFunction) => {  ///
-    const qualifiedStatementVerified = verifyQualifiedStatementFunction(qualifiedStatementNode, substitutions, localContext);
+  const qualifiedStatementUnified = unifyQualifiedStatementFunctions.some((unifyQualifiedStatementFunction) => {  ///
+    const qualifiedStatementUnified = unifyQualifiedStatementFunction(qualifiedStatementNode, substitutions, localContext);
 
-    if (qualifiedStatementVerified) {
+    if (qualifiedStatementUnified) {
       return true;
     }
   });
 
-  if (qualifiedStatementVerified) {
+  if (qualifiedStatementUnified) {
     const derived = false,
           statementNode = statementNodeQuery(qualifiedStatementNode),
           statedStatementVerified = verifyStatedStatement(statementNode, assignments, derived, localContext);
@@ -52,8 +52,8 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, substit
   return qualifiedStatementVerified;
 }
 
-function verifyQualifiedStatementAAgainstRule(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementVerifiedAgainstRule = false;
+function unifyQualifiedStatementAAgainstRule(qualifiedStatementNode, substitutions, localContext) {
+  let qualifiedStatementUnifiedAgainstRule = false;
 
   const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
         rule = localContext.findRuleByMetavariableNode(metavariableNode);
@@ -63,22 +63,22 @@ function verifyQualifiedStatementAAgainstRule(qualifiedStatementNode, substituti
           metavariableString = localContext.nodeAsString(metavariableNode),
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' rule...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' rule...`, qualifiedStatementNode);
 
     const ruleMatchesStatement = rule.unifyStatement(statementNode, localContext);
 
-    qualifiedStatementVerifiedAgainstRule = ruleMatchesStatement;  ///
+    qualifiedStatementUnifiedAgainstRule = ruleMatchesStatement;  ///
 
-    if (qualifiedStatementVerifiedAgainstRule) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' rule.`, qualifiedStatementNode);
+    if (qualifiedStatementUnifiedAgainstRule) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' rule.`, qualifiedStatementNode);
     }
   }
 
-  return qualifiedStatementVerifiedAgainstRule;
+  return qualifiedStatementUnifiedAgainstRule;
 }
 
-function verifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementVerifiedAgainstAxiom = false;
+function unifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, substitutions, localContext) {
+  let qualifiedStatementUnifiedAgainstAxiom = false;
 
   const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
         axiom = localContext.findAxiomByMetavariableNode(metavariableNode);
@@ -88,22 +88,22 @@ function verifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, substitut
           metavariableString = localContext.nodeAsString(metavariableNode),
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' axiom...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' axiom...`, qualifiedStatementNode);
 
     const axiomMatchesStatement = axiom.unifyStatement(statementNode, localContext);
 
-    qualifiedStatementVerifiedAgainstAxiom = axiomMatchesStatement; ///
+    qualifiedStatementUnifiedAgainstAxiom = axiomMatchesStatement; ///
 
-    if (qualifiedStatementVerifiedAgainstAxiom) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' axiom.`, qualifiedStatementNode);
+    if (qualifiedStatementUnifiedAgainstAxiom) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' axiom.`, qualifiedStatementNode);
     }
   }
 
-  return qualifiedStatementVerifiedAgainstAxiom;
+  return qualifiedStatementUnifiedAgainstAxiom;
 }
 
-function verifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementVerifiedAgainstLemma = false;
+function unifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, substitutions, localContext) {
+  let qualifiedStatementUnifiedAgainstLemma = false;
 
   const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
         lemma = localContext.findLemmaByMetavariableNode(metavariableNode);
@@ -113,22 +113,22 @@ function verifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, substitut
           metavariableString = localContext.nodeAsString(metavariableNode),
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' lemma...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' lemma...`, qualifiedStatementNode);
 
     const lemmaMatchesStatement = lemma.unifyStatement(statementNode, localContext);
 
-    qualifiedStatementVerifiedAgainstLemma = lemmaMatchesStatement; ///
+    qualifiedStatementUnifiedAgainstLemma = lemmaMatchesStatement; ///
 
-    if (qualifiedStatementVerifiedAgainstLemma) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' lemma.`, qualifiedStatementNode);
+    if (qualifiedStatementUnifiedAgainstLemma) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' lemma.`, qualifiedStatementNode);
     }
   }
 
-  return qualifiedStatementVerifiedAgainstLemma;
+  return qualifiedStatementUnifiedAgainstLemma;
 }
 
-function verifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementVerifiedAgainstTheorem = false;
+function unifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, substitutions, localContext) {
+  let qualifiedStatementUnifiedAgainstTheorem = false;
 
   const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
         theorem = localContext.findTheoremByMetavariableNode(metavariableNode);
@@ -138,22 +138,22 @@ function verifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, substit
           metavariableString = localContext.nodeAsString(metavariableNode),
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' theorem...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' theorem...`, qualifiedStatementNode);
 
     const theoremMatchesStatement = theorem.unifyStatement(statementNode, localContext);
 
-    qualifiedStatementVerifiedAgainstTheorem = theoremMatchesStatement; ///
+    qualifiedStatementUnifiedAgainstTheorem = theoremMatchesStatement; ///
 
-    if (qualifiedStatementVerifiedAgainstTheorem) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' theorem.`, qualifiedStatementNode);
+    if (qualifiedStatementUnifiedAgainstTheorem) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' theorem.`, qualifiedStatementNode);
     }
   }
 
-  return qualifiedStatementVerifiedAgainstTheorem;
+  return qualifiedStatementUnifiedAgainstTheorem;
 }
 
-function verifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementVerifiedAgainstConjecture = false;
+function unifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, substitutions, localContext) {
+  let qualifiedStatementUnifiedAgainstConjecture = false;
 
   const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
         conjecture = localContext.findConjectureByMetavariableNode(metavariableNode);
@@ -163,29 +163,29 @@ function verifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, subs
           metavariableString = localContext.nodeAsString(metavariableNode),
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' conjecture...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' conjecture...`, qualifiedStatementNode);
 
     const conjectureMatchesStatement = conjecture.unifyStatement(statementNode, localContext);
 
-    qualifiedStatementVerifiedAgainstConjecture = conjectureMatchesStatement; ///
+    qualifiedStatementUnifiedAgainstConjecture = conjectureMatchesStatement; ///
 
-    if (qualifiedStatementVerifiedAgainstConjecture) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' conjecture.`, qualifiedStatementNode);
+    if (qualifiedStatementUnifiedAgainstConjecture) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' conjecture.`, qualifiedStatementNode);
     }
   }
 
-  return qualifiedStatementVerifiedAgainstConjecture;
+  return qualifiedStatementUnifiedAgainstConjecture;
 }
 
-function verifyQualifiedStatementAAgainstReference(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementVerifiedAgainstReference = false;
+function unifyQualifiedStatementAAgainstReference(qualifiedStatementNode, substitutions, localContext) {
+  let qualifiedStatementUnifiedAgainstReference = false;
 
   const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
         metavariableString = localContext.nodeAsString(metavariableNode),
         metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode),
         qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-  localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' reference...`, qualifiedStatementNode);
+  localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' reference...`, qualifiedStatementNode);
 
   if (metavariablePresent) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
@@ -200,14 +200,14 @@ function verifyQualifiedStatementAAgainstReference(qualifiedStatementNode, subst
             return verifiedAhead;
           });
 
-    qualifiedStatementVerifiedAgainstReference = metavariableVerifiedAgainstStatement; ///
+    qualifiedStatementUnifiedAgainstReference = metavariableVerifiedAgainstStatement; ///
   }
 
-  if (qualifiedStatementVerifiedAgainstReference) {
-    localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' reference.`, qualifiedStatementNode);
+  if (qualifiedStatementUnifiedAgainstReference) {
+    localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' reference.`, qualifiedStatementNode);
   }
 
-  return qualifiedStatementVerifiedAgainstReference;
+  return qualifiedStatementUnifiedAgainstReference;
 }
 
 function verifyStatedStatement(statementNode, assignments, derived, localContext) {

package/src/verify/statement/unqualified.js

@@ -48,7 +48,7 @@ function verifyDerivedUnqualifiedStatement(unqualifiedStatementNode, assignments
 
     localContext.trace(`Verifying the '${unqualifiedStatementString}' derived unqualified statement...`, unqualifiedStatementNode);
 
-    const statementUnified = localContext.unifyStatement(statementNode);
+    const statementUnified = localContext.unifyStatement(statementNode, localContext);
 
     if (statementUnified) {
       derivedUnqualifiedStatementVerified = true;

package/src/verify/statement.js

@@ -28,24 +28,30 @@ function verifyStatement(statementNode, assignments, derived, localContext) {
 
   localContext.trace(`Verifying the '${statementString}' statement...`, statementNode);
 
-  const verifyStatementFunctions = [
-    verifyStatementAsMetavariable,
-    verifyStatementAsEquality,
-    verifyStatementAsJudgement,
-    verifyStatementAsTypeAssertion,
-    verifyStatementAsDefinedAssertion,
-    verifyStatementAsSubproofAssertion,
-    verifyStatementAsContainedAssertion,
-    verifyStatementAgainstCombinators
-  ];
-
-  statementVerified = verifyStatementFunctions.some((verifyStatementFunction) => {
-    const statementVerified = verifyStatementFunction(statementNode, assignments, derived, localContext);
-
-    if (statementVerified) {
-      return true;
-    }
-  });
+  const statementUnifiedAgainstCombinators = unifyStatementAgainstCombinators(statementNode, assignments, derived, localContext);
+
+  if (statementUnifiedAgainstCombinators) {
+    statementVerified = true;
+  } else {
+    const verifyStatementFunctions = [
+      verifyStatementAsMetavariable,
+      verifyStatementAsEquality,
+      verifyStatementAsJudgement,
+      verifyStatementAsTypeAssertion,
+      verifyStatementAsDefinedAssertion,
+      verifyStatementAsSubproofAssertion,
+      verifyStatementAsContainedAssertion,
+      unifyStatementAgainstCombinators
+    ];
+
+    statementVerified = verifyStatementFunctions.some((verifyStatementFunction) => {
+      const statementVerified = verifyStatementFunction(statementNode, assignments, derived, localContext);
+
+      if (statementVerified) {
+        return true;
+      }
+    });
+  }
 
   if (statementVerified) {
     localContext.debug(`...verified the '${statementString}' statement.`, statementNode);
@@ -218,8 +224,8 @@ function verifyStatementAsContainedAssertion(statementNode, assignments, derived
   return statementVerifiedAsContainedAssertion;
 }
 
-function verifyStatementAgainstCombinators(statementNode, assignments, derived, localContext) {
-  let statementVerifiedAgainstCombinators = false;
+function unifyStatementAgainstCombinators(statementNode, assignments, derived, localContext) {
+  let statementUnifiedAgainstCombinators = false;
 
   const equalityNode = equalityNodeQuery(statementNode),
         judgementNode = judgementNodeQuery(statementNode),
@@ -244,33 +250,33 @@ function verifyStatementAgainstCombinators(statementNode, assignments, derived,
       ...combinators
     ];
 
-    statementVerifiedAgainstCombinators = combinators.some((combinator) => {
-      const statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, localContext);
+    statementUnifiedAgainstCombinators = combinators.some((combinator) => {
+      const statementUnifiedAgainstCombinator = unifyStatementAgainstCombinator(statementNode, combinator, localContext);
 
-      if (statementVerifiedAgainstCombinator) {
+      if (statementUnifiedAgainstCombinator) {
         return true;
       }
     });
   }
 
-  return statementVerifiedAgainstCombinators;
+  return statementUnifiedAgainstCombinators;
 }
 
-function verifyStatementAgainstCombinator(statementNode, combinator, localContext) {
-  let statementVerifiedAgainstCombinator;
+function unifyStatementAgainstCombinator(statementNode, combinator, localContext) {
+  let statementUnifiedAgainstCombinator;
 
   const statementString = localContext.nodeAsString(statementNode),
         combinatorString = combinator.getString();
 
-  localContext.trace(`Verifying the '${statementString}' statement against the '${combinatorString}' combinator...`, statementNode);
+  localContext.trace(`Unifying the '${statementString}' statement against the '${combinatorString}' combinator...`, statementNode);
 
   const combinatorStatementNode = combinator.getStatementNode();
 
-  statementVerifiedAgainstCombinator = statementAgainstCombinatorUnifier.unify(statementNode, combinatorStatementNode, localContext);
+  statementUnifiedAgainstCombinator = statementAgainstCombinatorUnifier.unify(statementNode, combinatorStatementNode, localContext);
 
-  if (statementVerifiedAgainstCombinator) {
-    localContext.debug(`...verified the '${statementString}' statement against the '${combinatorString}' combinator.`, statementNode);
+  if (statementUnifiedAgainstCombinator) {
+    localContext.debug(`...unified the '${statementString}' statement against the '${combinatorString}' combinator.`, statementNode);
   }
 
-  return statementVerifiedAgainstCombinator;
+  return statementUnifiedAgainstCombinator;
 }

package/src/verify/term.js

@@ -20,8 +20,8 @@ function verifyTerm(termNode, terms, localContext, verifyAhead) {
 
   const verifyTermFunctions = [
     verifyTermAsVariable,
-    verifyTermAgainstConstructors,
-    verifyTermAgainstBracketedConstructor
+    unifyTermAgainstConstructors,
+    unifyTermAgainstBracketedConstructor
   ];
 
   termVerified = verifyTermFunctions.some((verifyTermFunction) => {
@@ -67,9 +67,7 @@ function verifyTermAsVariable(termNode, terms, localContext, verifyAhead) {
 
       verifiedAhead = verifyAhead();
 
-      if (!verifiedAhead) {
-        terms.pop();
-      }
+      terms.pop();
 
       termVerifiedAsVariable = verifiedAhead;  ///
     }
@@ -82,33 +80,33 @@ function verifyTermAsVariable(termNode, terms, localContext, verifyAhead) {
   return termVerifiedAsVariable;
 }
 
-function verifyTermAgainstConstructors(termNode, terms, localContext, verifyAhead) {
-  let termVerifiedAgainstConstructors = false;
+function unifyTermAgainstConstructors(termNode, terms, localContext, verifyAhead) {
+  let termUnifiedAgainstConstructors = false;
 
   const variableNode = variableNodeQuery(termNode);
 
   if (variableNode === null) {
     const constructors = localContext.getConstructors();
 
-    termVerifiedAgainstConstructors = constructors.some((constructor) => {
-      const termVerifiedAgainstConstructor = verifyTermAgainstConstructor(termNode, terms, constructor, localContext, verifyAhead);
+    termUnifiedAgainstConstructors = constructors.some((constructor) => {
+      const termUnifiedAgainstConstructor = unifyTermAgainstConstructor(termNode, terms, constructor, localContext, verifyAhead);
 
-      if (termVerifiedAgainstConstructor) {
+      if (termUnifiedAgainstConstructor) {
         return true;
       }
     });
   }
 
-  return termVerifiedAgainstConstructors;
+  return termUnifiedAgainstConstructors;
 }
 
-function verifyTermAgainstBracketedConstructor(termNode, terms, localContext, verifyAhead) {
-  let termVerifiedAgainstBracketedConstructor;
+function unifyTermAgainstBracketedConstructor(termNode, terms, localContext, verifyAhead) {
+  let termUnifiedAgainstBracketedConstructor;
 
   const termString = localContext.nodeAsString(termNode),
         bracketedConstructorString = bracketedConstructor.getString();
 
-  localContext.trace(`Verifying the '${termString}' term against the '${bracketedConstructorString}' bracketed constructor...`, termNode);
+  localContext.trace(`Unifying the '${termString}' term against the '${bracketedConstructorString}' bracketed constructor...`, termNode);
 
   const bracketedConstructorTermNode = bracketedConstructor.getTermNode(),
         termNodeA = termNode,  ///
@@ -148,30 +146,28 @@ function verifyTermAgainstBracketedConstructor(termNode, terms, localContext, ve
 
             verifiedAhead = verifyAhead();
 
-            if (!verifiedAhead) {
-              terms.pop();
-            }
+            terms.pop();
           }
 
           return verifiedAhead;
         });
 
-  termVerifiedAgainstBracketedConstructor = unified;  ///
+  termUnifiedAgainstBracketedConstructor = unified;  ///
 
-  if (termVerifiedAgainstBracketedConstructor) {
-    localContext.debug(`...verified the '${termString}' term against the '${bracketedConstructorString}' constructor.`, termNode);
+  if (termUnifiedAgainstBracketedConstructor) {
+    localContext.debug(`...unified the '${termString}' term against the '${bracketedConstructorString}' constructor.`, termNode);
   }
 
-  return termVerifiedAgainstBracketedConstructor;
+  return termUnifiedAgainstBracketedConstructor;
 }
 
-function verifyTermAgainstConstructor(termNode, terms, constructor, localContext, verifyAhead) {
-  let termVerifiedAgainstConstructor;
+function unifyTermAgainstConstructor(termNode, terms, constructor, localContext, verifyAhead) {
+  let termUnifiedAgainstConstructor;
 
   const termString = localContext.nodeAsString(termNode),
         constructorString = constructor.getString();
 
-  localContext.trace(`Verifying the '${termString}' term against the '${constructorString}' constructor...`, termNode);
+  localContext.trace(`Unifying the '${termString}' term against the '${constructorString}' constructor...`, termNode);
 
   const constructorTermNode = constructor.getTermNode(),
         termNodeA = termNode,  ///
@@ -186,19 +182,17 @@ function verifyTermAgainstConstructor(termNode, terms, constructor, localContext
 
           verifiedAhead = verifyAhead();
 
-          if (!verifiedAhead) {
-            terms.pop();
-          }
+          terms.pop();
 
           return verifiedAhead;
         });
 
-  termVerifiedAgainstConstructor = unified;  ///
+  termUnifiedAgainstConstructor = unified;  ///
 
-  if (termVerifiedAgainstConstructor) {
-    localContext.debug(`...verified the '${termString}' term against the '${constructorString}' constructor.`, termNode);
+  if (termUnifiedAgainstConstructor) {
+    localContext.debug(`...unified the '${termString}' term against the '${constructorString}' constructor.`, termNode);
   }
 
-  return termVerifiedAgainstConstructor;
+  return termUnifiedAgainstConstructor;
 }
 

package/src/verify/theorem.js

@@ -4,6 +4,7 @@ import Theorem from "../theorem";
 import verifyProof from "../verify/proof";
 import verifyLabels from "../verify/labels";
 import LocalContext from "../context/local";
+import Substitutions from "../substitutions";
 import verifyConsequent from "../verify/consequent";
 import verifySuppositions from "../verify/suppositions";
 
@@ -42,11 +43,11 @@ export default function verifyTheorem(theoremNode, fileContext) {
               firstConsequent = first(consequents),
               consequent = firstConsequent, ///
               statementNode = consequent.getStatementNode(),
-              substitutions = [],
+              substitutions = Substitutions.fromNothing(),
               proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);
 
         if (proofVerified) {
-          const substitutions = [],
+          const substitutions = Substitutions.fromNothing(),
                 theorem = Theorem.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext);
 
           fileContext.addTheorem(theorem);