occam-verify-cli 0.0.479 → 0.0.481

package/src/premise.js

@@ -195,6 +195,8 @@ function matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, su
         childNodes = nonTerminalNode.getChildNodes(),
         premiseNonTerminalNodeRuleName = premiseNonTerminalNode.getRuleName(),
         premiseNonTerminalNodeChildNodes = premiseNonTerminalNode.getChildNodes(),
+        nodes = childNodes, ///
+        premiseNodes = premiseNonTerminalNodeChildNodes, ///
         ruleNameStatementRuleName = (ruleName === STATEMENT_RULE_NAME),
         premiseNonTerminalNodeRuleNameMetastatementRuleName = (premiseNonTerminalNodeRuleName === METASTATEMENT_RULE_NAME);
 
@@ -206,16 +208,12 @@ function matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, su
     if (premiseMetastatementNodeMatches) {
       premiseNonTerminalNodeMatches = true;
     } else {
-      const nodes = childNodes, ///
-            premiseNodes = premiseNonTerminalNodeChildNodes, ///
-            premiseNonTerminalNodeChildNodesMatches = matchPremiseNodes(premiseNodes, nodes, substitutions);
+      const premiseNonTerminalNodeChildNodesMatches = matchPremiseNodes(premiseNodes, nodes, substitutions);
 
       premiseNonTerminalNodeMatches = premiseNonTerminalNodeChildNodesMatches; ///
     }
   } else if (ruleName === premiseNonTerminalNodeRuleName) {
-    const nodes = childNodes, ///
-          premiseNodes = premiseNonTerminalNodeChildNodes, ///
-          premiseNonTerminalNodeChildNodesMatches = matchPremiseNodes(premiseNodes, nodes, substitutions);
+    const premiseNonTerminalNodeChildNodesMatches = matchPremiseNodes(premiseNodes, nodes, substitutions);
 
     premiseNonTerminalNodeMatches = premiseNonTerminalNodeChildNodesMatches; ///
   }
@@ -223,7 +221,7 @@ function matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, su
   return premiseNonTerminalNodeMatches;
 }
 
-function matchPremiseMetavariableNode(premiseMetavariableNode, nodes, substitutions) {
+function matchPremiseMetavariableNode(premiseMetavariableNode, statementNode, substitutions) {
   let premiseMetavariableNodeMatches;
 
   const premiseMetavariableName = metavariableNameFromMetavariableNode(premiseMetavariableNode),
@@ -236,12 +234,12 @@ function matchPremiseMetavariableNode(premiseMetavariableNode, nodes, substituti
         }) || null;
 
   if (substitution !== null) {
-    const substitutionNodesMatch = substitution.matchNodes(nodes);
+    const substitutionNodesMatch = substitution.matchStatementNode(statementNode);
 
     premiseMetavariableNodeMatches = substitutionNodesMatch;  ///
   } else {
     const metavariableName = premiseMetavariableName, ///
-          substitution = Substitution.fromMetavariableNameAndNodes(metavariableName, nodes);
+          substitution = Substitution.fromMetavariableNameAndStatementNode(metavariableName, statementNode);
 
     substitutions.push(substitution);
 
@@ -270,10 +268,7 @@ function matchPremiseMetastatementNode(premiseMetastatementNode, statementNode,
 
       if (premiseNonTerminalChildNodeRuleNameMetavariableRuleName) {
         const premiseMetavariableNode = premiseNonTerminalChildNode,  ///
-              nonTerminalNode = statementNode,  ///
-              childNodes = nonTerminalNode.getChildNodes(),
-              nodes = childNodes, ///
-              premiseMetaVariableNodeMatches = matchPremiseMetavariableNode(premiseMetavariableNode, nodes, substitutions);
+              premiseMetaVariableNodeMatches = matchPremiseMetavariableNode(premiseMetavariableNode, statementNode, substitutions);
 
         premiseMetastatementNodeMatches = premiseMetaVariableNodeMatches; ///
       }
@@ -339,7 +334,11 @@ function metaMatchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode
   let premiseNonTerminalNodeMatches = false;
 
   const ruleName = nonTerminalNode.getRuleName(),
+        childNodes = nonTerminalNode.getChildNodes(),
         premiseNonTerminalNodeRuleName = premiseNonTerminalNode.getRuleName(),
+        premiseNonTerminalNodeChildNodes = premiseNonTerminalNode.getChildNodes(),
+        nodes = childNodes, ///
+        premiseNodes = premiseNonTerminalNodeChildNodes, ///
         ruleNameMetastatementRuleName = (ruleName === METASTATEMENT_RULE_NAME),
         premiseNonTerminalNodeRuleNameMetastatementRuleName = (premiseNonTerminalNodeRuleName === METASTATEMENT_RULE_NAME);
 
@@ -348,13 +347,15 @@ function metaMatchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode
           premiseMetastatementNode = premiseNonTerminalNode,  ///
           premiseMetastatementNodeMatches = metaMatchPremiseMetastatementNode(premiseMetastatementNode, metastatementNode, metaSubstitutions);
 
-    premiseNonTerminalNodeMatches = premiseMetastatementNodeMatches; ///
+    if (premiseMetastatementNodeMatches) {
+      premiseNonTerminalNodeMatches = true;
+    } else {
+      const premiseNonTerminalNodeChildNodesMatches = metaMatchPremiseNodes(premiseNodes, nodes, metaSubstitutions);
+
+      premiseNonTerminalNodeMatches = premiseNonTerminalNodeChildNodesMatches; ///
+    }
   } else if (ruleName === premiseNonTerminalNodeRuleName) {
-    const childNodes = nonTerminalNode.getChildNodes(),
-          premiseNonTerminalNodeChildNodes = premiseNonTerminalNode.getChildNodes(), ///
-          nodes = childNodes, ///
-          premiseNodes = premiseNonTerminalNodeChildNodes, ///
-          premiseNonTerminalNodeChildNodesMatches = metaMatchPremiseNodes(premiseNodes, nodes, metaSubstitutions);
+    const premiseNonTerminalNodeChildNodesMatches = metaMatchPremiseNodes(premiseNodes, nodes, metaSubstitutions);
 
     premiseNonTerminalNodeMatches = premiseNonTerminalNodeChildNodesMatches; ///
   }
@@ -362,7 +363,7 @@ function metaMatchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode
   return premiseNonTerminalNodeMatches;
 }
 
-function metaMatchPremiseMetavariableNode(premiseMetavariableNode, nodes, metaSubstitutions) {
+function metaMatchPremiseMetavariableNode(premiseMetavariableNode, metastatementNode, metaSubstitutions) {
   let premiseMetavariableNodeMatches;
 
   const premiseMetavariableName = metavariableNameFromMetavariableNode(premiseMetavariableNode),
@@ -375,12 +376,12 @@ function metaMatchPremiseMetavariableNode(premiseMetavariableNode, nodes, metaSu
         }) || null;
 
   if (metaSubstitution !== null) {
-    const metaSubstitutionNodesMatch = metaSubstitution.matchNodes(nodes);
+    const metaSubstitutionNodesMatch = metaSubstitution.matchMetastatementNode(metastatementNode);
 
     premiseMetavariableNodeMatches = metaSubstitutionNodesMatch;  ///
   } else {
     const metavariableName = premiseMetavariableName, ///
-          metaSubstitution = MetaSubstitution.fromMetavariableNameAndNodes(metavariableName, nodes);
+          metaSubstitution = MetaSubstitution.fromMetavariableNameAndMetastatementNode(metavariableName, metastatementNode);
 
     metaSubstitutions.push(metaSubstitution);
 
@@ -409,10 +410,7 @@ function metaMatchPremiseMetastatementNode(premiseMetastatementNode, metastateme
 
       if (premiseNonTerminalChildNodeRuleNameMetavariableRuleName) {
         const premiseMetavariableNode = premiseNonTerminalChildNode,  ///
-              nonTerminalNode = metastatementNode,  ///
-              childNodes = nonTerminalNode.getChildNodes(),
-              nodes = childNodes, ///
-              premiseMetaVariableNodeMatches = metaMatchPremiseMetavariableNode(premiseMetavariableNode, nodes, metaSubstitutions);
+              premiseMetaVariableNodeMatches = metaMatchPremiseMetavariableNode(premiseMetavariableNode, metastatementNode, metaSubstitutions);
 
         premiseMetastatementNodeMatches = premiseMetaVariableNodeMatches; ///
       }

package/src/substitution.js

@@ -1,59 +1,63 @@
 "use strict";
 
-import { matchNodes, bracketedChildNodeFromChildNodes } from "./utilities/node";
+import { STATEMENT_RULE_NAME } from "./ruleNames";
+import { matchNode, bracketedNonTerminalChildNodeFromChildNodes } from "./utilities/node";
 
 export default class Substitution {
-  constructor(metavariableName, nodes) {
+  constructor(metavariableName, statementNode) {
     this.metavariableName = metavariableName;
-    this.nodes = nodes;
+    this.statementNode = statementNode;
   }
 
   getMetavariableName() {
     return this.metavariableName;
   }
 
-  getNodes() {
-    return this.nodes;
+  getStatementNode() {
+    return this.statementNode;
   }
 
-  matchNodes(nodes) {
-    let matches;
+  matchStatementNode(statementNode) {
+    let matchesStatementNode;
 
-    const nodesA = this.nodes,  ///
-          nodesB = nodes,
-          nodesMatch = matchNodes(nodesA, nodesB);
+    const nodeA = this.statementNode,  ///
+          nodeB = statementNode,
+          nodeMatches = matchNode(nodeA, nodeB);
 
-    matches = nodesMatch;  ///
+    matchesStatementNode = nodeMatches;  ///
 
-    if (!matches) {
-      const childNodes = nodes, ///
-            bracketedChildNode = bracketedChildNodeFromChildNodes(childNodes);
+    if (!matchesStatementNode) {
+      const nonTerminalNode = statementNode,  ///
+            childNodes = nonTerminalNode.getChildNodes(), ///
+            ruleName = STATEMENT_RULE_NAME;
 
-      if (bracketedChildNode !== null) {
-        const nonTerminalNode = bracketedChildNode,  ///
-              childNodes = nonTerminalNode.getChildNodes(),
-              nodesB = childNodes, ///
-              nodesMatch = matchNodes(nodesA, nodesB);
+      statementNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
 
-        matches = nodesMatch; ///
+      if (statementNode !== null) {
+        const nodeA = this.statementNode,  ///
+              nodeB = statementNode,
+              nodeMatches = matchNode(nodeA, nodeB);
+
+        matchesStatementNode = nodeMatches;  ///
       }
     }
 
-    return matches;
+    return matchesStatementNode;
   }
 
-  static fromMetavariableNameAndNodes(metavariableName, nodes) {
-    const bracketedChildNode = bracketedChildNodeFromChildNodes(nodes);
+  static fromMetavariableNameAndStatementNode(metavariableName, statementNode) {
+    let substitution = new Substitution(metavariableName, statementNode);
 
-    if (bracketedChildNode !== null) {
-      const nonTerminalNode = bracketedChildNode,  ///
-            childNodes = nonTerminalNode.getChildNodes();
+    const nonTerminalNode = statementNode,  ///
+          childNodes = nonTerminalNode.getChildNodes(),
+          ruleName = STATEMENT_RULE_NAME;
 
-      nodes = childNodes; ///
-    }
+    statementNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
 
-    const metaSubstitution = new Substitution(metavariableName, nodes);
+    if (statementNode !== null) {
+      substitution = new Substitution(metavariableName, statementNode);
+    }
 
-    return metaSubstitution;
+    return substitution;
   }
 }

package/src/utilities/node.js

@@ -61,10 +61,10 @@ export function matchBracketedNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB
   if (!bracketedNodeMatches) {
     const nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
           childNodesA = nonTerminalNodeAChildNodes, ///
-          bracketedChildNodeA = bracketedChildNodeFromChildNodes(childNodesA);
+          bracketedNonTerminalChildNodeA = bracketedNonTerminalChildNodeFromChildNodes(childNodesA);
 
-    if (bracketedChildNodeA !== null) {
-      const nodeA = bracketedChildNodeA,  ///
+    if (bracketedNonTerminalChildNodeA !== null) {
+      const nodeA = bracketedNonTerminalChildNodeA,  ///
             nodeB = nonTerminalNodeB, ///
             nodeMatches = matchNode(nodeA, nodeB);
 
@@ -75,10 +75,10 @@ export function matchBracketedNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB
   if (!bracketedNodeMatches) {
     const nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
           childNodesB = nonTerminalNodeBChildNodes, ///
-          bracketedChildNodeB = bracketedChildNodeFromChildNodes(childNodesB);
+          bracketedNonTerminalChildNodeB = bracketedNonTerminalChildNodeFromChildNodes(childNodesB);
 
-    if (bracketedChildNodeB !== null) {
-      const nodeB = bracketedChildNodeB,  ///
+    if (bracketedNonTerminalChildNodeB !== null) {
+      const nodeB = bracketedNonTerminalChildNodeB,  ///
             nodeA = nonTerminalNodeA, ///
             nodeMatches = matchNode(nodeA, nodeB);
 
@@ -89,8 +89,8 @@ export function matchBracketedNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB
   return bracketedNodeMatches;
 }
 
-export function bracketedChildNodeFromChildNodes(childNodes) {
-  let bracketedChildNode = null;
+export function bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName = METASTATEMENT_RULE_NAME) {
+  let bracketedNonTerminalChildNode = null;
 
   const childNodesLength = childNodes.length;
 
@@ -109,17 +109,17 @@ export function bracketedChildNodeFromChildNodes(childNodes) {
             nonTerminalNodeRuleName = nonTerminalNode.getRuleName(),
             firstTerminalNodeContent = firstTerminalNode.getContent(),
             secondTerminalNodeContent = secondTerminalNode.getContent(),
+            nonTerminalNodeRuleNameRuleName = (nonTerminalNodeRuleName === ruleName),
             firstTerminalNodeContentLeftBracket = (firstTerminalNodeContent === LEFT_BRACKET),
-            secondTerminalNodeContentRightBracket = (secondTerminalNodeContent === RIGHT_BRACKET),
-            nonTerminalNodeRuleNameMetastatementRuleName = (nonTerminalNodeRuleName === METASTATEMENT_RULE_NAME);
+            secondTerminalNodeContentRightBracket = (secondTerminalNodeContent === RIGHT_BRACKET);
 
-      if (firstTerminalNodeContentLeftBracket && nonTerminalNodeRuleNameMetastatementRuleName && secondTerminalNodeContentRightBracket) {
-        bracketedChildNode = nonTerminalNode;  ///
+      if (nonTerminalNodeRuleNameRuleName && firstTerminalNodeContentLeftBracket && secondTerminalNodeContentRightBracket) {
+        bracketedNonTerminalChildNode = nonTerminalNode;  ///
       }
     }
   }
 
-  return bracketedChildNode;
+  return bracketedNonTerminalChildNode;
 }
 
 function matchTerminalNode(terminalNodeA, terminalNodeB) {

package/src/verify/statement.js

@@ -1,37 +1,33 @@
 "use strict";
 
-import verifyEquality from "../verify/equality";
-import verifyTypeAssertion from "../verify/assertion/type";
+import verifyStatementAsEquality from "../verify/statementAsEquality";
+import verifyStatementTypeAssertion from "../verify/statementTypeAssertion";
 
-import { nodeQuery } from "../utilities/query";
 import { nodeAsString } from "../utilities/string";
 
-const equalityNodeQuery = nodeQuery("/statement/equality!"),
-      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
-
 export default function verifyStatement(statementNode, proofContext) {
   let statementVerified = false;
 
   proofContext.begin(statementNode);
 
-  const equalityNode = equalityNodeQuery(statementNode),
-        statementString = nodeAsString(statementNode),
-        typeAssertionNode = typeAssertionNodeQuery(statementNode);
+  const statementString = nodeAsString(statementNode);
 
   proofContext.debug(`Verifying the '${statementString}' statement...`);
 
-  if (false) {
-    ///
-  } else if (equalityNode !== null) {
-    const equalityVerified = verifyEquality(equalityNode, proofContext);
+  if (!statementVerified) {
+    const equalityVerifiedAsEquality = verifyStatementAsEquality(statementNode, proofContext);
+
+    statementVerified = equalityVerifiedAsEquality; ///
+  }
 
-    statementVerified = equalityVerified; ///
-  } else if (typeAssertionNode !== null) {
-    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, proofContext);
+  if (!statementVerified) {
+    const statementTypeAssertionVerified = verifyStatementTypeAssertion(statementNode, proofContext);
+
+    statementVerified = statementTypeAssertionVerified; ///
+  }
 
-    statementVerified = typeAssertionVerified; ///
-  } else {
-    statementVerified = true;
+  if (!statementVerified) {
+    statementVerified = true; ///
   }
 
   statementVerified ?

package/src/verify/statementAsEquality.js

@@ -0,0 +1,146 @@
+"use strict";
+
+import Equality from "../equality";
+import Variable from "../variable";
+import verifyTerm from "../verify/term";
+
+import { nodeQuery } from "../utilities/query";
+import { nodeAsString } from "../utilities/string";
+import { first, second } from "../utilities/array";
+import { verifyTermAsVariable } from "../verify/term";
+import { EQUALS_CHARACTER, MAXIMUM_INDEXES_LENGTH } from "../constants";
+
+const specialNodeQuery = nodeQuery("/statement/@special!"),
+      leftTermNodeQuery = nodeQuery("/statement/term[0]"),
+      rightTermNodeQuery = nodeQuery("/statement/term[1]");
+
+export default function verifyStatementAsEquality(statementNode, proofContext) {
+  let statementVerifiedAsEquality = false;
+
+  proofContext.begin(statementNode);
+
+  const statementString = nodeAsString(statementNode);
+
+  proofContext.debug(`Verifying the '${statementString}' statement as an equality...`);
+
+  const specialNode = specialNodeQuery(statementNode);
+
+  if (specialNode !== null) {
+    const terminalNode = specialNode, ///
+          terminalNodeContent = terminalNode.getContent();
+
+    if (terminalNodeContent === EQUALS_CHARACTER) {
+      const types = [],
+            context = proofContext,  ///
+            leftTermNode = leftTermNodeQuery(statementNode),
+            rightTermNode = rightTermNodeQuery(statementNode),
+            leftTermVerified = verifyTerm(leftTermNode, types, context),
+            rightTermVerified = verifyTerm(rightTermNode, types, context);
+
+      if (leftTermVerified && rightTermVerified) {
+        const firstType = first(types),
+              secondType = second(types),
+              leftType = firstType, ///
+              rightType = secondType, ///
+              leftTermString = nodeAsString(leftTermNode),
+              rightTermString = nodeAsString(rightTermNode);
+
+        if ((leftType === null) && (rightType === null)) {
+          proofContext.error(`The types of the '${leftTermString}' and '${rightTermString}' terms are both undefined and therefore the terms cannot be equated.`);
+        } else if (rightType === null) {
+          const type = leftType,  ///
+                termNode = rightTermNode, ///
+                variable = addVariable(type, termNode, proofContext);
+
+          if (variable !== null) {
+            const leftTypeName = leftType.getName();
+
+            proofContext.info(`The '${rightTermString}' variable has been given the '${leftTypeName}' type.`);
+
+            statementVerifiedAsEquality = true;
+          }
+        } else if (leftType === null) {
+          const type = rightType,  ///
+                termNode = leftType, ///
+                variable = addVariable(type, termNode, proofContext);
+
+          if (variable !== null) {
+            const rightTypeName = rightType.getName();
+
+            proofContext.info(`The '${rightTermString}' variable has been given the '${rightTypeName}' type.`);
+
+            statementVerifiedAsEquality = true;
+          }
+        } else {
+          const leftTypeMatchesRightType = leftType.match(rightType);
+
+          if (!leftTypeMatchesRightType) {
+            proofContext.error(`The types of the '${leftTermString}' and '${rightTermString}' terms do not match and therefore the terms cannot be equated.`);
+          } else {
+            const derived = proofContext.isDerived();
+
+            if (!derived) {
+              statementVerifiedAsEquality = true;
+            } else {
+              const equality = Equality.fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode),
+                    proofSteps = proofContext.getProofSteps(),
+                    equalities = equalitiesFromProofSteps(proofSteps),
+                    equalityEquates = equality.equate(equalities, proofContext);
+
+              statementVerifiedAsEquality = equalityEquates;  ///
+            }
+          }
+        }
+      }
+    }
+  }
+
+  if (statementVerifiedAsEquality) {
+    proofContext.info(`Verified the '${statementString}' equality.`);
+  }
+
+  statementVerifiedAsEquality ?
+    proofContext.complete(statementNode) :
+      proofContext.halt(statementNode);
+
+  return statementVerifiedAsEquality;
+}
+
+function equalitiesFromProofSteps(proofSteps) {
+  const start = -MAXIMUM_INDEXES_LENGTH;  ///
+
+  proofSteps = proofSteps.slice(start); ///
+
+  const equalities = proofSteps.reduce((equalities, proofStep, index) => {
+    const equality = Equality.fromProofStep(proofStep);
+
+    if (equality !== null) {
+      equalities.push(equality);
+    }
+
+    return equalities;
+  }, []);
+
+  return equalities;
+}
+
+function addVariable(type, termNode, proofContext) {
+  let variable = null;
+
+  const variables = [],
+        termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, proofContext);
+
+  if (termVerifiedAsVariable) {
+    const firstVariable = first(variables);
+
+    variable = firstVariable;  ///
+
+    const name = variable.getName();
+
+    variable = Variable.fromTypeAndName(type, name);  ///
+
+    proofContext.addVariable(variable);
+  }
+
+  return variable;
+}

package/src/verify/{assertion/type.js → statementTypeAssertion.js}

@@ -1,53 +1,59 @@
 "use strict";
 
-import { first } from "../../utilities/array";
-import { nodeAsString } from "../../utilities/string";
-import { nodeQuery, typeNameFromTypeNode } from "../../utilities/query";
-import { verifyTermAsVariable, verifyTermAgainstConstructors } from "../../verify/term";
-import Variable from "../../variable";
+import Variable from "../variable";
+
+import { first } from "../utilities/array";
+import { nodeAsString } from "../utilities/string";
+import { nodeQuery, typeNameFromTypeNode } from "../utilities/query";
+import { verifyTermAsVariable, verifyTermAgainstConstructors } from "../verify/term";
 
 const termNodeQuery = nodeQuery("/typeAssertion/term"),
-      typeNodeQuery = nodeQuery("/typeAssertion/type");
+      typeNodeQuery = nodeQuery("/typeAssertion/type"),
+      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
 
-export default function verifyTypeAssertion(typeAssertionNode, proofContext) {
+export default function verifyStatementTypeAssertion(statementNode, proofContext) {
   let typeAssertionVerified = false;
 
-  proofContext.begin(typeAssertionNode);
+  proofContext.begin(statementNode);
 
-  const typeAssertionString = nodeAsString(typeAssertionNode);
+  const statementString = nodeAsString(statementNode);
 
-  proofContext.debug(`Verifying the '${typeAssertionString}' type assertion...`);
+  proofContext.debug(`Verifying the '${statementString}' statement type assertion...`);
 
-  const typeNode = typeNodeQuery(typeAssertionNode),
-        typeName = typeNameFromTypeNode(typeNode),
-        typePresent = proofContext.isTypePresentByTypeName(typeName);
-
-  if (!typePresent) {
-    proofContext.error(`The ${typeName} type is not present.`);
-  } else {
-    const context = proofContext, ///
-          termNode = termNodeQuery(typeAssertionNode),
-          variables = [],
-          termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context);
+  const typeAssertionNode = typeAssertionNodeQuery(statementNode);
 
-    if (termVerifiedAsVariable) {
-      const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, proofContext);
+  if (typeAssertionNode !== null) {
+    const typeNode = typeNodeQuery(typeAssertionNode),
+          typeName = typeNameFromTypeNode(typeNode),
+          typePresent = proofContext.isTypePresentByTypeName(typeName);
 
-      typeAssertionVerified = variableTypeAssertionVerified;  ///
+    if (!typePresent) {
+      proofContext.error(`The ${typeName} type is not present.`);
     } else {
-      const termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, proofContext);
+      const context = proofContext, ///
+            termNode = termNodeQuery(typeAssertionNode),
+            variables = [],
+            termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context);
+
+      if (termVerifiedAsVariable) {
+        const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, proofContext);
+
+        typeAssertionVerified = variableTypeAssertionVerified;  ///
+      } else {
+        const termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, proofContext);
 
-      typeAssertionVerified = termTypeAssertionVerified;  ///
+        typeAssertionVerified = termTypeAssertionVerified;  ///
+      }
     }
   }
 
   if (typeAssertionVerified) {
-    proofContext.info(`Verified the '${typeAssertionString}' type assertion.`);
+    proofContext.info(`Verified the '${statementString}' statement type assertion.`);
   }
 
   typeAssertionVerified ?
-    proofContext.complete(typeAssertionNode) :
-      proofContext.halt(typeAssertionNode);
+    proofContext.complete(statementNode) :
+      proofContext.halt(statementNode);
 
   return typeAssertionVerified;
 }