occam-verify-cli 0.0.453 → 0.0.455

package/lib/verify/termAsConstructor.js

@@ -103,7 +103,7 @@ function verifyNonTerminalNode(nonTerminalNode, fileContext) {
             }
         case _ruleNames.TERM_RULE_NAME:
             {
-                var termNode = nonTerminalNode, types = [], values = [], context = fileContext, termVerified = (0, _term.default)(termNode, types, values, context);
+                var termNode = nonTerminalNode, types = [], context = fileContext, termVerified = (0, _term.default)(termNode, types, context);
                 if (termVerified) {
                     var firstType = (0, _array.first)(types), type = firstType; ///
                     if (type !== null) {
@@ -125,4 +125,4 @@ function verifyNonTerminalNode(nonTerminalNode, fileContext) {
     return nonTerminalNodeVerified;
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/verify/termAsConstructor.js"],"sourcesContent":["\"use strict\";\n\nimport verifyTerm from \"../verify/term\";\nimport Constructor from \"../constructor\";\n\nimport { first } from \"../utilities/array\";\nimport { nodeAsString } from \"../utilities/string\";\nimport { nodeQuery, typeNameFromTypeNode } from \"../utilities/query\";\nimport { TERM_RULE_NAME, ARGUMENT_RULE_NAME } from \"../ruleNames\";\n\nconst typeNodeQuery = nodeQuery(\"/argument/type\");\n\nexport default function verifyTermAsConstructor(termNode, typeNode, fileContext) {\n  let termVerifiedAsConstructor = false;\n\n  fileContext.begin(termNode);\n\n  let type = null;\n\n  const nonTerminalNode = termNode,  ///\n        childNodes = nonTerminalNode.getChildNodes(),\n        childNodesVerified = verifyChildNodes(childNodes, fileContext);\n\n  if (childNodesVerified) {\n    if (typeNode === null) {\n      termVerifiedAsConstructor = true;\n    } else {\n      const typeName = typeNameFromTypeNode(typeNode);\n\n      type = fileContext.findTypeByTypeName(typeName);\n\n      if (type !== null) {\n        termVerifiedAsConstructor = true;\n      } else {\n        const termString = nodeAsString(termNode);\n\n        fileContext.error(`The '${termString}' constructor's '${typeName}' type is missing.`);\n      }\n    }\n  }\n\n  if (termVerifiedAsConstructor) {\n    const constructor = Constructor.fromTermNodeAndType(termNode, type);\n\n    fileContext.addConstructor(constructor);\n  }\n\n  if (termVerifiedAsConstructor) {\n    const termString = nodeAsString(termNode);\n\n    fileContext.info(`Verified the '${termString}' constructor.`);\n  }\n\n  termVerifiedAsConstructor ?\n    fileContext.complete(termNode) :\n      fileContext.halt(termNode);\n\n  return termVerifiedAsConstructor;\n}\n\nfunction verifyNode(node, fileContext) {\n  let nodeVerified;\n\n  const nodeTerminalNode = node.isTerminalNode();\n\n  if (nodeTerminalNode) {\n    const terminalNode = node,  ///\n          terminalNodeVerified = verifyTerminalNode(terminalNode, fileContext);\n\n    nodeVerified = terminalNodeVerified;  ///\n  } else {\n    const nonTerminalNode = node, ///\n          nonTerminalNodeVerified = verifyNonTerminalNode(nonTerminalNode, fileContext);\n\n    nodeVerified = nonTerminalNodeVerified; ///\n  }\n\n  return nodeVerified;\n}\n\nfunction verifyChildNodes(childNodes, fileContext) {\n  const childNodesVerified = childNodes.every((childNode) => {\n    const node = childNode, ///\n          nodeVerified = verifyNode(node, fileContext);\n\n    if (nodeVerified) {\n      return true;\n    }\n  });\n\n  return childNodesVerified;\n}\n\nfunction verifyTerminalNode(terminalNode, fileContext) {\n  const terminalNodeVerified = true;\n\n  return terminalNodeVerified;\n}\n\nfunction verifyArgumentNode(argumentNode, fileContext) {\n  let typeNodeVerified = false;\n\n  const typeNode = typeNodeQuery(argumentNode);\n\n  if (typeNode === null) {\n    const argumentString = nodeAsString(argumentNode);\n\n    fileContext.error(`The ${argumentString} argument should be a type.`);\n  } else {\n    const typeName = typeNameFromTypeNode(typeNode),\n          typePresent = fileContext.isTypePresentByTypeName(typeName);\n\n    if (!typePresent) {\n      fileContext.error(`The type '${typeName}' is missing.`);\n    } else {\n      typeNodeVerified = true;\n    }\n  }\n\n  return typeNodeVerified;\n}\n\nfunction verifyNonTerminalNode(nonTerminalNode, fileContext) {\n  let nonTerminalNodeVerified;\n\n  const ruleName = nonTerminalNode.getRuleName();\n\n  switch (ruleName) {\n    case ARGUMENT_RULE_NAME: {\n      const argumentNode = nonTerminalNode, ///\n            argumentNodeVerified = verifyArgumentNode(argumentNode, fileContext);\n\n      nonTerminalNodeVerified = argumentNodeVerified; ///\n\n      break;\n    }\n\n    case TERM_RULE_NAME: {\n      const termNode = nonTerminalNode, ///\n            types = [],\n            values = [],\n            context = fileContext,  ///\n            termVerified = verifyTerm(termNode, types, values, context);\n\n      if (termVerified) {\n        const firstType = first(types),\n              type = firstType; ///\n\n        if (type !== null) {\n          const termString = nodeAsString(termNode);\n\n          fileContext.error(`The type of the constructor's compound '${termString}' term node is not null.`);\n        } else {\n          nonTerminalNodeVerified = true; ///\n        }\n      }\n\n      break;\n    }\n\n    default: {\n      const childNodes = nonTerminalNode.getChildNodes(),\n            childNodesVerified = verifyChildNodes(childNodes, fileContext);\n\n      nonTerminalNodeVerified = childNodesVerified; ///\n\n      break;\n    }\n  }\n\n  return nonTerminalNodeVerified;\n}\n\n"],"names":["verifyTermAsConstructor","typeNodeQuery","nodeQuery","termNode","typeNode","fileContext","termVerifiedAsConstructor","begin","type","nonTerminalNode","childNodes","getChildNodes","childNodesVerified","verifyChildNodes","typeName","typeNameFromTypeNode","findTypeByTypeName","termString","nodeAsString","error","constructor","Constructor","fromTermNodeAndType","addConstructor","info","complete","halt","verifyNode","node","nodeVerified","nodeTerminalNode","isTerminalNode","terminalNode","terminalNodeVerified","verifyTerminalNode","nonTerminalNodeVerified","verifyNonTerminalNode","every","childNode","verifyArgumentNode","argumentNode","typeNodeVerified","argumentString","typePresent","isTypePresentByTypeName","ruleName","getRuleName","ARGUMENT_RULE_NAME","argumentNodeVerified","TERM_RULE_NAME","types","values","context","termVerified","verifyTerm","firstType","first"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/verify/termAsConstructor.js"],"sourcesContent":["\"use strict\";\n\nimport verifyTerm from \"../verify/term\";\nimport Constructor from \"../constructor\";\n\nimport { first } from \"../utilities/array\";\nimport { nodeAsString } from \"../utilities/string\";\nimport { nodeQuery, typeNameFromTypeNode } from \"../utilities/query\";\nimport { TERM_RULE_NAME, ARGUMENT_RULE_NAME } from \"../ruleNames\";\n\nconst typeNodeQuery = nodeQuery(\"/argument/type\");\n\nexport default function verifyTermAsConstructor(termNode, typeNode, fileContext) {\n  let termVerifiedAsConstructor = false;\n\n  fileContext.begin(termNode);\n\n  let type = null;\n\n  const nonTerminalNode = termNode,  ///\n        childNodes = nonTerminalNode.getChildNodes(),\n        childNodesVerified = verifyChildNodes(childNodes, fileContext);\n\n  if (childNodesVerified) {\n    if (typeNode === null) {\n      termVerifiedAsConstructor = true;\n    } else {\n      const typeName = typeNameFromTypeNode(typeNode);\n\n      type = fileContext.findTypeByTypeName(typeName);\n\n      if (type !== null) {\n        termVerifiedAsConstructor = true;\n      } else {\n        const termString = nodeAsString(termNode);\n\n        fileContext.error(`The '${termString}' constructor's '${typeName}' type is missing.`);\n      }\n    }\n  }\n\n  if (termVerifiedAsConstructor) {\n    const constructor = Constructor.fromTermNodeAndType(termNode, type);\n\n    fileContext.addConstructor(constructor);\n  }\n\n  if (termVerifiedAsConstructor) {\n    const termString = nodeAsString(termNode);\n\n    fileContext.info(`Verified the '${termString}' constructor.`);\n  }\n\n  termVerifiedAsConstructor ?\n    fileContext.complete(termNode) :\n      fileContext.halt(termNode);\n\n  return termVerifiedAsConstructor;\n}\n\nfunction verifyNode(node, fileContext) {\n  let nodeVerified;\n\n  const nodeTerminalNode = node.isTerminalNode();\n\n  if (nodeTerminalNode) {\n    const terminalNode = node,  ///\n          terminalNodeVerified = verifyTerminalNode(terminalNode, fileContext);\n\n    nodeVerified = terminalNodeVerified;  ///\n  } else {\n    const nonTerminalNode = node, ///\n          nonTerminalNodeVerified = verifyNonTerminalNode(nonTerminalNode, fileContext);\n\n    nodeVerified = nonTerminalNodeVerified; ///\n  }\n\n  return nodeVerified;\n}\n\nfunction verifyChildNodes(childNodes, fileContext) {\n  const childNodesVerified = childNodes.every((childNode) => {\n    const node = childNode, ///\n          nodeVerified = verifyNode(node, fileContext);\n\n    if (nodeVerified) {\n      return true;\n    }\n  });\n\n  return childNodesVerified;\n}\n\nfunction verifyTerminalNode(terminalNode, fileContext) {\n  const terminalNodeVerified = true;\n\n  return terminalNodeVerified;\n}\n\nfunction verifyArgumentNode(argumentNode, fileContext) {\n  let typeNodeVerified = false;\n\n  const typeNode = typeNodeQuery(argumentNode);\n\n  if (typeNode === null) {\n    const argumentString = nodeAsString(argumentNode);\n\n    fileContext.error(`The ${argumentString} argument should be a type.`);\n  } else {\n    const typeName = typeNameFromTypeNode(typeNode),\n          typePresent = fileContext.isTypePresentByTypeName(typeName);\n\n    if (!typePresent) {\n      fileContext.error(`The type '${typeName}' is missing.`);\n    } else {\n      typeNodeVerified = true;\n    }\n  }\n\n  return typeNodeVerified;\n}\n\nfunction verifyNonTerminalNode(nonTerminalNode, fileContext) {\n  let nonTerminalNodeVerified;\n\n  const ruleName = nonTerminalNode.getRuleName();\n\n  switch (ruleName) {\n    case ARGUMENT_RULE_NAME: {\n      const argumentNode = nonTerminalNode, ///\n            argumentNodeVerified = verifyArgumentNode(argumentNode, fileContext);\n\n      nonTerminalNodeVerified = argumentNodeVerified; ///\n\n      break;\n    }\n\n    case TERM_RULE_NAME: {\n      const termNode = nonTerminalNode, ///\n            types = [],\n            context = fileContext,  ///\n            termVerified = verifyTerm(termNode, types, context);\n\n      if (termVerified) {\n        const firstType = first(types),\n              type = firstType; ///\n\n        if (type !== null) {\n          const termString = nodeAsString(termNode);\n\n          fileContext.error(`The type of the constructor's compound '${termString}' term node is not null.`);\n        } else {\n          nonTerminalNodeVerified = true; ///\n        }\n      }\n\n      break;\n    }\n\n    default: {\n      const childNodes = nonTerminalNode.getChildNodes(),\n            childNodesVerified = verifyChildNodes(childNodes, fileContext);\n\n      nonTerminalNodeVerified = childNodesVerified; ///\n\n      break;\n    }\n  }\n\n  return nonTerminalNodeVerified;\n}\n\n"],"names":["verifyTermAsConstructor","typeNodeQuery","nodeQuery","termNode","typeNode","fileContext","termVerifiedAsConstructor","begin","type","nonTerminalNode","childNodes","getChildNodes","childNodesVerified","verifyChildNodes","typeName","typeNameFromTypeNode","findTypeByTypeName","termString","nodeAsString","error","constructor","Constructor","fromTermNodeAndType","addConstructor","info","complete","halt","verifyNode","node","nodeVerified","nodeTerminalNode","isTerminalNode","terminalNode","terminalNodeVerified","verifyTerminalNode","nonTerminalNodeVerified","verifyNonTerminalNode","every","childNode","verifyArgumentNode","argumentNode","typeNodeVerified","argumentString","typePresent","isTypePresentByTypeName","ruleName","getRuleName","ARGUMENT_RULE_NAME","argumentNodeVerified","TERM_RULE_NAME","types","context","termVerified","verifyTerm","firstType","first"],"mappings":"AAAA;;;;+BAYA;;;eAAwBA;;;yDAVD;gEACC;qBAEF;sBACO;qBACmB;yBACG;;;;;;AAEnD,IAAMC,gBAAgBC,IAAAA,gBAAS,EAAC;AAEjB,SAASF,wBAAwBG,QAAQ,EAAEC,QAAQ,EAAEC,WAAW,EAAE;IAC/E,IAAIC,4BAA4B,KAAK;IAErCD,YAAYE,KAAK,CAACJ;IAElB,IAAIK,OAAO,IAAI;IAEf,IAAMC,kBAAkBN,UAClBO,aAAaD,gBAAgBE,aAAa,IAC1CC,qBAAqBC,iBAAiBH,YAAYL;IAExD,IAAIO,oBAAoB;QACtB,IAAIR,aAAa,IAAI,EAAE;YACrBE,4BAA4B,IAAI;QAClC,OAAO;YACL,IAAMQ,WAAWC,IAAAA,2BAAoB,EAACX;YAEtCI,OAAOH,YAAYW,kBAAkB,CAACF;YAEtC,IAAIN,SAAS,IAAI,EAAE;gBACjBF,4BAA4B,IAAI;YAClC,OAAO;gBACL,IAAMW,aAAaC,IAAAA,oBAAY,EAACf;gBAEhCE,YAAYc,KAAK,CAAC,AAAC,QAAqCL,OAA9BG,YAAW,qBAA4B,OAATH,UAAS;YACnE,CAAC;QACH,CAAC;IACH,CAAC;IAED,IAAIR,2BAA2B;QAC7B,IAAMc,cAAcC,oBAAW,CAACC,mBAAmB,CAACnB,UAAUK;QAE9DH,YAAYkB,cAAc,CAACH;IAC7B,CAAC;IAED,IAAId,2BAA2B;QAC7B,IAAMW,cAAaC,IAAAA,oBAAY,EAACf;QAEhCE,YAAYmB,IAAI,CAAC,AAAC,iBAA2B,OAAXP,aAAW;IAC/C,CAAC;IAEDX,4BACED,YAAYoB,QAAQ,CAACtB,YACnBE,YAAYqB,IAAI,CAACvB,SAAS;IAE9B,OAAOG;AACT;AAEA,SAASqB,WAAWC,IAAI,EAAEvB,WAAW,EAAE;IACrC,IAAIwB;IAEJ,IAAMC,mBAAmBF,KAAKG,cAAc;IAE5C,IAAID,kBAAkB;QACpB,IAAME,eAAeJ,MACfK,uBAAuBC,mBAAmBF,cAAc3B;QAE9DwB,eAAeI,sBAAuB,GAAG;IAC3C,OAAO;QACL,IAAMxB,kBAAkBmB,MAClBO,0BAA0BC,sBAAsB3B,iBAAiBJ;QAEvEwB,eAAeM,yBAAyB,GAAG;IAC7C,CAAC;IAED,OAAON;AACT;AAEA,SAAShB,iBAAiBH,UAAU,EAAEL,WAAW,EAAE;IACjD,IAAMO,qBAAqBF,WAAW2B,KAAK,CAAC,SAACC,WAAc;QACzD,IAAMV,OAAOU,WACPT,eAAeF,WAAWC,MAAMvB;QAEtC,IAAIwB,cAAc;YAChB,OAAO,IAAI;QACb,CAAC;IACH;IAEA,OAAOjB;AACT;AAEA,SAASsB,mBAAmBF,YAAY,EAAE3B,WAAW,EAAE;IACrD,IAAM4B,uBAAuB,IAAI;IAEjC,OAAOA;AACT;AAEA,SAASM,mBAAmBC,YAAY,EAAEnC,WAAW,EAAE;IACrD,IAAIoC,mBAAmB,KAAK;IAE5B,IAAMrC,WAAWH,cAAcuC;IAE/B,IAAIpC,aAAa,IAAI,EAAE;QACrB,IAAMsC,iBAAiBxB,IAAAA,oBAAY,EAACsB;QAEpCnC,YAAYc,KAAK,CAAC,AAAC,OAAqB,OAAfuB,gBAAe;IAC1C,OAAO;QACL,IAAM5B,WAAWC,IAAAA,2BAAoB,EAACX,WAChCuC,cAActC,YAAYuC,uBAAuB,CAAC9B;QAExD,IAAI,CAAC6B,aAAa;YAChBtC,YAAYc,KAAK,CAAC,AAAC,aAAqB,OAATL,UAAS;QAC1C,OAAO;YACL2B,mBAAmB,IAAI;QACzB,CAAC;IACH,CAAC;IAED,OAAOA;AACT;AAEA,SAASL,sBAAsB3B,eAAe,EAAEJ,WAAW,EAAE;IAC3D,IAAI8B;IAEJ,IAAMU,WAAWpC,gBAAgBqC,WAAW;IAE5C,OAAQD;QACN,KAAKE,6BAAkB;YAAE;gBACvB,IAAMP,eAAe/B,iBACfuC,uBAAuBT,mBAAmBC,cAAcnC;gBAE9D8B,0BAA0Ba,sBAAsB,GAAG;gBAEnD,KAAM;YACR;QAEA,KAAKC,yBAAc;YAAE;gBACnB,IAAM9C,WAAWM,iBACXyC,QAAQ,EAAE,EACVC,UAAU9C,aACV+C,eAAeC,IAAAA,aAAU,EAAClD,UAAU+C,OAAOC;gBAEjD,IAAIC,cAAc;oBAChB,IAAME,YAAYC,IAAAA,YAAK,EAACL,QAClB1C,OAAO8C,WAAW,GAAG;oBAE3B,IAAI9C,SAAS,IAAI,EAAE;wBACjB,IAAMS,aAAaC,IAAAA,oBAAY,EAACf;wBAEhCE,YAAYc,KAAK,CAAC,AAAC,2CAAqD,OAAXF,YAAW;oBAC1E,OAAO;wBACLkB,0BAA0B,IAAI,EAAE,GAAG;oBACrC,CAAC;gBACH,CAAC;gBAED,KAAM;YACR;QAEA;YAAS;gBACP,IAAMzB,aAAaD,gBAAgBE,aAAa,IAC1CC,qBAAqBC,iBAAiBH,YAAYL;gBAExD8B,0BAA0BvB,oBAAoB,GAAG;gBAEjD,KAAM;YACR;IACF;IAEA,OAAOuB;AACT"}

package/lib/verify/theorem.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return verifyTheorem;
+    }
+});
+var _theorem = /*#__PURE__*/ _interopRequireDefault(require("../theorem"));
+var _labels = /*#__PURE__*/ _interopRequireDefault(require("../verify/labels"));
+var _proof = /*#__PURE__*/ _interopRequireDefault(require("../context/proof"));
+var _unqualified = /*#__PURE__*/ _interopRequireDefault(require("../verify/statement/unqualified"));
+var _indicativeConditional = /*#__PURE__*/ _interopRequireDefault(require("../verify/indicativeConditional"));
+var _array = require("../utilities/array");
+var _string = require("../utilities/string");
+var _query = require("../utilities/query");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var labelNodesQuery = (0, _query.nodesQuery)("/theorem/label"), statementNodeQuery = (0, _query.nodeQuery)("/unqualifiedStatement/statement!"), statementNodesQuery = (0, _query.nodesQuery)("/indicativeConditional/unqualifiedStatement/statement!"), unqualifiedStatementNodeQuery = (0, _query.nodeQuery)("/theorem/unqualifiedStatement!"), indicativeConditionalNodeQuery = (0, _query.nodeQuery)("/theorem/indicativeConditional!");
+function verifyTheorem(theoremNode, fileContext) {
+    var theoremVerified = false;
+    fileContext.begin(theoremNode);
+    var labelNodes = labelNodesQuery(theoremNode), labelsString = (0, _string.nodesAsString)(labelNodes), proofContext = _proof.default.fromFileContext(fileContext);
+    fileContext.debug("Verifying the '".concat(labelsString, "' theorem..."));
+    var labels = [], labelsVerified = (0, _labels.default)(labelNodes, labels, fileContext);
+    if (labelsVerified) {
+        var unqualifiedStatementNode = unqualifiedStatementNodeQuery(theoremNode), indicativeConditionalNode = indicativeConditionalNodeQuery(theoremNode);
+        if (unqualifiedStatementNode !== null) {
+            var unqualifiedStatementVerified = (0, _unqualified.default)(unqualifiedStatementNode, proofContext);
+            if (unqualifiedStatementVerified) {
+                var statementNode = statementNodeQuery(unqualifiedStatementNode), theorem = _theorem.default.fromLabelsAndStatementNode(labels, statementNode);
+                fileContext.addTheorem(theorem);
+                theoremVerified = true;
+            }
+        }
+        if (indicativeConditionalNode !== null) {
+            var indicativeConditionalVerified = (0, _indicativeConditional.default)(indicativeConditionalNode, proofContext);
+            if (indicativeConditionalVerified !== null) {
+                var statementNodes = statementNodesQuery(indicativeConditionalNode), lastStatementNode = (0, _array.last)(statementNodes), frontStatementNodes = (0, _array.front)(statementNodes), consequentStatementNode = lastStatementNode, suppositionStatementNodes = frontStatementNodes, theorem1 = _theorem.default.fromLabelsSuppositionStatementNodesAndConsequentStatementNode(labels, suppositionStatementNodes, consequentStatementNode);
+                fileContext.addTheorem(theorem1);
+                theoremVerified = true;
+            }
+        }
+    }
+    if (theoremVerified) {
+        fileContext.info("Verified the '".concat(labelsString, "' theorem."));
+    }
+    theoremVerified ? fileContext.complete(theoremNode) : fileContext.halt(theoremNode);
+    return theoremVerified;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.453",
+  "version": "0.0.455",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",
@@ -12,9 +12,9 @@
   "dependencies": {
     "argumentative": "^2.0.21",
     "necessary": "^11.2.1",
-    "occam-custom-grammars": "^5.0.368",
+    "occam-custom-grammars": "^5.0.370",
     "occam-dom": "^3.0.171",
-    "occam-file-system": "^5.0.127",
+    "occam-file-system": "^5.0.129",
     "occam-grammar-utilities": "^7.0.66"
   },
   "devDependencies": {

package/src/assertion.js

@@ -49,6 +49,13 @@ export default class Assertion {
     return assertion;
   }
 
+  static fromStatementNode(statementNode) {
+    const subproofNode = null,
+          assertion = new Assertion(subproofNode, statementNode);
+
+    return assertion;
+  }
+
   static fromQualifiedStatementNode(qualifiedStatementNode) {
     const subproofNode = null,
           statementNode = statementNodeQuery(qualifiedStatementNode),
@@ -95,7 +102,7 @@ function matchAssertionChildNodes(assertionChildNodes, childNodes) {
   let assertionChildNodesMatches = false;
 
   const childNodesLength = childNodes.length,
-      assertionChildNodesLength = assertionChildNodes.length;
+        assertionChildNodesLength = assertionChildNodes.length;
 
   if (childNodesLength === assertionChildNodesLength) {
     assertionChildNodesMatches = childNodes.every((childNode, index) => {

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, lemmas, variables, combinators, constructors) {
+  constructor(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, theorems, variables, combinators, constructors) {
     this.releaseContext = releaseContext;
     this.filePath = filePath;
     this.tokens = tokens;
@@ -15,6 +15,7 @@ export default class FileContext {
     this.rules = rules;
     this.axioms = axioms;
     this.lemmas = lemmas;
+    this.theorems = theorems;
     this.variables = variables;
     this.combinators = combinators;
     this.constructors = constructors;
@@ -61,6 +62,12 @@ export default class FileContext {
       push(labels, lemmaLabels);
     });
 
+    this.theorems.forEach((theorem) => {
+      const theoremLabels = theorem.getLabels();
+
+      push(labels, theoremLabels);
+    });
+
     if (includeRelease) {
       const releaseContextLabels = this.releaseContext.getLabels();
 
@@ -126,6 +133,20 @@ export default class FileContext {
     return lemmas;
   }
 
+  getTheorems(includeRelease = true) {
+    const theorems = [];
+
+    push(theorems, this.theorems);
+
+    if (includeRelease) {
+      const releaseContextTheorems = this.releaseContext.getTheorems();
+
+      push(theorems, releaseContextTheorems);
+    }
+
+    return theorems;
+  }
+
   getCombinators(includeRelease = true) {
     const combinators = [];
 
@@ -235,6 +256,20 @@ export default class FileContext {
     return lemma;
   }
 
+  findTheoremByReferenceName(referenceName) {
+    const labelName = referenceName,  ///
+          theorems = this.getTheorems(),
+          theorem = theorems.find((theorem) => {
+            const theoremMatchesLabelName = theorem.matchLabelName(labelName);
+
+            if (theoremMatchesLabelName) {
+              return true;
+            }
+          }) || null;
+
+    return theorem;
+  }
+
   findVariableByVariableName(variableName) {
     const name = variableName,  ///
           variables = this.getVariables(),
@@ -286,6 +321,10 @@ export default class FileContext {
     this.lemmas.push(lemma);
   }
 
+  addTheorem(theorem) {
+    this.theorems.push(theorem);
+  }
+
   addVariable(variable) {
     this.variables.push(variable);
   }
@@ -352,10 +391,10 @@ export default class FileContext {
       json.push(axiomJSON);
     });
 
-    this.lemmas.forEach((lemma) => {
-      const lemmaJSON = lemma.toJSON();
+    this.theorems.forEach((theorem) => {
+      const theoremJSON = theorem.toJSON();
 
-      json.push(lemmaJSON);
+      json.push(theoremJSON);
     });
 
     this.combinators.forEach((combinator) => {
@@ -385,10 +424,11 @@ export default class FileContext {
           rules = [],
           axioms = [],
           lemmas = [],
+          theorems = [],
           variables = [],
           combinators = [],
           constructors = [],
-          fileContext = new FileContext(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, variables, combinators, constructors);
+          fileContext = new FileContext(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, theorems, variables, combinators, constructors);
 
     return fileContext;
   }

package/src/context/proof.js

@@ -37,6 +37,10 @@ class ProofContext {
 
   getAxioms() { return this.context.getAxioms(); }
 
+  getLemmas() { return this.context.getLemmas(); }
+
+  getTheorems() { return this.context.getTheorems(); }
+
   getCombinators() { return this.context.getCombinators(); }
 
   getConstructors() { return this.context.getConstructors(); }
@@ -54,10 +58,6 @@ class ProofContext {
   }
 
   setDerived(derived) {
-    if (derived) {
-      this.statementNodes.pop();
-    }
-
     this.derived = derived;
   }
 
@@ -119,6 +119,10 @@ class ProofContext {
 
   findAxiomByReferenceName(referenceName) { return this.context.findAxiomByReferenceName(referenceName); }
 
+  findLemmaByReferenceName(referenceName) { return this.context.findLemmaByReferenceName(referenceName); }
+
+  findTheoremByReferenceName(referenceName) { return this.context.findTheoremByReferenceName(referenceName); }
+
   isLabelPresentByLabelName(labelName) { return this.context.isLabelPresentByLabelName(labelName); }
 
   isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }

package/src/context/release/directory.js

@@ -112,7 +112,7 @@ export default class DirectoryReleaseContext extends ReleaseContext {
     return axioms;
   }
 
-  getLemmas(includeDependencies = true) {
+  getLemmas() {
     const lemmas = [];
 
     this.fileContexts.forEach((fileContext) => {
@@ -122,18 +122,31 @@ export default class DirectoryReleaseContext extends ReleaseContext {
       push(lemmas, fileContextLemmas);
     });
 
+    return lemmas;
+  }
+
+  getTheorems(includeDependencies = true) {
+    const theorems = [];
+
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextTheorems = fileContext.getTheorems(includeRelease);
+
+      push(theorems, fileContextTheorems);
+    });
+
     if (includeDependencies) {
       const dependencyReleaseContexts = this.getDependencyReleaseContexts();
 
       dependencyReleaseContexts.forEach((releaseContext) => {
         const includeDependencies = false,
-              releaseContextLemmas = releaseContext.getLemmas(includeDependencies);
+              releaseContextTheorems = releaseContext.getTheorems(includeDependencies);
 
-        push(lemmas, releaseContextLemmas);
+        push(theorems, releaseContextTheorems);
       });
     }
 
-    return lemmas;
+    return theorems;
   }
 
   getCombinators(includeDependencies = true) {

package/src/context/release/file.js

@@ -7,21 +7,23 @@ import { rewriteNodes } from "occam-grammar-utilities";
 import Rule from "../../rule";
 import Type from "../../type";
 import Axiom from "../../axiom";
+import Theorem from "../../theorem";
 import Combinator from "../../combinator";
 import Constructor from "../../constructor";
 
 import { push } from "../../utilities/array";
 import { customGrammarFromNameAndEntries } from "../../utilities/customGrammar";
-import { RULE_KIND, TYPE_KIND, AXIOM_KIND, LEMMA_KIND, COMBINATOR_KIND, CONSTRUCTOR_KIND } from "../../kinds";
+import { RULE_KIND, TYPE_KIND, AXIOM_KIND, THEOREM_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, lemmas, combinators, constructors) {
+  constructor(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts, contextJSON, types, rules, axioms, lemmas, theorems, 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.theorems = theorems;
     this.combinators = combinators;
     this.constructors = constructors;
     this.contextJSON = contextJSON;
@@ -46,6 +48,12 @@ export default class FileReleaseContext extends ReleaseContext {
       push(labels, axiomLabels);
     });
 
+    this.theorems.forEach((theorem) => {
+      const theoremLabels = theorem.getLabels();
+
+      push(labels, theoremLabels);
+    });
+
     if (includeDependencies) {
       const dependencyReleaseContexts = this.getDependencyReleaseContexts();
 
@@ -117,23 +125,31 @@ export default class FileReleaseContext extends ReleaseContext {
     return axioms;
   }
 
-  getLemmas(includeDependencies = true) {
-    const lemmas = [];
+  getLemmas() {
+    const theorems = [];
+
+    push(theorems, this.theorems);
+
+    return theorems;
+  }
+
+  getTheorems(includeDependencies = true) {
+    const theorems = [];
 
-    push(lemmas, this.lemmas);
+    push(theorems, this.theorems);
 
     if (includeDependencies) {
       const dependencyReleaseContexts = this.getDependencyReleaseContexts();
 
       dependencyReleaseContexts.forEach((releaseContext) => {
         const includeDependencies = false,
-              releaseContextLemmas = releaseContext.getLemmas(includeDependencies);
+              releaseContextTheorems = releaseContext.getTheorems(includeDependencies);
 
-        push(lemmas, releaseContextLemmas);
+        push(theorems, releaseContextTheorems);
       });
     }
 
-    return lemmas;
+    return theorems;
   }
 
   getCombinators(includeDependencies = true) {
@@ -221,10 +237,10 @@ export default class FileReleaseContext extends ReleaseContext {
           break;
         }
 
-        case LEMMA_KIND: {
-          const lemma = Lemma.fromJSON(json, releaseContext);
+        case THEOREM_KIND: {
+          const theorem = Theorem.fromJSON(json, releaseContext);
 
-          this.lemmas.push(lemma);
+          this.theorems.push(theorem);
 
           break;
         }
@@ -258,9 +274,10 @@ export default class FileReleaseContext extends ReleaseContext {
           rules = [],
           axioms = [],
           lemmas = [],
+          theorems = [],
           combinators = [],
           constructors = [],
-          releaseContext = new FileReleaseContext(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts, contextJSON, types, rules, axioms, lemmas, combinators, constructors);
+          releaseContext = new FileReleaseContext(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts, contextJSON, types, rules, axioms, lemmas, theorems, combinators, constructors);
 
     return releaseContext;
   }

package/src/kinds.js

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

package/src/theorem.js

@@ -0,0 +1,130 @@
+"use strict";
+
+import Label from "./label";
+
+import { THEOREM_KIND } from "./kinds";
+import { nodeAsString } from "./utilities/string";
+
+import { statementNodeFromStatementJSON } from "./utilities/node";
+
+export default class Theorem {
+  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 = THEOREM_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 theorem;
+
+    if (statement !== null) {
+      const statementJSON = statement,  ///
+            statementNode = statementNodeFromStatementJSON(statementJSON, releaseContext),
+            suppositionStatementNodes = null,
+            consequentStatementNode = null;
+
+      theorem = new Theorem(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);
+
+      theorem = new Theorem(labels, statementNode, suppositionStatementNodes, consequentStatementNode);
+    }
+
+    return theorem;
+  }
+
+  static fromLabelsAndStatementNode(labels, statementNode) {
+    const suppositionStatementNodes = [],
+          consequentStatementNode = null,
+          theorem = new Theorem(labels, statementNode, suppositionStatementNodes, consequentStatementNode);
+
+    return theorem;
+  }
+
+  static fromLabelsSuppositionStatementNodesAndConsequentStatementNode(labels, suppositionStatementNodes, consequentStatementNode) {
+    const statementNode = null,
+          theorem = new Theorem(labels, statementNode, suppositionStatementNodes, consequentStatementNode);
+
+    return theorem;
+  }
+}

package/src/variable.js

@@ -19,6 +19,12 @@ export default class Variable {
     return this.value;
   }
 
+  isDefined() {
+    const defined = (this.value !== undefined);
+
+    return defined;
+  }
+
   setValue(value) {
     this.value = value;
   }