occam-verify-cli 0.0.453 → 0.0.455

package/src/verify/assertion/type.js

@@ -1,7 +1,6 @@
 "use strict";
 
 import Variable from "../../variable";
-import verifyTerm from "../../verify/term";
 
 import { first } from "../../utilities/array";
 import { nodeAsString } from "../../utilities/string";
@@ -11,7 +10,7 @@ import { verifyTermAsVariable, verifyTermAgainstConstructors } from "../../verif
 const termNodeQuery = nodeQuery("/typeAssertion/term"),
       typeNodeQuery = nodeQuery("/typeAssertion/type");
 
-export default function verifyTypeAssertion(typeAssertionNode, proofContext) {
+export default function verifyTypeAssertion(typeAssertionNode, types, variables, proofContext) {
   let typeAssertionVerified = false;
 
   proofContext.begin(typeAssertionNode);
@@ -23,22 +22,37 @@ export default function verifyTypeAssertion(typeAssertionNode, proofContext) {
   if (!typePresent) {
     proofContext.error(`The ${typeName} type is not present.`);
   } else {
+    const type = proofContext.findTypeByTypeName(typeName),
+          context = proofContext, ///
+          termNode = termNodeQuery(typeAssertionNode),
+          variables = [],
+          termString = nodeAsString(termNode),
+          termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context);
+
+    if (termVerifiedAsVariable) {
+      types.add(type);
+
+      typeAssertionVerified = true;
+    } else {
+      const termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, values, context);
+
+    }
+
+
+    const ;
+
+
     const derived = proofContext.isDerived();
 
     if (derived) {
       debugger
     } else {
-      const types = [],
-            values = [],
-            context = proofContext, ///
-            termNode = termNodeQuery(typeAssertionNode),
-            termString = nodeAsString(termNode),
-            termVerifiedAsVariable = verifyTermAsVariable(termNode, types, values, context);
 
       if (termVerifiedAsVariable) {
-        const firstValue = first(values),
-              variableName = termString, ///
-              value = firstValue; ///
+        const firstVariable = first(variables),
+              variable = firstVariable, ///
+              variableName = variable.getName(),
+              variableDefined = variable.isDefined();
 
         if (value !== undefined) {
           proofContext.error(`The value of the ${variableName} variable is not undefined.`);
@@ -60,7 +74,6 @@ export default function verifyTypeAssertion(typeAssertionNode, proofContext) {
           }
         }
       } else {
-        const termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, values, context);
 
         if (termVerifiedAgainstConstructors) {
           const type = proofContext.findTypeByTypeName(typeName),

package/src/verify/declaration/topLevel.js

@@ -3,6 +3,7 @@
 import verifyRule from "../../verify/rule";
 import verifyAxiom from "../../verify/axiom";
 import verifyLemma from "../../verify/lemma";
+import verifyTheorem from "../../verify/theorem";
 import verifyTypeDeclaration from "../../verify/declaration/type";
 import verifyVariableDeclaration from "../../verify/declaration/variable";
 import verifyCombinatorDeclaration from "../../verify/declaration/combinator";
@@ -13,6 +14,7 @@ import { nodeQuery } from "../../utilities/query";
 const ruleNodeQuery = nodeQuery("/topLevelDeclaration/rule!"),
       axiomNodeQuery = nodeQuery("/topLevelDeclaration/axiom!"),
       lemmaNodeQuery = nodeQuery("/topLevelDeclaration/lemma!"),
+      theoremNodeQuery = nodeQuery("/topLevelDeclaration/theorem!"),
       typeDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/typeDeclaration!"),
       variableDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/variableDeclaration!"),
       combinatorDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/combinatorDeclaration!"),
@@ -27,6 +29,7 @@ export default function verifyTopLevelDeclaration(topLevelDeclarationNode, fileC
         ruleNode = ruleNodeQuery(node),
         axiomNode = axiomNodeQuery(node),
         lemmaNode = lemmaNodeQuery(node),
+        theoremNode = theoremNodeQuery(node),
         typeDeclarationNode = typeDeclarationNodeQuery(node),
         variableDeclarationNode = variableDeclarationNodeQuery(node),
         combinatorDeclarationNode = combinatorDeclarationNodeQuery(node),
@@ -46,6 +49,10 @@ export default function verifyTopLevelDeclaration(topLevelDeclarationNode, fileC
     const lemmaVerified = verifyLemma(lemmaNode, fileContext);
 
     topLevelDeclarationVerified = lemmaVerified;  ///
+  } else if (theoremNode !== null) {
+    const theoremVerified = verifyTheorem(theoremNode, fileContext);
+
+    topLevelDeclarationVerified = theoremVerified;  ///
   } else if (typeDeclarationNode !== null) {
     const typeDeclarationVerified = verifyTypeDeclaration(typeDeclarationNode, fileContext);
 

package/src/verify/derivation.js

@@ -0,0 +1,156 @@
+"use strict";
+
+import Assertion from "../assertion";
+import ProofContext from "../context/proof";
+import verifyQualifiedStatement from "../verify/statement/qualified";
+import verifyUnqualifiedStatement from "../verify/statement/unqualified";
+
+import { front, last } from "../utilities/array";
+import { nodeQuery, nodesQuery } from "../utilities/query";
+import { SUBPROOF_RULE_NAME, QUALIFIED_STATEMENT_RULE_NAME, UNQUALIFIED_STATEMENT_RULE_NAME } from "../ruleNames";
+
+const derivationNodeQuery = nodeQuery("/subproof/derivation!"),
+      derivationChildNodesQuery = nodesQuery("/derivation/*"),
+      qualifiedStatementNodeQuery = nodeQuery("/qualifiedStatement"),
+      unqualifiedStatementNodeQuery = nodeQuery("/unqualifiedStatement!"),
+      qualifiedOrUnqualifiedStatementNodesQuery = nodesQuery("/subproof/qualifiedStatement|unqualifiedStatement")
+
+export default function verifyDerivation(derivationNode, proofContext) {
+  let derivationVerified,
+      derived;
+
+  proofContext.begin(derivationNode);
+
+  derived = true;
+
+  proofContext.setDerived(derived);
+
+  const derivationChildNodes = derivationChildNodesQuery(derivationNode);
+
+  derivationVerified = derivationChildNodes.every((derivationChildNode) => {  ///
+    const derivationChildVerified = verifyDerivationChild(derivationChildNode, proofContext);
+
+    if (derivationChildVerified) {
+      return true;
+    }
+  });
+
+  derived = false;
+
+  proofContext.setDerived(derived);
+
+  derivationVerified ?
+    proofContext.complete(derivationNode) :
+      proofContext.halt(derivationNode);
+
+  return derivationVerified;
+}
+
+function verifyDerivationChild(derivationChildNode, proofContext) {
+  let derivationChildVerified;
+
+  const ruleName = derivationChildNode.getRuleName();
+
+  switch (ruleName) {
+    case SUBPROOF_RULE_NAME: {
+      const subproofNode = derivationChildNode,  ///
+            subproofVerified = verifySubproof(subproofNode, proofContext);
+
+      if (subproofVerified) {
+        const assertion = Assertion.fromSubproofNode(subproofNode);
+
+        proofContext.addAssertion(assertion);
+
+        derivationChildVerified = true;
+      }
+
+      break;
+    }
+
+    case QUALIFIED_STATEMENT_RULE_NAME: {
+      const qualifiedStatementNode = derivationChildNode,  ///
+            qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, proofContext);
+
+      if (qualifiedStatementVerified) {
+        const assertion = Assertion.fromQualifiedStatementNode(qualifiedStatementNode);
+
+        proofContext.addAssertion(assertion);
+
+        derivationChildVerified = qualifiedStatementVerified; ///
+      }
+
+      break;
+    }
+
+    case UNQUALIFIED_STATEMENT_RULE_NAME: {
+      const unqualifiedStatementNode = derivationChildNode,  ///
+            unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext);
+
+      if (unqualifiedStatementVerified) {
+        const assertion = Assertion.fromUnqualifiedStatementNode(unqualifiedStatementNode);
+
+        proofContext.addAssertion(assertion);
+
+        derivationChildVerified = true;
+      }
+
+      break;
+    }
+  }
+
+  return derivationChildVerified;
+}
+
+function verifySubproof(subproofNode, proofContext) {
+  let subproofVerified = false;
+
+  proofContext = ProofContext.fromProofContext(proofContext); ///
+
+  const qualifiedOrUnqualifiedStatementNodes = qualifiedOrUnqualifiedStatementNodesQuery(subproofNode),
+        frontQualifiedOrUnqualifiedStatementNodes = front(qualifiedOrUnqualifiedStatementNodes),
+        unqualifiedStatementNodes = frontQualifiedOrUnqualifiedStatementNodes,  ///
+        unqualifiedStatementsVerified = unqualifiedStatementNodes.every((unqualifiedStatementNode) => {
+          const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext);
+
+          if (unqualifiedStatementVerified) {
+            return true;
+          }
+        });
+
+  if (unqualifiedStatementsVerified) {
+    unqualifiedStatementNodes.forEach((unqualifiedStatementNode) => {
+      const assertion = Assertion.fromUnqualifiedStatementNode(unqualifiedStatementNode);
+
+      proofContext.addAssertion(assertion);
+    });
+
+    let derivationVerified = true;
+
+    const derivationNode = derivationNodeQuery(subproofNode);
+
+    if (derivationNode !== null) {
+      derivationVerified = verifyDerivation(derivationNode, proofContext);
+    }
+
+    if (derivationVerified) {
+      const lastQualifiedOrUnqualifiedStatementNode = last(qualifiedOrUnqualifiedStatementNodes),
+            qualifiedOrUnqualifiedStatementNode = lastQualifiedOrUnqualifiedStatementNode,  ///
+            qualifiedStatementNode = qualifiedStatementNodeQuery(qualifiedOrUnqualifiedStatementNode),
+            unqualifiedStatementNode = unqualifiedStatementNodeQuery(qualifiedOrUnqualifiedStatementNode);
+
+      if (qualifiedStatementNode !== null) {
+        const qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, proofContext);
+
+        subproofVerified = qualifiedStatementVerified;  ///
+      }
+
+      if (unqualifiedStatementNode !== null) {
+        const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext);
+
+        subproofVerified = unqualifiedStatementVerified;  ///
+      }
+    }
+  }
+
+  return subproofVerified;
+}

package/src/verify/equality.js

@@ -14,12 +14,11 @@ export default function verifyEquality(equalityNode, proofContext) {
   proofContext.begin(equalityNode);
 
   const types = [],
-        values = [],
         context = proofContext,
         firstTermNode = firstTermNodeQuery(equalityNode),
         secondTermNode = secondTermNodeQuery(equalityNode),
-        firstTermVerified = verifyTerm(firstTermNode, types, values, context),
-        secondTermVerified = verifyTerm(secondTermNode, types, values, context);
+        firstTermVerified = verifyTerm(firstTermNode, types, context),
+        secondTermVerified = verifyTerm(secondTermNode, types, context);
 
   if (firstTermVerified && secondTermVerified) {
     const firstType = first(types),
@@ -27,17 +26,7 @@ export default function verifyEquality(equalityNode, proofContext) {
           firstTypeEqualToSubTypeOfOrSuperTypeOfSecondType = firstType.isEqualToSubTypeOfOrSuperTypeOf(secondType);
 
     if (firstTypeEqualToSubTypeOfOrSuperTypeOfSecondType) {
-      const derived = proofContext.isDerived();
-
-      if (derived) {
-        const termsEqual = equateTerms(firstTermNode, secondTermNode, proofContext);
-
-        if (termsEqual) {
-          equalityVerified = true;
-        }
-      } else {
-        equalityVerified = true;
-      }
+      equalityVerified = true;
     }
   }
 
@@ -47,11 +36,3 @@ export default function verifyEquality(equalityNode, proofContext) {
 
   return equalityVerified;
 }
-
-function equateTerms(firstTermNode, secondTermNode, proofContext) {
-  let termsEqual = true;  ///
-
-  debugger
-
-  return termsEqual;
-}

package/src/verify/metaDerivation.js

@@ -16,77 +16,89 @@ const metaDerivationNodeQuery = nodeQuery("/metaSubproof/metaDerivation!"),
       qualifiedOrUnqualifiedMetastatementNodesQuery = nodesQuery("/metaSubproof/qualifiedMetastatement|unqualifiedMetastatement")
 
 export default function verifyMetaDerivation(metaDerivationNode, metaproofContext) {
-  let metaDerivationVerified;
+  let metaDerivationVerified,
+      derived;
 
   metaproofContext.begin(metaDerivationNode);
 
-  const derived = true;
+  derived = true;
 
   metaproofContext.setDerived(derived);
 
-  const metaDerivationChildNodes = metaDerivationChildNodesQuery(metaDerivationNode),
-        metaDerivationChildNodesVerified = metaDerivationChildNodes.every((metaDerivationChildNode) => {
-          let metaDerivationChildNodeVerified;
+  const metaDerivationChildNodes = metaDerivationChildNodesQuery(metaDerivationNode);
 
-          const ruleName = metaDerivationChildNode.getRuleName();
+  metaDerivationVerified = metaDerivationChildNodes.every((metaDerivationChildNode) => {  ///
+    const metaDerivationChildVerified = verifyMetaDerivationChild(metaDerivationChildNode, metaproofContext);
 
-          switch (ruleName) {
-            case META_SUBPROOF_RULE_NAME: {
-              const metaSubproofNode = metaDerivationChildNode,  ///
-                    metaSubproofVerified = verifyMetaSubproof(metaSubproofNode, metaproofContext);
+    if (metaDerivationChildVerified) {
+      return true;
+    }
+  });
 
-              if (metaSubproofVerified) {
-                const metaAssertion = MetaAssertion.fromMetaSubproofNode(metaSubproofNode);
+  derived = false;
 
-                metaproofContext.addMetaAssertion(metaAssertion);
+  metaproofContext.setDerived(derived);
 
-                metaDerivationChildNodeVerified = true;
-              }
+  metaDerivationVerified ?
+    metaproofContext.complete(metaDerivationNode) :
+      metaproofContext.halt(metaDerivationNode);
 
-              break;
-            }
+  return metaDerivationVerified;
+}
 
-            case QUALIFIED_METASTATEMENT_RULE_NAME: {
-              const qualifiedMetastatementNode = metaDerivationChildNode,  ///
-                    qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, metaproofContext);
+function verifyMetaDerivationChild(metaDerivationChildNode, metaproofContext) {
+  let metaDerivationChildVerified;
 
-              if (qualifiedMetastatementVerified) {
-                const metaAssertion = MetaAssertion.fromQualifiedMetastatementNode(qualifiedMetastatementNode);
+  const ruleName = metaDerivationChildNode.getRuleName();
 
-                metaproofContext.addMetaAssertion(metaAssertion);
+  switch (ruleName) {
+    case META_SUBPROOF_RULE_NAME: {
+      const metaSubproofNode = metaDerivationChildNode,  ///
+            metaSubproofVerified = verifyMetaSubproof(metaSubproofNode, metaproofContext);
 
-                metaDerivationChildNodeVerified = qualifiedMetastatementVerified; ///
-              }
+      if (metaSubproofVerified) {
+        const metaAssertion = MetaAssertion.fromMetaSubproofNode(metaSubproofNode);
 
-              break;
-            }
+        metaproofContext.addMetaAssertion(metaAssertion);
 
-            case UNQUALIFIED_METASTATEMENT_RULE_NAME: {
-              const unqualifiedMetastatementNode = metaDerivationChildNode,  ///
-                    unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, metaproofContext);
+        metaDerivationChildVerified = true;
+      }
 
-              if (unqualifiedMetastatementVerified) {
-                const metaAssertion = MetaAssertion.fromUnqualifiedMetastatementNode(unqualifiedMetastatementNode);
+      break;
+    }
 
-                metaproofContext.addMetaAssertion(metaAssertion);
+    case QUALIFIED_METASTATEMENT_RULE_NAME: {
+      const qualifiedMetastatementNode = metaDerivationChildNode,  ///
+            qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, metaproofContext);
 
-                metaDerivationChildNodeVerified = true;
-              }
+      if (qualifiedMetastatementVerified) {
+        const metaAssertion = MetaAssertion.fromQualifiedMetastatementNode(qualifiedMetastatementNode);
 
-              break;
-            }
-          }
+        metaproofContext.addMetaAssertion(metaAssertion);
 
-          return metaDerivationChildNodeVerified;
-        });
+        metaDerivationChildVerified = qualifiedMetastatementVerified; ///
+      }
 
-  metaDerivationVerified = metaDerivationChildNodesVerified;  ///
+      break;
+    }
 
-  metaDerivationVerified ?
-    metaproofContext.complete(metaDerivationNode) :
-      metaproofContext.halt(metaDerivationNode);
+    case UNQUALIFIED_METASTATEMENT_RULE_NAME: {
+      const unqualifiedMetastatementNode = metaDerivationChildNode,  ///
+            unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, metaproofContext);
 
-  return metaDerivationVerified;
+      if (unqualifiedMetastatementVerified) {
+        const metaAssertion = MetaAssertion.fromUnqualifiedMetastatementNode(unqualifiedMetastatementNode);
+
+        metaproofContext.addMetaAssertion(metaAssertion);
+
+        metaDerivationChildVerified = true;
+      }
+
+      break;
+    }
+  }
+
+  return metaDerivationChildVerified;
 }
 
 function verifyMetaSubproof(metaSubproofNode, metaproofContext) {

package/src/verify/proof.js

@@ -0,0 +1,123 @@
+"use strict";
+
+import verifyDerivation from "../verify/derivation";
+import verifyQualifiedStatement from "../verify/statement/qualified";
+
+import { nodeQuery } from "../utilities/query";
+
+const derivationNodeQuery = nodeQuery("/proof/derivation!"),
+      qualifiedStatementNodeQuery = nodeQuery("/proof/qualifiedStatement!"),
+      proofStatementNodeQuery = nodeQuery("/proof/qualifiedStatement/statement!");
+
+export default function verifyProof(proofNode, conclusion, proofContext) {
+  let proofVerified = false;
+
+  proofContext.begin(proofNode);
+
+  const derivationNode = derivationNodeQuery(proofNode);
+
+  let derivationVerified = true;
+
+  if (derivationNode !== null) {
+    derivationVerified = verifyDerivation(derivationNode, proofContext);
+  }
+
+  if (derivationVerified) {
+    const qualifiedStatementNode = qualifiedStatementNodeQuery(proofNode),
+          qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, proofContext);
+
+    if (qualifiedStatementVerified) {
+      const statementNode = conclusion.getStatementNode(),
+            proofStatementNode = proofStatementNodeQuery(proofNode),
+            proofStatementNodeMatches = matchProofStatementNode(proofStatementNode, statementNode);
+
+      proofVerified = proofStatementNodeMatches;  ///
+    }
+  }
+
+  proofVerified ?
+    proofContext.complete(proofNode) :
+      proofContext.complete(proofNode);
+
+  return proofVerified;
+}
+
+function matchProofStatementNode(proofStatementNode, statementNode) {
+  const proofNonTerminalNode = proofStatementNode,  ///
+        nonTerminalNode = statementNode,  ///
+        proofNonTerminalNodeMatches = matchProofNonTerminalNode(proofNonTerminalNode, nonTerminalNode),
+        proofStatementNodeMatches = proofNonTerminalNodeMatches;  ///
+
+  return proofStatementNodeMatches;
+}
+
+function matchProofNode(proofNode, node) {
+  let proofNodeMatches = false;
+
+  const nodeTerminalNode = node.isTerminalNode(),
+        ruleNodeTerminalNode = proofNode.isTerminalNode();
+
+  if (nodeTerminalNode === ruleNodeTerminalNode) {
+    if (nodeTerminalNode) {
+      const terminalNode = node,  ///
+            proofTerminalNode = proofNode,  ///
+            proofTerminalNodeMatches = matchProofTerminalNode(proofTerminalNode, terminalNode);
+
+      proofNodeMatches = proofTerminalNodeMatches;  ///
+    } else {
+      const nonTerminalNode = node, ///
+            proofNonTerminalNode = proofNode,  ///
+            proofNonTerminalNodeMatches = matchProofNonTerminalNode(proofNonTerminalNode, nonTerminalNode);
+
+      proofNodeMatches = proofNonTerminalNodeMatches; ///
+    }
+  }
+
+  return proofNodeMatches;
+}
+
+function matchProofNodes(proofNodes, nodes) {
+  let proofNodesMatches = false;
+
+  const nodesLength = nodes.length,
+        proofNodesLength = proofNodes.length;
+
+  if (nodesLength === proofNodesLength) {
+    proofNodesMatches = nodes.every((node, index) => {
+      const proofNode = proofNodes[index],
+            proofNodeMatches = matchProofNode(proofNode, node);
+
+      if (proofNodeMatches) {
+        return true;
+      }
+    })
+  }
+
+  return proofNodesMatches;
+}
+
+function matchProofTerminalNode(proofTerminalNode, terminalNode) {
+  const matches = proofTerminalNode.match(terminalNode),
+        proofTerminalNodeMatches = matches;  ///
+
+  return proofTerminalNodeMatches;
+}
+
+function matchProofNonTerminalNode(proofNonTerminalNode, nonTerminalNode) {
+  let proofNonTerminalNodeMatches = false;
+
+  const ruleName = nonTerminalNode.getRuleName(),
+        proofRuleName = proofNonTerminalNode.getRuleName(); ///
+
+  if (ruleName === proofRuleName) {
+    const childNodes = nonTerminalNode.getChildNodes(),
+          proofChildNodes = proofNonTerminalNode.getChildNodes(),
+          nodes = childNodes, ///
+          proofNodes = proofChildNodes, ///
+          proofNodesMatches = matchProofNodes(proofNodes, nodes);
+
+    proofNonTerminalNodeMatches = proofNodesMatches; ///
+  }
+
+  return proofNonTerminalNodeMatches;
+}

package/src/verify/statement/unqualified.js

@@ -2,7 +2,10 @@
 
 import verifyStatement from "../../verify/statement";
 
+import Assertion from "../../assertion";
+
 import { nodeQuery } from "../../utilities/query";
+import { nodeAsString } from "../../utilities/string";
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
 
@@ -14,16 +17,80 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, pro
   const statementNode = statementNodeQuery(unqualifiedStatementNode);
 
   if (statementNode !== null) {
-    const statementVerified = verifyStatement(statementNode, proofContext);
+    const derived = proofContext.isDerived();
+
+    if (derived) {
+      const assertion = Assertion.fromStatementNode(statementNode),
+            assertionMatches = proofContext.matchAssertion(assertion);
 
-    if (statementVerified) {
+      unqualifiedStatementVerified = assertionMatches;  ///
+    } else {
       unqualifiedStatementVerified = true;
     }
   }
 
+  if (unqualifiedStatementVerified) {
+    const statementString = nodeAsString(statementNode);
+
+    proofContext.debug(`Verified the '${statementString}' unqualified statement.`);
+  }
+
   unqualifiedStatementVerified ?
     proofContext.complete(unqualifiedStatementNode) :
       proofContext.halt(unqualifiedStatementNode);
 
   return unqualifiedStatementVerified;
 }
+
+// if (derived) {
+//   debugger
+// } else {
+//   const types = [],
+//     context = proofContext, ///
+//     termNode = termNodeQuery(typeAssertionNode),
+//     variables = [],
+//     termString = nodeAsString(termNode),
+//     termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context);
+//
+//   if (termVerifiedAsVariable) {
+//     const firstValue = first(values),
+//       variableName = termString, ///
+//       value = firstValue; ///
+//
+//     if (value !== undefined) {
+//       proofContext.error(`The value of the ${variableName} variable is not undefined.`);
+//     } else {
+//       const type = proofContext.findTypeByTypeName(typeName),
+//         firstType = first(types),
+//         variableType = firstType, ///
+//         typeEqualToOrSubTypeOfVariableType = type.isEqualToOrSubTypeOf(variableType);
+//
+//       if (!typeEqualToOrSubTypeOfVariableType) {
+//         proofContext.error(`The asserted type of the ${variableName} variable is not equal to or a sub-type of its declared type.`);
+//       } else {
+//         const name = variableName,  ///
+//           variable = Variable.fromTypeAndName(type, name);
+//
+//         proofContext.addVariable(variable);
+//
+//         typeAssertionVerified = true;
+//       }
+//     }
+//   } else {
+//     const termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, values, context);
+//
+//     if (termVerifiedAgainstConstructors) {
+//       const type = proofContext.findTypeByTypeName(typeName),
+//         firstType = first(types),
+//         termType = firstType, ///
+//         typeEqualToOrSubTypeOfTermType = type.isEqualToOrSubTypeOf(termType);
+//
+//       if (!typeEqualToOrSubTypeOfTermType) {
+//         proofContext.error(`The asserted type of the '${termString}' term is not equal to or a sub-type of its declared type.`);
+//       } else {
+//
+//         typeAssertionVerified = true;
+//       }
+//     }
+//   }
+// }

package/src/verify/statement.js

@@ -27,7 +27,8 @@ export default function verifyStatement(statementNode, proofContext) {
 
     statementVerified = equalityVerified; ///
   } else if (typeAssertionNode !== null) {
-    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, proofContext);
+    const types = [],
+          typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, types, proofContext);
 
     statementVerified = typeAssertionVerified; ///
   } else {