occam-verify-cli 0.0.449 → 0.0.451

package/lib/verify/term.js

@@ -2,46 +2,79 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    default: function() {
         return verifyTerm;
+    },
+    verifyTermAsVariable: function() {
+        return verifyTermAsVariable;
+    },
+    verifyTermAgainstConstructors: function() {
+        return verifyTermAgainstConstructors;
     }
 });
-var _termAsVariable = /*#__PURE__*/ _interopRequireDefault(require("../verify/termAsVariable"));
 var _array = require("../utilities/array");
 var _string = require("../utilities/string");
 var _ruleNames = require("../ruleNames");
 var _query = require("../utilities/query");
-function _interopRequireDefault(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-var termNodeQuery = (0, _query.nodeQuery)("/argument/term!"), typeNodeQuery = (0, _query.nodeQuery)("/argument/type!");
+var termNodeQuery = (0, _query.nodeQuery)("/argument/term!"), typeNodeQuery = (0, _query.nodeQuery)("/argument/type!"), variableNodeQuery = (0, _query.nodeQuery)("/term/variable!");
 function verifyTerm(termNode, types, values, context) {
     var termVerified = false;
     context.begin(termNode);
-    var names = [], termVerifiedAsVariable = (0, _termAsVariable.default)(termNode, types, names, values, context);
+    var termVerifiedAsVariable = verifyTermAsVariable(termNode, types, values, context);
     if (termVerifiedAsVariable) {
         termVerified = true;
     } else {
-        var constructors = context.getConstructors(), constructor = constructors.find(function(constructor) {
-            var termVerifiedAgainstConstructor = verifyTermAgainstConstructor(termNode, constructor, context);
-            if (termVerifiedAgainstConstructor) {
-                return true;
-            }
-        }) || null;
-        if (constructor !== null) {
-            var type = constructor.getType(), value = termNode; ///
-            types.push(type);
-            values.push(value);
+        var termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, values, context);
+        if (termVerifiedAgainstConstructors) {
             termVerified = true;
         }
     }
     termVerified ? context.complete(termNode) : context.halt(termNode);
     return termVerified;
 }
+function verifyTermAsVariable(termNode, types, values, context) {
+    var termVerifiedAsVariable = false;
+    context.begin(termNode);
+    var variableNode = variableNodeQuery(termNode);
+    if (variableNode !== null) {
+        var variableName = (0, _query.variableNameFromVariableNode)(variableNode), variablePresent = context.isVariablePresentByVariableName(variableName);
+        if (!variablePresent) {
+            context.error("The ".concat(variableName, " variable is not present."));
+        } else {
+            var variable = context.findVariableByVariableName(variableName), type = variable.getType(), value = variable.getValue();
+            types.push(type);
+            values.push(value);
+            termVerifiedAsVariable = true;
+        }
+    }
+    termVerifiedAsVariable ? context.complete(termNode) : context.halt(termNode);
+    return termVerifiedAsVariable;
+}
+function verifyTermAgainstConstructors(termNode, types, values, context) {
+    var termVerifiedAgainstConstructors = false;
+    context.begin(termNode);
+    var constructors = context.getConstructors(), constructor = constructors.find(function(constructor) {
+        var termVerifiedAgainstConstructor = verifyTermAgainstConstructor(termNode, constructor, context);
+        if (termVerifiedAgainstConstructor) {
+            return true;
+        }
+    }) || null;
+    if (constructor !== null) {
+        var type = constructor.getType(), value = termNode; ///
+        types.push(type);
+        values.push(value);
+        termVerifiedAgainstConstructors = true;
+    }
+    termVerifiedAgainstConstructors ? context.complete(termNode) : context.halt(termNode);
+    return termVerifiedAgainstConstructors;
+}
 function verifyTermAgainstConstructor(termNode, constructor, context) {
     var constructorTermNode = constructor.getTermNode(), node = termNode, constructorNode = constructorTermNode, nodeVerified = verifyNode(node, constructorNode, context), termVerifiedAgainstConstructor = nodeVerified; ///
     return termVerifiedAgainstConstructor;
@@ -120,4 +153,4 @@ function verifyArgumentNode(argumentNode, constructorArgumentNode, context) {
     return argumentNodeVerified;
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/verify/term.js"],"sourcesContent":["\"use strict\";\n\nimport verifyTermAsVariable from \"../verify/termAsVariable\";\n\nimport { first } from \"../utilities/array\";\nimport { nodeAsString } from \"../utilities/string\";\nimport { ARGUMENT_RULE_NAME } from \"../ruleNames\";\nimport { nodeQuery, typeNameFromTypeNode } from \"../utilities/query\";\n\nconst termNodeQuery = nodeQuery(\"/argument/term!\"),\n      typeNodeQuery = nodeQuery(\"/argument/type!\")\n\nexport default function verifyTerm(termNode, types, values, context) {\n  let termVerified = false;\n\n  context.begin(termNode);\n\n  const names = [],\n        termVerifiedAsVariable = verifyTermAsVariable(termNode, types, names, values, context);\n\n  if (termVerifiedAsVariable) {\n    termVerified = true;\n  } else {\n    const constructors = context.getConstructors(),\n          constructor = constructors.find((constructor) => {\n            const termVerifiedAgainstConstructor = verifyTermAgainstConstructor(termNode, constructor, context);\n\n            if (termVerifiedAgainstConstructor) {\n              return true;\n            }\n          }) || null;\n\n    if (constructor !== null) {\n      const type = constructor.getType(),\n            value = termNode; ///\n\n      types.push(type);\n\n      values.push(value);\n\n      termVerified = true;\n    }\n  }\n\n  termVerified ?\n    context.complete(termNode) :\n      context.halt(termNode);\n\n  return termVerified;\n}\n\nfunction verifyTermAgainstConstructor(termNode, constructor, context) {\n  const constructorTermNode = constructor.getTermNode(),\n        node = termNode,  ///\n        constructorNode = constructorTermNode, ///\n        nodeVerified = verifyNode(node, constructorNode, context),\n        termVerifiedAgainstConstructor = nodeVerified;  ///\n\n  return termVerifiedAgainstConstructor;\n}\n\nfunction verifyNode(node, constructorNode, context) {\n  let nodeVerified;\n\n  const nodeTerminalNode = node.isTerminalNode(),\n        constructorNodeTerminalNode = constructorNode.isTerminalNode();\n\n  if (nodeTerminalNode === constructorNodeTerminalNode) {\n    if (nodeTerminalNode) {\n      const terminalNode = node,  ///\n            constructorTerminalNode = constructorNode,  ///\n            terminalNodeVerified = verifyTerminalNode(terminalNode, constructorTerminalNode, context);\n\n      nodeVerified = terminalNodeVerified;  ///\n    } else {\n      const nonTerminalNode = node, ///\n            constructorNonTerminalNode = constructorNode,  ///\n            nonTerminalNodeVerified = verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, context);\n\n      nodeVerified = nonTerminalNodeVerified; ///\n    }\n  }\n\n  return nodeVerified;\n}\n\nfunction verifyChildNodes(childNodes, constructorChildNodes, context) {\n  let childNodesVerified = false;\n\n  const childNodesLength = childNodes.length,\n        constructorChildNodesLength = constructorChildNodes.length;\n\n  if (childNodesLength === constructorChildNodesLength) {\n    childNodesVerified = childNodes.every((childNode, index) => {\n      const constructorChildNode = constructorChildNodes[index],\n            node = childNode, ///\n            constructorNode = constructorChildNode,  ///\n            nodeVerified = verifyNode(node, constructorNode, context);\n\n      if (nodeVerified) {\n        return true;\n      }\n    });\n  }\n\n  return childNodesVerified;\n}\n\nfunction verifyTerminalNode(terminalNode, constructorTerminalNode, context) {\n  let terminalNodeVerified = false;\n\n  const matches = terminalNode.match(constructorTerminalNode);\n\n  if (matches) {\n    terminalNodeVerified = true;\n  }\n\n  return terminalNodeVerified;\n}\n\nfunction verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, context) {\n  let nonTerminalNodeVerified = false;\n\n  const ruleName = nonTerminalNode.getRuleName(),\n        constructorRuleName = constructorNonTerminalNode.getRuleName();\n\n  if (ruleName === constructorRuleName) {\n    switch (ruleName) {\n      case ARGUMENT_RULE_NAME: {\n        const argumentNode = nonTerminalNode, ///\n              constructorArgumentNode = constructorNonTerminalNode, ///\n              argumentNodeVerified = verifyArgumentNode(argumentNode, constructorArgumentNode, context);\n\n        nonTerminalNodeVerified = argumentNodeVerified; ///\n\n        break;\n      }\n\n      default: {\n        const childNodes = nonTerminalNode.getChildNodes(),\n              constructorChildNodes = constructorNonTerminalNode.getChildNodes(),\n              childNodesVerified = verifyChildNodes(childNodes, constructorChildNodes, context);\n\n        nonTerminalNodeVerified = childNodesVerified; ///\n\n        break;\n      }\n    }\n  }\n\n  return nonTerminalNodeVerified;\n}\n\nfunction verifyArgumentNode(argumentNode, constructorArgumentNode, context) {\n  let argumentNodeVerified = false;\n\n  const termNode = termNodeQuery(argumentNode);\n\n  if (termNode === null) {\n    const argumentString = nodeAsString(argumentNode);\n\n    context.error(`The ${argumentString} argument should be a term, not a type`);\n  } else {\n    const types = [],\n          values = [],\n          termVerified = verifyTerm(termNode, types, values, context);\n\n    if (termVerified) {\n      const firstType = first(types),\n            termType = firstType, ///\n            typeNode = typeNodeQuery(constructorArgumentNode),\n            typeName = typeNameFromTypeNode(typeNode),\n            type = context.findTypeByTypeName(typeName),\n            termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);\n\n      if (termTypeEqualToOrSubTypeOfType) {\n        argumentNodeVerified = true;\n      }\n    }\n  }\n\n  return argumentNodeVerified;\n}\n"],"names":["verifyTerm","termNodeQuery","nodeQuery","typeNodeQuery","termNode","types","values","context","termVerified","begin","names","termVerifiedAsVariable","verifyTermAsVariable","constructors","getConstructors","constructor","find","termVerifiedAgainstConstructor","verifyTermAgainstConstructor","type","getType","value","push","complete","halt","constructorTermNode","getTermNode","node","constructorNode","nodeVerified","verifyNode","nodeTerminalNode","isTerminalNode","constructorNodeTerminalNode","terminalNode","constructorTerminalNode","terminalNodeVerified","verifyTerminalNode","nonTerminalNode","constructorNonTerminalNode","nonTerminalNodeVerified","verifyNonTerminalNode","verifyChildNodes","childNodes","constructorChildNodes","childNodesVerified","childNodesLength","length","constructorChildNodesLength","every","childNode","index","constructorChildNode","matches","match","ruleName","getRuleName","constructorRuleName","ARGUMENT_RULE_NAME","argumentNode","constructorArgumentNode","argumentNodeVerified","verifyArgumentNode","getChildNodes","argumentString","nodeAsString","error","firstType","first","termType","typeNode","typeName","typeNameFromTypeNode","findTypeByTypeName","termTypeEqualToOrSubTypeOfType","isEqualToOrSubTypeOf"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/verify/term.js"],"sourcesContent":["\"use strict\";\n\nimport { first } from \"../utilities/array\";\nimport { nodeAsString } from \"../utilities/string\";\nimport { ARGUMENT_RULE_NAME } from \"../ruleNames\";\nimport { nodeQuery, typeNameFromTypeNode, variableNameFromVariableNode } from \"../utilities/query\";\n\nconst termNodeQuery = nodeQuery(\"/argument/term!\"),\n      typeNodeQuery = nodeQuery(\"/argument/type!\"),\n      variableNodeQuery = nodeQuery(\"/term/variable!\");\n\nexport default function verifyTerm(termNode, types, values, context) {\n  let termVerified = false;\n\n  context.begin(termNode);\n\n  const termVerifiedAsVariable = verifyTermAsVariable(termNode, types, values, context);\n\n  if (termVerifiedAsVariable) {\n    termVerified = true;\n  } else {\n    const termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, values, context);\n\n    if (termVerifiedAgainstConstructors) {\n      termVerified = true;\n    }\n  }\n\n  termVerified ?\n    context.complete(termNode) :\n      context.halt(termNode);\n\n  return termVerified;\n}\n\nexport function verifyTermAsVariable(termNode, types, values, context) {\n  let termVerifiedAsVariable = false;\n\n  context.begin(termNode);\n\n  const variableNode = variableNodeQuery(termNode);\n\n  if (variableNode !== null) {\n    const variableName = variableNameFromVariableNode(variableNode),\n          variablePresent = context.isVariablePresentByVariableName(variableName);\n\n    if (!variablePresent) {\n      context.error(`The ${variableName} variable is not present.`)\n    } else {\n      const variable = context.findVariableByVariableName(variableName),\n        type = variable.getType(),\n        value = variable.getValue();\n\n      types.push(type);\n\n      values.push(value);\n\n      termVerifiedAsVariable = true;\n    }\n  }\n\n  termVerifiedAsVariable ?\n    context.complete(termNode) :\n      context.halt(termNode);\n\n  return termVerifiedAsVariable;\n}\n\nexport function verifyTermAgainstConstructors(termNode, types, values, context) {\n  let termVerifiedAgainstConstructors = false;\n\n  context.begin(termNode);\n\n  const constructors = context.getConstructors(),\n        constructor = constructors.find((constructor) => {\n          const termVerifiedAgainstConstructor = verifyTermAgainstConstructor(termNode, constructor, context);\n\n          if (termVerifiedAgainstConstructor) {\n            return true;\n          }\n        }) || null;\n\n  if (constructor !== null) {\n    const type = constructor.getType(),\n          value = termNode; ///\n\n    types.push(type);\n\n    values.push(value);\n\n    termVerifiedAgainstConstructors = true;\n  }\n\n  termVerifiedAgainstConstructors ?\n    context.complete(termNode) :\n      context.halt(termNode);\n\n  return termVerifiedAgainstConstructors;\n}\n\nfunction verifyTermAgainstConstructor(termNode, constructor, context) {\n  const constructorTermNode = constructor.getTermNode(),\n        node = termNode,  ///\n        constructorNode = constructorTermNode, ///\n        nodeVerified = verifyNode(node, constructorNode, context),\n        termVerifiedAgainstConstructor = nodeVerified;  ///\n\n  return termVerifiedAgainstConstructor;\n}\n\nfunction verifyNode(node, constructorNode, context) {\n  let nodeVerified;\n\n  const nodeTerminalNode = node.isTerminalNode(),\n        constructorNodeTerminalNode = constructorNode.isTerminalNode();\n\n  if (nodeTerminalNode === constructorNodeTerminalNode) {\n    if (nodeTerminalNode) {\n      const terminalNode = node,  ///\n            constructorTerminalNode = constructorNode,  ///\n            terminalNodeVerified = verifyTerminalNode(terminalNode, constructorTerminalNode, context);\n\n      nodeVerified = terminalNodeVerified;  ///\n    } else {\n      const nonTerminalNode = node, ///\n            constructorNonTerminalNode = constructorNode,  ///\n            nonTerminalNodeVerified = verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, context);\n\n      nodeVerified = nonTerminalNodeVerified; ///\n    }\n  }\n\n  return nodeVerified;\n}\n\nfunction verifyChildNodes(childNodes, constructorChildNodes, context) {\n  let childNodesVerified = false;\n\n  const childNodesLength = childNodes.length,\n        constructorChildNodesLength = constructorChildNodes.length;\n\n  if (childNodesLength === constructorChildNodesLength) {\n    childNodesVerified = childNodes.every((childNode, index) => {\n      const constructorChildNode = constructorChildNodes[index],\n            node = childNode, ///\n            constructorNode = constructorChildNode,  ///\n            nodeVerified = verifyNode(node, constructorNode, context);\n\n      if (nodeVerified) {\n        return true;\n      }\n    });\n  }\n\n  return childNodesVerified;\n}\n\nfunction verifyTerminalNode(terminalNode, constructorTerminalNode, context) {\n  let terminalNodeVerified = false;\n\n  const matches = terminalNode.match(constructorTerminalNode);\n\n  if (matches) {\n    terminalNodeVerified = true;\n  }\n\n  return terminalNodeVerified;\n}\n\nfunction verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, context) {\n  let nonTerminalNodeVerified = false;\n\n  const ruleName = nonTerminalNode.getRuleName(),\n        constructorRuleName = constructorNonTerminalNode.getRuleName();\n\n  if (ruleName === constructorRuleName) {\n    switch (ruleName) {\n      case ARGUMENT_RULE_NAME: {\n        const argumentNode = nonTerminalNode, ///\n              constructorArgumentNode = constructorNonTerminalNode, ///\n              argumentNodeVerified = verifyArgumentNode(argumentNode, constructorArgumentNode, context);\n\n        nonTerminalNodeVerified = argumentNodeVerified; ///\n\n        break;\n      }\n\n      default: {\n        const childNodes = nonTerminalNode.getChildNodes(),\n              constructorChildNodes = constructorNonTerminalNode.getChildNodes(),\n              childNodesVerified = verifyChildNodes(childNodes, constructorChildNodes, context);\n\n        nonTerminalNodeVerified = childNodesVerified; ///\n\n        break;\n      }\n    }\n  }\n\n  return nonTerminalNodeVerified;\n}\n\nfunction verifyArgumentNode(argumentNode, constructorArgumentNode, context) {\n  let argumentNodeVerified = false;\n\n  const termNode = termNodeQuery(argumentNode);\n\n  if (termNode === null) {\n    const argumentString = nodeAsString(argumentNode);\n\n    context.error(`The ${argumentString} argument should be a term, not a type`);\n  } else {\n    const types = [],\n          values = [],\n          termVerified = verifyTerm(termNode, types, values, context);\n\n    if (termVerified) {\n      const firstType = first(types),\n            termType = firstType, ///\n            typeNode = typeNodeQuery(constructorArgumentNode),\n            typeName = typeNameFromTypeNode(typeNode),\n            type = context.findTypeByTypeName(typeName),\n            termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);\n\n      if (termTypeEqualToOrSubTypeOfType) {\n        argumentNodeVerified = true;\n      }\n    }\n  }\n\n  return argumentNodeVerified;\n}\n"],"names":["verifyTerm","verifyTermAsVariable","verifyTermAgainstConstructors","termNodeQuery","nodeQuery","typeNodeQuery","variableNodeQuery","termNode","types","values","context","termVerified","begin","termVerifiedAsVariable","termVerifiedAgainstConstructors","complete","halt","variableNode","variableName","variableNameFromVariableNode","variablePresent","isVariablePresentByVariableName","error","variable","findVariableByVariableName","type","getType","value","getValue","push","constructors","getConstructors","constructor","find","termVerifiedAgainstConstructor","verifyTermAgainstConstructor","constructorTermNode","getTermNode","node","constructorNode","nodeVerified","verifyNode","nodeTerminalNode","isTerminalNode","constructorNodeTerminalNode","terminalNode","constructorTerminalNode","terminalNodeVerified","verifyTerminalNode","nonTerminalNode","constructorNonTerminalNode","nonTerminalNodeVerified","verifyNonTerminalNode","verifyChildNodes","childNodes","constructorChildNodes","childNodesVerified","childNodesLength","length","constructorChildNodesLength","every","childNode","index","constructorChildNode","matches","match","ruleName","getRuleName","constructorRuleName","ARGUMENT_RULE_NAME","argumentNode","constructorArgumentNode","argumentNodeVerified","verifyArgumentNode","getChildNodes","argumentString","nodeAsString","firstType","first","termType","typeNode","typeName","typeNameFromTypeNode","findTypeByTypeName","termTypeEqualToOrSubTypeOfType","isEqualToOrSubTypeOf"],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.449",
+  "version": "0.0.451",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",

package/src/constructor.js

@@ -61,15 +61,17 @@ export default class Constructor {
 
     let { type } = json;
 
-    const typeJSON = type;  ///
+    if (type !== null) {
+      const typeJSON = type;  ///
 
-    json = typeJSON;  ///
+      json = typeJSON;  ///
 
-    type = Type.fromJSON(json, releaseContext);
+      type = Type.fromJSON(json, releaseContext);
 
-    const typeName = type.getName();
+      const typeName = type.getName();
 
-    type = releaseContext.findTypeByTypeName(typeName); ///
+      type = releaseContext.findTypeByTypeName(typeName); ///
+    }
 
     const constructor = new Constructor(termNode, type);
 

package/src/context/file.js

@@ -6,7 +6,7 @@ import { push } from "../utilities/array";
 import { leastLineIndexFromNodeAndTokens, greatestLineIndexFromNodeAndTokens } from "../utilities/tokens";
 
 export default class FileContext {
-  constructor(releaseContext, filePath, tokens, node, types, rules, axioms, variables, combinators, constructors) {
+  constructor(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, variables, combinators, constructors) {
     this.releaseContext = releaseContext;
     this.filePath = filePath;
     this.tokens = tokens;
@@ -14,6 +14,7 @@ export default class FileContext {
     this.types = types;
     this.rules = rules;
     this.axioms = axioms;
+    this.lemmas = lemmas;
     this.variables = variables;
     this.combinators = combinators;
     this.constructors = constructors;
@@ -54,6 +55,12 @@ export default class FileContext {
       push(labels, axiomLabels);
     });
 
+    this.lemmas.forEach((lemma) => {
+      const lemmaLabels = lemma.getLabels();
+
+      push(labels, lemmaLabels);
+    });
+
     if (includeRelease) {
       const releaseContextLabels = this.releaseContext.getLabels();
 
@@ -105,6 +112,20 @@ export default class FileContext {
     return axioms;
   }
 
+  getLemmas(includeRelease = true) {
+    const lemmas = [];
+
+    push(lemmas, this.lemmas);
+
+    if (includeRelease) {
+      const releaseContextLemmas = this.releaseContext.getLemmas();
+
+      push(lemmas, releaseContextLemmas);
+    }
+
+    return lemmas;
+  }
+
   getCombinators(includeRelease = true) {
     const combinators = [];
 
@@ -200,6 +221,20 @@ export default class FileContext {
     return axiom;
   }
 
+  findLemmaByReferenceName(referenceName) {
+    const labelName = referenceName,  ///
+          lemmas = this.getLemmas(),
+          lemma = lemmas.find((lemma) => {
+            const lemmaMatchesLabelName = lemma.matchLabelName(labelName);
+
+            if (lemmaMatchesLabelName) {
+              return true;
+            }
+          }) || null;
+
+    return lemma;
+  }
+
   findVariableByVariableName(variableName) {
     const name = variableName,  ///
           variables = this.getVariables(),
@@ -247,6 +282,10 @@ export default class FileContext {
     this.axioms.push(axiom);
   }
 
+  addLemma(lemma) {
+    this.lemmas.push(lemma);
+  }
+
   addVariable(variable) {
     this.variables.push(variable);
   }
@@ -313,6 +352,12 @@ export default class FileContext {
       json.push(axiomJSON);
     });
 
+    this.lemmas.forEach((lemma) => {
+      const lemmaJSON = lemma.toJSON();
+
+      json.push(lemmaJSON);
+    });
+
     this.combinators.forEach((combinator) => {
       const combinatorJSON = combinator.toJSON();
 
@@ -339,10 +384,11 @@ export default class FileContext {
     const types = [],
           rules = [],
           axioms = [],
+          lemmas = [],
           variables = [],
           combinators = [],
           constructors = [],
-          fileContext = new FileContext(releaseContext, filePath, tokens, node, types, rules, axioms, variables, combinators, constructors);
+          fileContext = new FileContext(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, variables, combinators, constructors);
 
     return fileContext;
   }

package/src/context/release/directory.js

@@ -112,6 +112,30 @@ export default class DirectoryReleaseContext extends ReleaseContext {
     return axioms;
   }
 
+  getLemmas(includeDependencies = true) {
+    const lemmas = [];
+
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextLemmas = fileContext.getLemmas(includeRelease);
+
+      push(lemmas, fileContextLemmas);
+    });
+
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextLemmas = releaseContext.getLemmas(includeDependencies);
+
+        push(lemmas, releaseContextLemmas);
+      });
+    }
+
+    return lemmas;
+  }
+
   getCombinators(includeDependencies = true) {
     const combinators = [];
 

package/src/context/release/file.js

@@ -12,15 +12,16 @@ import Constructor from "../../constructor";
 
 import { push } from "../../utilities/array";
 import { customGrammarFromNameAndEntries } from "../../utilities/customGrammar";
-import { RULE_KIND, TYPE_KIND, AXIOM_KIND, COMBINATOR_KIND, CONSTRUCTOR_KIND } from "../../kinds";
+import { RULE_KIND, TYPE_KIND, AXIOM_KIND, LEMMA_KIND, COMBINATOR_KIND, CONSTRUCTOR_KIND } from "../../kinds";
 
 export default class FileReleaseContext extends ReleaseContext {
-  constructor(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts, contextJSON, types, rules, axioms, combinators, constructors) {
+  constructor(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts, contextJSON, types, rules, axioms, lemmas, combinators, constructors) {
     super(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts);
 
     this.types = types;
     this.rules = rules;
     this.axioms = axioms;
+    this.lemmas = lemmas;
     this.combinators = combinators;
     this.constructors = constructors;
     this.contextJSON = contextJSON;
@@ -116,6 +117,25 @@ export default class FileReleaseContext extends ReleaseContext {
     return axioms;
   }
 
+  getLemmas(includeDependencies = true) {
+    const lemmas = [];
+
+    push(lemmas, this.lemmas);
+
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextLemmas = releaseContext.getLemmas(includeDependencies);
+
+        push(lemmas, releaseContextLemmas);
+      });
+    }
+
+    return lemmas;
+  }
+
   getCombinators(includeDependencies = true) {
     const combinators = [];
 
@@ -201,6 +221,14 @@ export default class FileReleaseContext extends ReleaseContext {
           break;
         }
 
+        case LEMMA_KIND: {
+          const lemma = Lemma.fromJSON(json, releaseContext);
+
+          this.lemmas.push(lemma);
+
+          break;
+        }
+
         case COMBINATOR_KIND: {
           const combinator = Combinator.fromJSON(json, releaseContext);
 
@@ -229,9 +257,10 @@ export default class FileReleaseContext extends ReleaseContext {
           types = [],
           rules = [],
           axioms = [],
+          lemmas = [],
           combinators = [],
           constructors = [],
-          releaseContext = new FileReleaseContext(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts, contextJSON, types, rules, axioms, combinators, constructors);
+          releaseContext = new FileReleaseContext(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts, contextJSON, types, rules, axioms, lemmas, combinators, constructors);
 
     return releaseContext;
   }

package/src/kinds.js

@@ -3,5 +3,6 @@
 export const TYPE_KIND = "type";
 export const RULE_KIND = "rule";
 export const AXIOM_KIND = "axiom";
+export const LEMMA_KIND = "lemma";
 export const COMBINATOR_KIND = "combinator";
 export const CONSTRUCTOR_KIND = "constructor";

package/src/lemma.js

@@ -0,0 +1,130 @@
+"use strict";
+
+import Label from "./label";
+
+import { LEMMA_KIND } from "./kinds";
+import { nodeAsString } from "./utilities/string";
+
+import { statementNodeFromStatementJSON } from "./utilities/node";
+
+export default class Lemma {
+  constructor(labels, statementNode, suppositionStatementNodes, consequentStatementNode) {
+    this.labels = labels;
+    this.statementNode = statementNode;
+    this.suppositionStatementNodes = suppositionStatementNodes;
+    this.consequentStatementNode = consequentStatementNode;
+  }
+
+  getLabels() {
+    return this.labels;
+  }
+
+  getStatementNode() {
+    return this.statementNode;
+  }
+
+  getSuppositionStatementNodes() {
+    return this.suppositionStatementNodes;
+  }
+
+  getConsequentStatementNode() {
+    return this.consequentStatementNode;
+  }
+
+  matchLabelName(labelName) {
+    const matchesLabelName = this.labels.some((label) => {
+      const name = labelName, ///
+            labelMatchesName = label.matchName(name);
+
+      if (labelMatchesName) {
+        return true;
+      }
+    });
+
+    return matchesLabelName;
+  }
+
+  toJSON() {
+    const labelsJSON = this.labels.map((label) => {
+            const labelJSON = label.toJSON();
+
+            return labelJSON;
+          }),
+          statementString = nodeAsString(this.statementNode),
+          consequentStatementString = nodeAsString(this.consequentStatementNode),
+          suppositionStatementStrings = this.suppositionStatementNodes.map((suppositionStatementNode) => {
+            const suppositionStatementString = nodeAsString(suppositionStatementNode);
+
+            return suppositionStatementString;
+          }),
+          kind = LEMMA_KIND,
+          labels = labelsJSON,  ///
+          statement = statementString,  ///
+          consequent = consequentStatementString, ///
+          suppositions = suppositionStatementStrings, ///
+          json = {
+            kind,
+            labels,
+            statement,
+            consequent,
+            suppositions
+          };
+
+    return json;
+  }
+
+  static fromJSON(json, releaseContext) {
+    let { labels } = json;
+
+    const labelsJSON = labels;  ///
+
+    labels = labelsJSON.map((labelJSON) => {
+      const json = labelJSON, ///
+            label = Label.fromJSON(json, releaseContext);
+
+      return label;
+    });
+
+    const { statement, suppositions, consequent } = json;
+
+    let lemma;
+
+    if (statement !== null) {
+      const statementJSON = statement,  ///
+            statementNode = statementNodeFromStatementJSON(statementJSON, releaseContext),
+            suppositionStatementNodes = null,
+            consequentStatementNode = null;
+
+      lemma = new Lemma(labels, statementNode, suppositionStatementNodes, consequentStatementNode);
+    } else {
+      const statementNode = null,
+            suppositionStatementsJSON = suppositions,  ///
+            suppositionStatementNodes = suppositionStatementsJSON.map((suppositionStatementJSON) => {
+              const suppositionStatementNode = statementNodeFromStatementJSON(suppositionStatementJSON, releaseContext);
+
+              return suppositionStatementNode;
+            }),
+            consequentStatementJSON = consequent, ///
+            consequentStatementNode = statementNodeFromStatementJSON(consequentStatementJSON, releaseContext);
+
+      lemma = new Lemma(labels, statementNode, suppositionStatementNodes, consequentStatementNode);
+    }
+
+    return lemma;
+  }
+
+  static fromLabelsAndStatementNode(labels, statementNode) {
+    const suppositionStatementNodes = [],
+          consequentStatementNode = null,
+          lemma = new Lemma(labels, statementNode, suppositionStatementNodes, consequentStatementNode);
+
+    return lemma;
+  }
+
+  static fromLabelsSuppositionStatementNodesAndConsequentStatementNode(labels, suppositionStatementNodes, consequentStatementNode) {
+    const statementNode = null,
+          lemma = new Lemma(labels, statementNode, suppositionStatementNodes, consequentStatementNode);
+
+    return lemma;
+  }
+}

package/src/verify/assertion/type.js

@@ -1,10 +1,12 @@
 "use strict";
 
 import Variable from "../../variable";
-import verifyTermAsVariable from "../../verify/termAsVariable";
+import verifyTerm from "../../verify/term";
 
 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");
@@ -27,16 +29,15 @@ export default function verifyTypeAssertion(typeAssertionNode, proofContext) {
       debugger
     } else {
       const types = [],
-            names = [],
             values = [],
             context = proofContext, ///
             termNode = termNodeQuery(typeAssertionNode),
-            termVerifiedAsVariable = verifyTermAsVariable(termNode, types, names, values, context);
+            termString = nodeAsString(termNode),
+            termVerifiedAsVariable = verifyTermAsVariable(termNode, types, values, context);
 
       if (termVerifiedAsVariable) {
-        const firstName = first(names),
-              firstValue = first(values),
-              variableName = firstName, ///
+        const firstValue = first(values),
+              variableName = termString, ///
               value = firstValue; ///
 
         if (value !== undefined) {
@@ -45,16 +46,32 @@ export default function verifyTypeAssertion(typeAssertionNode, proofContext) {
           const type = proofContext.findTypeByTypeName(typeName),
                 firstType = first(types),
                 variableType = firstType, ///
-                typeSubTypeOfVariableType = type.isSubTypeOf(variableType);
+                typeEqualToOrSubTypeOfVariableType = type.isEqualToOrSubTypeOf(variableType);
 
-          if (!typeSubTypeOfVariableType) {
-            proofContext.error(`The asserted type of the ${variableName} variable is not a sub-type of its declared type.`);
+          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/declaration/topLevel.js

@@ -2,6 +2,7 @@
 
 import verifyRule from "../../verify/rule";
 import verifyAxiom from "../../verify/axiom";
+import verifyLemma from "../../verify/lemma";
 import verifyTypeDeclaration from "../../verify/declaration/type";
 import verifyVariableDeclaration from "../../verify/declaration/variable";
 import verifyCombinatorDeclaration from "../../verify/declaration/combinator";
@@ -11,6 +12,7 @@ import { nodeQuery } from "../../utilities/query";
 
 const ruleNodeQuery = nodeQuery("/topLevelDeclaration/rule!"),
       axiomNodeQuery = nodeQuery("/topLevelDeclaration/axiom!"),
+      lemmaNodeQuery = nodeQuery("/topLevelDeclaration/lemma!"),
       typeDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/typeDeclaration!"),
       variableDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/variableDeclaration!"),
       combinatorDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/combinatorDeclaration!"),
@@ -24,6 +26,7 @@ export default function verifyTopLevelDeclaration(topLevelDeclarationNode, fileC
   const node = topLevelDeclarationNode, ///
         ruleNode = ruleNodeQuery(node),
         axiomNode = axiomNodeQuery(node),
+        lemmaNode = lemmaNodeQuery(node),
         typeDeclarationNode = typeDeclarationNodeQuery(node),
         variableDeclarationNode = variableDeclarationNodeQuery(node),
         combinatorDeclarationNode = combinatorDeclarationNodeQuery(node),
@@ -39,6 +42,10 @@ export default function verifyTopLevelDeclaration(topLevelDeclarationNode, fileC
     const axiomVerified = verifyAxiom(axiomNode, fileContext);
 
     topLevelDeclarationVerified = axiomVerified;  ///
+  } else if (lemmaNode !== null) {
+    const lemmaVerified = verifyLemma(lemmaNode, fileContext);
+
+    topLevelDeclarationVerified = lemmaVerified;  ///
   } else if (typeDeclarationNode !== null) {
     const typeDeclarationVerified = verifyTypeDeclaration(typeDeclarationNode, fileContext);