occam-verify-cli 0.0.869 → 0.0.871

package/src/verify/metavariable.js

@@ -2,7 +2,6 @@
 
 import Metavariable from "../metavariable";
 import MetavariableAssignment from "../assignment/metavariable";
-import verifyGivenMetavariable from "../verify/givenMetavariable";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -44,16 +43,19 @@ export default function verifyMetavariable(metavariableNode, metaTypeNode, fileC
 }
 
 export function verifyStandaloneMetavariable(metavariableNode, localMetaContext, verifyAhead) {
-  let standaloneMetavariableVerified;
+  let standaloneMetavariableVerified = false;
 
   const metavariableString = localMetaContext.nodeAsString(metavariableNode);
 
   localMetaContext.trace(`Verifying the '${metavariableString}' standalone metavariable...`, metavariableNode);
 
-  const metavariables = [],
-        givenMetavariableVerified = verifyGivenMetavariable(metavariableNode, metavariables, localMetaContext, verifyAhead);
+  const metavariablePresent = localMetaContext.isMetavariablePresentByMetavariableNode(metavariableNode);
 
-  standaloneMetavariableVerified = givenMetavariableVerified; ///
+  if (metavariablePresent) {
+    const verifiedAhead = verifyAhead();
+
+    standaloneMetavariableVerified = verifiedAhead; ///
+  }
 
   if (standaloneMetavariableVerified) {
     localMetaContext.debug(`...verified the '${metavariableString}' standalone metavariable.`, metavariableNode);

package/src/verify/metavariableAgainstMetastatement.js

@@ -0,0 +1,42 @@
+"use strict";
+
+import MetastatementForMetavariableSubstitution from "../substitution/metastatementForMetavariable";
+
+export default function verifyMetavariableAgainstMetastatement(metavariableNode, metastatementNode, substitutions, localContextA, localMetaContextB, verifyAhead) {
+  let metavariableVerifiedAgainstMetastatement = false;
+
+  const substitution = substitutions.find((substitution) => {
+    const substitutionMatchesMetavariableNodeA = substitution.matchMetavariableNode(metavariableNode);
+
+    if (substitutionMatchesMetavariableNodeA) {
+      return true;
+    }
+  }) || null;
+
+  if (substitution !== null) {
+    const metastatementNodeMatches = substitution.matchMetastatementNode(metastatementNode);
+
+    if (metastatementNodeMatches) {
+      const verifiedAhead = verifyAhead();
+
+      metavariableVerifiedAgainstMetastatement = verifiedAhead; ///
+    }
+  } else {
+    let verifiedAhead;
+
+    const metastatementForMetavariableSubstitution = MetastatementForMetavariableSubstitution.fromMetavariableNodeAndMetastatementNode(metavariableNode, metastatementNode),
+          substitution = metastatementForMetavariableSubstitution;  ///
+
+    substitutions.push(substitution);
+
+    verifiedAhead = verifyAhead();
+
+    if (!verifiedAhead) {
+      substitutions.pop();
+    }
+
+    metavariableVerifiedAgainstMetastatement = verifiedAhead; ///
+  }
+
+  return metavariableVerifiedAgainstMetastatement;
+}

package/src/verify/metavariableAgainstStatement.js

@@ -0,0 +1,77 @@
+"use strict";
+
+import TermForVariableSubstitution from "../substitution/termForVariable";
+import verifyStatementAgainstStatement from "../verify/statementAtainstStatement";
+import StatementForMetavariableSubstitution from "../substitution/statementForMetavariable";
+
+export default function verifyMetavariableAgainstStatement(metavariableNode, statementNode, substitutionNode, substitutions, localContextA, localContextB, verifyAhead) {
+  let metavariableVerifiedAgainstStatement = false;
+
+  const substitution = substitutions.find((substitution) => {
+    const substitutionMatchesMetavariableNodeA = substitution.matchMetavariableNode(metavariableNode);
+
+    if (substitutionMatchesMetavariableNodeA) {
+      return true;
+    }
+  }) || null;
+
+  if (substitution !== null) {
+    const substitutionStatementNode = substitution.getStatementNode();
+
+    if (substitutionNode !== null) {
+      const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionNode(substitutionNode),
+            substitution = termForVariableSubstitution, ///
+            statementNodeA = substitutionStatementNode, ///
+            statementNodeB = statementNode, ///
+            statementVerifiedAgainstStatement = verifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
+
+      if (statementVerifiedAgainstStatement) {
+        const verifiedAhead = verifyAhead();
+
+        metavariableVerifiedAgainstStatement = verifiedAhead;  ///
+      }
+    } else {
+      const substitutionSubstitution = substitution.getSubstitution();
+
+      if (substitutionSubstitution !== null) {
+        localContextA = localContextB;  ///
+
+        const substitution = substitutionSubstitution,
+              statementNodeA = statementNode, ///
+              statementNodeB = substitutionStatementNode, ///
+              statementVerifiedAgainstStatement = verifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
+
+        if (statementVerifiedAgainstStatement) {
+          const verifiedAhead = verifyAhead();
+
+          metavariableVerifiedAgainstStatement = verifiedAhead;  ///
+        }
+      } else {
+        const statementNodeMatches = substitution.matchStatementNode(statementNode);
+
+        if (statementNodeMatches) {
+          const verifiedAhead = verifyAhead();
+
+          metavariableVerifiedAgainstStatement = verifiedAhead;  ///
+        }
+      }
+    }
+  } else {
+    let verifiedAhead;
+
+    const statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNodeStatementNodeAndSubstitutionNode(metavariableNode, statementNode, substitutionNode),
+          substitution = statementForMetavariableSubstitution;  ///
+
+    substitutions.push(substitution);
+
+    verifiedAhead = verifyAhead();
+
+    if (!verifiedAhead) {
+      substitutions.pop();
+    }
+
+    metavariableVerifiedAgainstStatement = verifiedAhead;  ///
+  }
+
+  return metavariableVerifiedAgainstStatement;
+}

package/src/verify/rule.js

@@ -10,7 +10,7 @@ import verifyConclusion from "../verify/conclusion";
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const labelNodesQuery = nodesQuery("/rule//reference/label"),
+const labelsNodeQuery = nodeQuery("/rule/labels!"),
       premisesNodeQuery = nodesQuery("/rule/premise"),
       ruleProofNodeQuery = nodeQuery("/rule/ruleProof!"),
       conclusionNodeQuery = nodeQuery("/rule/conclusion!");
@@ -18,14 +18,14 @@ const labelNodesQuery = nodesQuery("/rule//reference/label"),
 export default function verifyRule(ruleNode, fileContext) {
   let ruleVerified = false;
 
-  const labelNodes = labelNodesQuery(ruleNode),
-        labelsString = fileContext.nodesAsString(labelNodes),
+  const labelsNode = labelsNodeQuery(ruleNode),
+        labelsString = fileContext.nodeAsString(labelsNode),
         localMetaContext = LocalMetaContext.fromFileContext(fileContext);
 
   fileContext.trace(`Verifying the '${labelsString}' rule...`, ruleNode);
 
   const labels = [],
-        labelsVerified = verifyLabels(labelNodes, labels, fileContext);
+        labelsVerified = verifyLabels(labelsNode, labels, fileContext);
 
   if (labelsVerified) {
     const premises = [],

package/src/verify/statement/qualified.js

@@ -5,10 +5,10 @@ import verifyTypeAssertion from "../typeAssertion";
 
 import { nodeQuery } from "../../utilities/query";
 
-const labelNodeQuery = nodeQuery("/qualifiedStatement/qualification!/label!"),
-      equalityNodeQuery = nodeQuery("/qualifiedStatement/statement/equality!"),
+const equalityNodeQuery = nodeQuery("/qualifiedStatement/statement/equality!"),
       statementNodeQuery = nodeQuery("/qualifiedStatement/statement!"),
-      typeAssertionNodeQuery = nodeQuery("/qualifiedStatement/statement/typeAssertion!");
+      typeAssertionNodeQuery = nodeQuery("/qualifiedStatement/statement/typeAssertion!"),
+      referenceMetavariableNodeQuery = nodeQuery("/qualifiedStatement/reference!/metavariable!");
 
 export default function verifyQualifiedStatement(qualifiedStatementNode, assignments, derived, localContext) {
   let qualifiedStatementVerified = false;
@@ -20,7 +20,7 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
 
     localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement...`, qualifiedStatementNode);
 
-    const labelNode = labelNodeQuery(qualifiedStatementNode),
+    const referenceMetavariableNode = referenceMetavariableNodeQuery(qualifiedStatementNode),
           verifyQualifiedStatementFunctions = [
             verifyQualifiedStatementAAgainstRule,
             verifyQualifiedStatementAAgainstAxiom,
@@ -30,7 +30,7 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
           ];
 
     qualifiedStatementVerified = verifyQualifiedStatementFunctions.some((verifyQualifiedStatementFunction) => {  ///
-      const qualifiedStatementVerified = verifyQualifiedStatementFunction(qualifiedStatementNode, labelNode, localContext);
+      const qualifiedStatementVerified = verifyQualifiedStatementFunction(qualifiedStatementNode, referenceMetavariableNode, localContext);
 
       if (qualifiedStatementVerified) {
         return true;
@@ -66,125 +66,130 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
   return qualifiedStatementVerified;
 }
 
-function verifyQualifiedStatementAAgainstRule(qualifiedStatementNode, labelNode, localContext) {
+function verifyQualifiedStatementAAgainstRule(qualifiedStatementNode, referenceMetavariableNode, localContext) {
   let qualifiedStatementVerifiedAgainstRule = false;
 
-  const rule = localContext.findRuleByLabelNode(labelNode);
+  const labelMetavariableNode = referenceMetavariableNode,  ///
+        rule = localContext.findRuleByLabelMetavariableNode(labelMetavariableNode);
 
   if (rule !== null) {
-    const labelString = localContext.nodeAsString(labelNode),
+    const referenceMetavariableString = localContext.nodeAsString(referenceMetavariableNode),
           statementNode = statementNodeQuery(qualifiedStatementNode),
           statementLocalContext = localContext, ///
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${labelString}' rule...`, statementNode);
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceMetavariableString}' rule...`, statementNode);
 
     const ruleMatchesStatement = rule.matchStatement(statementNode, statementLocalContext);
 
     qualifiedStatementVerifiedAgainstRule = ruleMatchesStatement;  ///
 
     if (qualifiedStatementVerifiedAgainstRule) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${labelString}' rule.`, statementNode);
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceMetavariableString}' rule.`, statementNode);
     }
   }
 
   return qualifiedStatementVerifiedAgainstRule;
 }
 
-function verifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, labelNode, localContext) {
+function verifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, referenceMetavariableNode, localContext) {
   let qualifiedStatementVerifiedAgainstAxiom = false;
 
-  const axiom = localContext.findAxiomByLabelNode(labelNode);
+  const labelMetavariableNode = referenceMetavariableNode,  ///
+        axiom = localContext.findAxiomByLabelMetavariableNode(labelMetavariableNode);
 
   if (axiom !== null) {
-    const labelString = localContext.nodeAsString(labelNode),
+    const referenceMetavariableString = localContext.nodeAsString(referenceMetavariableNode),
           statementNode = statementNodeQuery(qualifiedStatementNode),
           statementLocalContext = localContext, ///
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${labelString}' axiom...`, statementNode);
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceMetavariableString}' axiom...`, statementNode);
 
     const axiomMatchesStatement = axiom.matchStatement(statementNode, statementLocalContext);
 
     qualifiedStatementVerifiedAgainstAxiom = axiomMatchesStatement; ///
 
     if (qualifiedStatementVerifiedAgainstAxiom) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${labelString}' axiom.`, statementNode);
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceMetavariableString}' axiom.`, statementNode);
     }
   }
 
   return qualifiedStatementVerifiedAgainstAxiom;
 }
 
-function verifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, labelNode, localContext) {
+function verifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, referenceMetavariableNode, localContext) {
   let qualifiedStatementVerifiedAgainstLemma = false;
 
-  const lemma = localContext.findLemmaByLabelNode(labelNode);
+  const labelMetavariableNode = referenceMetavariableNode,  ///
+        lemma = localContext.findLemmaByLabelMetavariableNode(labelMetavariableNode);
 
   if (lemma !== null) {
-    const labelString = localContext.nodeAsString(labelNode),
+    const referenceMetavariableString = localContext.nodeAsString(referenceMetavariableNode),
           statementNode = statementNodeQuery(qualifiedStatementNode),
           statementLocalContext = localContext, ///
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${labelString}' lemma...`, statementNode);
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceMetavariableString}' lemma...`, statementNode);
 
     const lemmaMatchesStatement = lemma.matchStatement(statementNode, statementLocalContext);
 
     qualifiedStatementVerifiedAgainstLemma = lemmaMatchesStatement; ///
 
     if (qualifiedStatementVerifiedAgainstLemma) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${labelString}' lemma.`, statementNode);
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceMetavariableString}' lemma.`, statementNode);
     }
   }
 
   return qualifiedStatementVerifiedAgainstLemma;
 }
 
-function verifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, labelNode, localContext) {
+function verifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, referenceMetavariableNode, localContext) {
   let qualifiedStatementVerifiedAgainstTheorem = false;
 
-  const theorem = localContext.findTheoremByLabelNode(labelNode);
+  const labelMetavariableNode = referenceMetavariableNode,  ///
+        theorem = localContext.findTheoremByLabelMetavariableNode(labelMetavariableNode);
 
   if (theorem !== null) {
-    const labelString = localContext.nodeAsString(labelNode),
+    const referenceMetavariableString = localContext.nodeAsString(referenceMetavariableNode),
           statementNode = statementNodeQuery(qualifiedStatementNode),
           statementLocalContext = localContext, ///
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${labelString}' theorem...`, statementNode);
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceMetavariableString}' theorem...`, statementNode);
 
     const theoremMatchesStatement = theorem.matchStatement(statementNode, statementLocalContext);
 
     qualifiedStatementVerifiedAgainstTheorem = theoremMatchesStatement; ///
 
     if (qualifiedStatementVerifiedAgainstTheorem) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${labelString}' theorem.`, statementNode);
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceMetavariableString}' theorem.`, statementNode);
     }
   }
 
   return qualifiedStatementVerifiedAgainstTheorem;
 }
 
-function verifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, labelNode, localContext) {
+function verifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, referenceMetavariableNode, localContext) {
   let qualifiedStatementVerifiedAgainstConjecture = false;
 
-  const conjecture = localContext.findConjectureByLabelNode(labelNode);
+  const labelMetavariableNode = referenceMetavariableNode,  ///
+        conjecture = localContext.findConjectureByLabelMetavariableNode(labelMetavariableNode);
 
   if (conjecture !== null) {
-    const labelString = localContext.nodeAsString(labelNode),
+    const referenceMetavariableString = localContext.nodeAsString(referenceMetavariableNode),
           statementNode = statementNodeQuery(qualifiedStatementNode),
           statementLocalContext = localContext, ///
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${labelString}' conjecture...`, statementNode);
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceMetavariableString}' conjecture...`, statementNode);
 
     const conjectureMatchesStatement = conjecture.matchStatement(statementNode, statementLocalContext);
 
     qualifiedStatementVerifiedAgainstConjecture = conjectureMatchesStatement; ///
 
     if (qualifiedStatementVerifiedAgainstConjecture) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${labelString}' conjecture.`, statementNode);
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceMetavariableString}' conjecture.`, statementNode);
     }
   }
 

package/src/verify/statement.js

@@ -12,9 +12,9 @@ import { nodeQuery } from "../utilities/query";
 const termNodeQuery = nodeQuery("/statement/term!"),
       equalityNodeQuery = nodeQuery("/statement/equality!"),
       definingNodeQuery = nodeQuery("/statement/defining!"),
-      statementNodeQuery = nodeQuery("/metaArgument/statement!"),
+      statementNodeQuery = nodeQuery("/metastatement/statement!"),
       containmentNodeQuery = nodeQuery("/statement/containment!"),
-      metaArgumentNodeQuery = nodeQuery("/statement/metaArgument!"),
+      metastatementNodeQuery = nodeQuery("/statement/metastatement!"),
       typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
 
 function verifyStatement(statementNode, assignments, derived, localContext, verifyAhead) {
@@ -151,11 +151,11 @@ function verifyStatementAboutContainment(statementNode, assignments, derived, lo
     localContext.trace(`Verifying the '${statementString}' statement about containment...`, statementNode);
 
     const termNode = termNodeQuery(statementNode),
-          metaArgumentNode = metaArgumentNodeQuery(statementNode),
-          containmentVerified = verifyContainment(termNode, containmentNode, metaArgumentNode, localContext);
+          metastatementNode = metastatementNodeQuery(statementNode),
+          containmentVerified = verifyContainment(termNode, containmentNode, metastatementNode, localContext);
 
     if (containmentVerified) {
-      statementNode = statementNodeQuery(metaArgumentNode); ///
+      statementNode = statementNodeQuery(metastatementNode); ///
 
       const verifyStatementFunctions = [
         verifyStatementAsEquality,

package/src/verify/statementAgainstMetaType.js

@@ -0,0 +1,21 @@
+"use strict";
+
+import { nodeQuery } from "../utilities/query";
+import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
+
+const metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type!");
+
+export default function verifyStatementAgainstMetaType(statementNode, metaTypeNode, localContext, verifyAhead) {
+  let statementVerifiedAgainstMetaType = false;
+
+  const metaTypeTerminalNode = metaTypeTerminalNodeQuery(metaTypeNode),
+        content = metaTypeTerminalNode.getContent();
+
+  if (content === STATEMENT_META_TYPE_NAME) {
+    const verifiedAhead = verifyAhead();
+
+    statementVerifiedAgainstMetaType = verifiedAhead; ///
+  }
+
+  return statementVerifiedAgainstMetaType;
+}

package/src/verify/statementAtainstStatement.js

@@ -0,0 +1,60 @@
+"use strict";
+
+import TermForVariableSubstitution from "../substitution/termForVariable";
+import intrinsicLevelNodesVerifier from "../verifier/nodes/intrinsicLevel";
+
+import { push } from "../utilities/array";
+
+export default function verifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB) {
+  let statementVerifiedAgainstStatement = false;
+
+  const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionAndSubstitutions(substitution, substitutions),
+        transformed = termForVariableSubstitution.isTransformed(substitution);
+
+  let substitutionsA = []; ///
+
+  if (transformed) {
+    const substitutionA = termForVariableSubstitution;  ///
+
+    substitutionsA.push(substitutionA);
+  }
+
+  const nonTerminalNodeA = statementNodeA,  ///
+        nonTerminalNodeB = statementNodeB,  ///
+        nonTerminalNodeVerified = intrinsicLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutionsA, localContextA, localContextB, () => {
+          const verifiedAhead = true;
+
+          return verifiedAhead;
+        });
+
+  if (nonTerminalNodeVerified) {
+    if (!transformed) {
+      const substitutionB = termForVariableSubstitution,  ///
+            substitutionsB = [
+              substitutionB
+            ];
+
+      substitutionsA = transformSubstitutions(substitutionsA, substitutionsB);
+
+      push(substitutions, substitutionsA);
+    }
+
+    statementVerifiedAgainstStatement = true;
+  }
+
+  return statementVerifiedAgainstStatement;
+}
+
+function transformSubstitutions(substitutionsA, substitutionsB) {
+  substitutionsA = substitutionsA.map((substitutionA) => {
+    const substitution = substitutionA,  ///
+          substitutions = substitutionsB,
+          termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionAndSubstitutions(substitution, substitutions);
+
+    substitutionA = termForVariableSubstitution; ///
+
+    return substitutionA;
+  });
+
+  return substitutionsA;
+}

package/src/verify/term.js

@@ -1,9 +1,8 @@
 "use strict";
 
 import Term from "../term";
-import termAgainstConstructorNodesVerifier from "../verifier/nodes/termAgainstConstructor";
-import verifyGivenVariable from "../verify/givenVariable";
 import bracketedConstructor from "../constructor/bracketed";
+import termAgainstConstructorNodesVerifier from "../verifier/nodes/termAgainstConstructor";
 
 import { first } from "../utilities/array";
 import { nodeQuery } from "../utilities/query";
@@ -74,27 +73,24 @@ function verifyTermAsVariable(termNode, terms, localContext, verifyAhead) {
 
     localContext.trace(`Verifying the '${termString}' term as a variable...`, termNode);
 
-    const variables = [],
-          givenVariableVerified = verifyGivenVariable(variableNode, variables, localContext, () => {
-            let verifiedAhead;
+    const variable = localContext.findVariableByVariableNode(variableNode);
 
-            const firstVariable = first(variables),
-                  variable = firstVariable, ///
-                  type = variable.getType(),
-                  term = Term.fromTermNodeAndType(termNode, type);
+    if (variable !== null) {
+      let verifiedAhead;
 
-            terms.push(term);
+      const type = variable.getType(),
+            term = Term.fromTermNodeAndType(termNode, type);
 
-            verifiedAhead = verifyAhead();
+      terms.push(term);
 
-            if (!verifiedAhead) {
-              terms.pop();
-            }
+      verifiedAhead = verifyAhead();
 
-            return verifiedAhead;
-          });
+      if (!verifiedAhead) {
+        terms.pop();
+      }
 
-    termVerifiedAsVariable = givenVariableVerified;  ///
+      termVerifiedAsVariable = verifiedAhead;  ///
+    }
 
     if (termVerifiedAsVariable) {
       localContext.debug(`...verified the '${termString}' term as a variable.`, termNode);

package/src/verify/termAgainstTerm.js

@@ -0,0 +1,20 @@
+"use strict";
+
+import { areTermNodesEqual } from "../utilities/equivalences";
+
+export default function verifyTermAgainstTerm(termNodeA, termNodeB, localContext, verifyAhead) {
+  let termVerifiedAgainstTerm = false;
+
+  const leftTermNode = termNodeA, ///
+        rightTermNode = termNodeB, ///
+        equivalences = localContext.getEquivalences(),
+        termNodesEqual = areTermNodesEqual(leftTermNode, rightTermNode, equivalences);
+
+  if (termNodesEqual) {
+    const verifiedAhead = verifyAhead();
+
+    termVerifiedAgainstTerm = verifiedAhead;  ///
+  }
+
+  return termVerifiedAgainstTerm;
+}

package/src/verify/termAgainstType.js

@@ -0,0 +1,28 @@
+"use strict";
+
+import { first } from "../utilities/array";
+
+export default function verifyTermAgainstType(termNode, typeNode, localContext, verifyAhead, verifyTerm) {
+  let termVerifiedAgainstType;
+
+  const terms = [],
+        termVerified = verifyTerm(termNode, terms, localContext, () => {
+          let verifiedAhead = false;
+
+          const firstTerm = first(terms),
+                term = firstTerm, ///
+                termType = term.getType(),
+                type = localContext.findTypeByTypeNode(typeNode),
+                termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
+
+          if (termTypeEqualToOrSubTypeOfType) {
+            verifiedAhead = verifyAhead();
+          }
+
+          return verifiedAhead;
+        });
+
+  termVerifiedAgainstType = termVerified; ///
+
+  return termVerifiedAgainstType;
+}

package/src/verify/terms.js

@@ -18,9 +18,7 @@ export default function verifyTerms(termNodes, terms, localContext, verifyAhead)
           let verifiedAhead;
 
           const secondTermVerified = verifyTerm(secondTermNode, terms, localContext, () => {
-            let verifiedAhead;
-
-            verifiedAhead = verifyAhead();
+            const verifiedAhead = verifyAhead();
 
             return verifiedAhead;
           });

package/src/verify/theorem.js

@@ -11,21 +11,21 @@ import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const proofNodeQuery = nodeQuery("/theorem/proof!"),
-      labelNodesQuery = nodesQuery("/theorem//reference/label"),
+      labelsNodeQuery = nodeQuery("/theorem/labels!"),
       consequentNodeQuery = nodeQuery("/theorem/consequent!"),
       suppositionsNodeQuery = nodesQuery("/theorem/supposition");
 
 export default function verifyTheorem(theoremNode, fileContext) {
   let theoremVerified = false;
 
-  const labelNodes = labelNodesQuery(theoremNode),
-        labelsString = fileContext.nodesAsString(labelNodes),
+  const labelsNode = labelsNodeQuery(theoremNode),
+        labelsString = fileContext.nodeAsString(labelsNode),
         localContext = LocalContext.fromFileContext(fileContext);
 
   fileContext.trace(`Verifying the '${labelsString}' theorem...`, theoremNode);
 
   const labels = [],
-        labelsVerified = verifyLabels(labelNodes, labels, fileContext);
+        labelsVerified = verifyLabels(labelsNode, labels, fileContext);
 
   if (labelsVerified) {
     const suppositions = [],

package/src/verify/type.js

@@ -1,7 +1,6 @@
 "use strict";
 
 import Type from "../type";
-import verifyGivenType from "../verify/givenType";
 
 import { typeNameFromTypeNode } from "../utilities/name";
 
@@ -52,16 +51,19 @@ export default function verifyType(typeNode, superTypeNode, fileContext) {
 }
 
 export function verifyStandaloneType(typeNode, localContext, verifyAhead) {
-  let standaloneTypeVerified;
+  let standaloneTypeVerified = false;
 
   const typeString = localContext.nodeAsString(typeNode);
 
   localContext.trace(`Verifying the '${typeString}' standalone type...`, typeNode);
 
-  const types = [],
-        givenTypeVerified = verifyGivenType(typeNode, types, localContext, verifyAhead);
+  const typePresent = localContext.isTypePresentByTypeNode(typeNode);
 
-  standaloneTypeVerified = givenTypeVerified;  ///
+  if (typePresent) {
+    const verifiedAhead = verifyAhead();
+
+    standaloneTypeVerified = verifiedAhead; ///
+  }
 
   if (standaloneTypeVerified) {
     localContext.debug(`...verified the '${typeString}' standalone type.`, typeNode);