occam-verify-cli 0.0.1002 → 0.0.1005

package/lib/verify/theorem.js

@@ -9,12 +9,9 @@ Object.defineProperty(exports, "default", {
     }
 });
 var _theorem = /*#__PURE__*/ _interop_require_default(require("../theorem"));
-var _proof = /*#__PURE__*/ _interop_require_default(require("../verify/proof"));
-var _labels = /*#__PURE__*/ _interop_require_default(require("../verify/labels"));
 var _local = /*#__PURE__*/ _interop_require_default(require("../context/local"));
 var _substitutions = /*#__PURE__*/ _interop_require_default(require("../substitutions"));
 var _consequent = /*#__PURE__*/ _interop_require_default(require("../verify/consequent"));
-var _suppositions = /*#__PURE__*/ _interop_require_default(require("../verify/suppositions"));
 var _array = require("../utilities/array");
 var _query = require("../utilities/query");
 function _interop_require_default(obj) {
@@ -27,13 +24,13 @@ function verifyTheorem(theoremNode, fileContext) {
     var theoremVerified = false;
     var labelNodes = labelNodesQuery(theoremNode), labelsString = fileContext.nodesAsString(labelNodes);
     fileContext.trace("Verifying the '".concat(labelsString, "' theorem..."), theoremNode);
-    var labels = [], labelsVerified = (0, _labels.default)(labelNodes, labels, fileContext);
+    var labels = [], labelsVerified = verifyLabels(labelNodes, labels, fileContext);
     if (labelsVerified) {
-        var localContext = _local.default.fromFileContext(fileContext), suppositions = [], suppositionNodes = suppositionsNodeQuery(theoremNode), suppositionsVerified = (0, _suppositions.default)(suppositionNodes, suppositions, localContext);
+        var localContext = _local.default.fromFileContext(fileContext), suppositions = [], suppositionNodes = suppositionsNodeQuery(theoremNode), suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
         if (suppositionsVerified) {
             var consequents = [], consequentNode = consequentNodeQuery(theoremNode), consequentVerified = (0, _consequent.default)(consequentNode, consequents, localContext);
             if (consequentVerified) {
-                var proofNode = proofNodeQuery(theoremNode), firstConsequent = (0, _array.first)(consequents), consequent = firstConsequent, statementNode = consequent.getStatementNode(), substitutions = _substitutions.default.fromNothing(), proofVerified = (0, _proof.default)(proofNode, statementNode, substitutions, localContext);
+                var proofNode = proofNodeQuery(theoremNode), firstConsequent = (0, _array.first)(consequents), consequent = firstConsequent, statementNode = consequent.getStatementNode(), substitutions = _substitutions.default.fromNothing(), proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);
                 if (proofVerified) {
                     var substitutions1 = _substitutions.default.fromNothing(), theorem = _theorem.default.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions1, fileContext);
                     fileContext.addTheorem(theorem);
@@ -48,4 +45,4 @@ function verifyTheorem(theoremNode, fileContext) {
     return theoremVerified;
 }
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy92ZXJpZnkvdGhlb3JlbS5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJcInVzZSBzdHJpY3RcIjtcblxuaW1wb3J0IFRoZW9yZW0gZnJvbSBcIi4uL3RoZW9yZW1cIjtcbmltcG9ydCB2ZXJpZnlQcm9vZiBmcm9tIFwiLi4vdmVyaWZ5L3Byb29mXCI7XG5pbXBvcnQgdmVyaWZ5TGFiZWxzIGZyb20gXCIuLi92ZXJpZnkvbGFiZWxzXCI7XG5pbXBvcnQgTG9jYWxDb250ZXh0IGZyb20gXCIuLi9jb250ZXh0L2xvY2FsXCI7XG5pbXBvcnQgU3Vic3RpdHV0aW9ucyBmcm9tIFwiLi4vc3Vic3RpdHV0aW9uc1wiO1xuaW1wb3J0IHZlcmlmeUNvbnNlcXVlbnQgZnJvbSBcIi4uL3ZlcmlmeS9jb25zZXF1ZW50XCI7XG5pbXBvcnQgdmVyaWZ5U3VwcG9zaXRpb25zIGZyb20gXCIuLi92ZXJpZnkvc3VwcG9zaXRpb25zXCI7XG5cbmltcG9ydCB7IGZpcnN0IH0gZnJvbSBcIi4uL3V0aWxpdGllcy9hcnJheVwiO1xuaW1wb3J0IHsgbm9kZVF1ZXJ5LCBub2Rlc1F1ZXJ5IH0gZnJvbSBcIi4uL3V0aWxpdGllcy9xdWVyeVwiO1xuXG5jb25zdCBwcm9vZk5vZGVRdWVyeSA9IG5vZGVRdWVyeShcIi90aGVvcmVtL3Byb29mIVwiKSxcbiAgICAgIGxhYmVsTm9kZXNRdWVyeSA9IG5vZGVzUXVlcnkoXCIvdGhlb3JlbS9sYWJlbFwiKSxcbiAgICAgIGNvbnNlcXVlbnROb2RlUXVlcnkgPSBub2RlUXVlcnkoXCIvdGhlb3JlbS9jb25zZXF1ZW50IVwiKSxcbiAgICAgIHN1cHBvc2l0aW9uc05vZGVRdWVyeSA9IG5vZGVzUXVlcnkoXCIvdGhlb3JlbS9zdXBwb3NpdGlvblwiKTtcblxuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24gdmVyaWZ5VGhlb3JlbSh0aGVvcmVtTm9kZSwgZmlsZUNvbnRleHQpIHtcbiAgbGV0IHRoZW9yZW1WZXJpZmllZCA9IGZhbHNlO1xuXG4gIGNvbnN0IGxhYmVsTm9kZXMgPSBsYWJlbE5vZGVzUXVlcnkodGhlb3JlbU5vZGUpLFxuICAgICAgICBsYWJlbHNTdHJpbmcgPSBmaWxlQ29udGV4dC5ub2Rlc0FzU3RyaW5nKGxhYmVsTm9kZXMpO1xuXG4gIGZpbGVDb250ZXh0LnRyYWNlKGBWZXJpZnlpbmcgdGhlICcke2xhYmVsc1N0cmluZ30nIHRoZW9yZW0uLi5gLCB0aGVvcmVtTm9kZSk7XG5cbiAgY29uc3QgbGFiZWxzID0gW10sXG4gICAgICAgIGxhYmVsc1ZlcmlmaWVkID0gdmVyaWZ5TGFiZWxzKGxhYmVsTm9kZXMsIGxhYmVscywgZmlsZUNvbnRleHQpO1xuXG4gIGlmIChsYWJlbHNWZXJpZmllZCkge1xuICAgIGNvbnN0IGxvY2FsQ29udGV4dCA9IExvY2FsQ29udGV4dC5mcm9tRmlsZUNvbnRleHQoZmlsZUNvbnRleHQpLFxuICAgICAgICAgIHN1cHBvc2l0aW9ucyA9IFtdLFxuICAgICAgICAgIHN1cHBvc2l0aW9uTm9kZXMgPSBzdXBwb3NpdGlvbnNOb2RlUXVlcnkodGhlb3JlbU5vZGUpLFxuICAgICAgICAgIHN1cHBvc2l0aW9uc1ZlcmlmaWVkID0gdmVyaWZ5U3VwcG9zaXRpb25zKHN1cHBvc2l0aW9uTm9kZXMsIHN1cHBvc2l0aW9ucywgbG9jYWxDb250ZXh0KTtcblxuICAgIGlmIChzdXBwb3NpdGlvbnNWZXJpZmllZCkge1xuICAgICAgY29uc3QgY29uc2VxdWVudHMgPSBbXSxcbiAgICAgICAgICAgIGNvbnNlcXVlbnROb2RlID0gY29uc2VxdWVudE5vZGVRdWVyeSh0aGVvcmVtTm9kZSksXG4gICAgICAgICAgICBjb25zZXF1ZW50VmVyaWZpZWQgPSB2ZXJpZnlDb25zZXF1ZW50KGNvbnNlcXVlbnROb2RlLCBjb25zZXF1ZW50cywgbG9jYWxDb250ZXh0KTtcblxuICAgICAgaWYgKGNvbnNlcXVlbnRWZXJpZmllZCkge1xuICAgICAgICBjb25zdCBwcm9vZk5vZGUgPSBwcm9vZk5vZGVRdWVyeSh0aGVvcmVtTm9kZSksXG4gICAgICAgICAgICAgIGZpcnN0Q29uc2VxdWVudCA9IGZpcnN0KGNvbnNlcXVlbnRzKSxcbiAgICAgICAgICAgICAgY29uc2VxdWVudCA9IGZpcnN0Q29uc2VxdWVudCwgLy8vXG4gICAgICAgICAgICAgIHN0YXRlbWVudE5vZGUgPSBjb25zZXF1ZW50LmdldFN0YXRlbWVudE5vZGUoKSxcbiAgICAgICAgICAgICAgc3Vic3RpdHV0aW9ucyA9IFN1YnN0aXR1dGlvbnMuZnJvbU5vdGhpbmcoKSxcbiAgICAgICAgICAgICAgcHJvb2ZWZXJpZmllZCA9IHZlcmlmeVByb29mKHByb29mTm9kZSwgc3RhdGVtZW50Tm9kZSwgc3Vic3RpdHV0aW9ucywgbG9jYWxDb250ZXh0KTtcblxuICAgICAgICBpZiAocHJvb2ZWZXJpZmllZCkge1xuICAgICAgICAgIGNvbnN0IHN1YnN0aXR1dGlvbnMgPSBTdWJzdGl0dXRpb25zLmZyb21Ob3RoaW5nKCksXG4gICAgICAgICAgICAgICAgdGhlb3JlbSA9IFRoZW9yZW0uZnJvbUxhYmVsc1N1cHBvc2l0aW9uc0NvbnNlcXVlbnRTdWJzdGl0dXRpb25zQW5kRmlsZUNvbnRleHQobGFiZWxzLCBzdXBwb3NpdGlvbnMsIGNvbnNlcXVlbnQsIHN1YnN0aXR1dGlvbnMsIGZpbGVDb250ZXh0KTtcblxuICAgICAgICAgIGZpbGVDb250ZXh0LmFkZFRoZW9yZW0odGhlb3JlbSk7XG5cbiAgICAgICAgICB0aGVvcmVtVmVyaWZpZWQgPSB0cnVlO1xuICAgICAgICB9XG4gICAgICB9XG4gICAgfVxuICB9XG5cbiAgaWYgKHRoZW9yZW1WZXJpZmllZCkge1xuICAgIGZpbGVDb250ZXh0LmRlYnVnKGAuLi52ZXJpZmllZCB0aGUgJyR7bGFiZWxzU3RyaW5nfScgdGhlb3JlbS5gLCB0aGVvcmVtTm9kZSk7XG4gIH1cblxuICByZXR1cm4gdGhlb3JlbVZlcmlmaWVkO1xufVxuIl0sIm5hbWVzIjpbInZlcmlmeVRoZW9yZW0iLCJwcm9vZk5vZGVRdWVyeSIsIm5vZGVRdWVyeSIsImxhYmVsTm9kZXNRdWVyeSIsIm5vZGVzUXVlcnkiLCJjb25zZXF1ZW50Tm9kZVF1ZXJ5Iiwic3VwcG9zaXRpb25zTm9kZVF1ZXJ5IiwidGhlb3JlbU5vZGUiLCJmaWxlQ29udGV4dCIsInRoZW9yZW1WZXJpZmllZCIsImxhYmVsTm9kZXMiLCJsYWJlbHNTdHJpbmciLCJub2Rlc0FzU3RyaW5nIiwidHJhY2UiLCJsYWJlbHMiLCJsYWJlbHNWZXJpZmllZCIsInZlcmlmeUxhYmVscyIsImxvY2FsQ29udGV4dCIsIkxvY2FsQ29udGV4dCIsImZyb21GaWxlQ29udGV4dCIsInN1cHBvc2l0aW9ucyIsInN1cHBvc2l0aW9uTm9kZXMiLCJzdXBwb3NpdGlvbnNWZXJpZmllZCIsInZlcmlmeVN1cHBvc2l0aW9ucyIsImNvbnNlcXVlbnRzIiwiY29uc2VxdWVudE5vZGUiLCJjb25zZXF1ZW50VmVyaWZpZWQiLCJ2ZXJpZnlDb25zZXF1ZW50IiwicHJvb2ZOb2RlIiwiZmlyc3RDb25zZXF1ZW50IiwiZmlyc3QiLCJjb25zZXF1ZW50Iiwic3RhdGVtZW50Tm9kZSIsImdldFN0YXRlbWVudE5vZGUiLCJzdWJzdGl0dXRpb25zIiwiU3Vic3RpdHV0aW9ucyIsImZyb21Ob3RoaW5nIiwicHJvb2ZWZXJpZmllZCIsInZlcmlmeVByb29mIiwidGhlb3JlbSIsIlRoZW9yZW0iLCJmcm9tTGFiZWxzU3VwcG9zaXRpb25zQ29uc2VxdWVudFN1YnN0aXR1dGlvbnNBbmRGaWxlQ29udGV4dCIsImFkZFRoZW9yZW0iLCJkZWJ1ZyJdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7K0JBa0JBOzs7ZUFBd0JBOzs7OERBaEJKOzREQUNJOzZEQUNDOzREQUNBO29FQUNDO2lFQUNHO21FQUNFO3FCQUVUO3FCQUNnQjs7Ozs7O0FBRXRDLElBQU1DLGlCQUFpQkMsSUFBQUEsZ0JBQVMsRUFBQyxvQkFDM0JDLGtCQUFrQkMsSUFBQUEsaUJBQVUsRUFBQyxtQkFDN0JDLHNCQUFzQkgsSUFBQUEsZ0JBQVMsRUFBQyx5QkFDaENJLHdCQUF3QkYsSUFBQUEsaUJBQVUsRUFBQztBQUUxQixTQUFTSixjQUFjTyxXQUFXLEVBQUVDLFdBQVc7SUFDNUQsSUFBSUMsa0JBQWtCO0lBRXRCLElBQU1DLGFBQWFQLGdCQUFnQkksY0FDN0JJLGVBQWVILFlBQVlJLGFBQWEsQ0FBQ0Y7SUFFL0NGLFlBQVlLLEtBQUssQ0FBQyxBQUFDLGtCQUE4QixPQUFiRixjQUFhLGlCQUFlSjtJQUVoRSxJQUFNTyxTQUFTLEVBQUUsRUFDWEMsaUJBQWlCQyxJQUFBQSxlQUFZLEVBQUNOLFlBQVlJLFFBQVFOO0lBRXhELElBQUlPLGdCQUFnQjtRQUNsQixJQUFNRSxlQUFlQyxjQUFZLENBQUNDLGVBQWUsQ0FBQ1gsY0FDNUNZLGVBQWUsRUFBRSxFQUNqQkMsbUJBQW1CZixzQkFBc0JDLGNBQ3pDZSx1QkFBdUJDLElBQUFBLHFCQUFrQixFQUFDRixrQkFBa0JELGNBQWNIO1FBRWhGLElBQUlLLHNCQUFzQjtZQUN4QixJQUFNRSxjQUFjLEVBQUUsRUFDaEJDLGlCQUFpQnBCLG9CQUFvQkUsY0FDckNtQixxQkFBcUJDLElBQUFBLG1CQUFnQixFQUFDRixnQkFBZ0JELGFBQWFQO1lBRXpFLElBQUlTLG9CQUFvQjtnQkFDdEIsSUFBTUUsWUFBWTNCLGVBQWVNLGNBQzNCc0Isa0JBQWtCQyxJQUFBQSxZQUFLLEVBQUNOLGNBQ3hCTyxhQUFhRixpQkFDYkcsZ0JBQWdCRCxXQUFXRSxnQkFBZ0IsSUFDM0NDLGdCQUFnQkMsc0JBQWEsQ0FBQ0MsV0FBVyxJQUN6Q0MsZ0JBQWdCQyxJQUFBQSxjQUFXLEVBQUNWLFdBQVdJLGVBQWVFLGVBQWVqQjtnQkFFM0UsSUFBSW9CLGVBQWU7b0JBQ2pCLElBQU1ILGlCQUFnQkMsc0JBQWEsQ0FBQ0MsV0FBVyxJQUN6Q0csVUFBVUMsZ0JBQU8sQ0FBQ0MsMkRBQTJELENBQUMzQixRQUFRTSxjQUFjVyxZQUFZRyxnQkFBZTFCO29CQUVySUEsWUFBWWtDLFVBQVUsQ0FBQ0g7b0JBRXZCOUIsa0JBQWtCO2dCQUNwQjtZQUNGO1FBQ0Y7SUFDRjtJQUVBLElBQUlBLGlCQUFpQjtRQUNuQkQsWUFBWW1DLEtBQUssQ0FBQyxBQUFDLG9CQUFnQyxPQUFiaEMsY0FBYSxlQUFhSjtJQUNsRTtJQUVBLE9BQU9FO0FBQ1QifQ==
+//# 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.1002",
+  "version": "0.0.1005",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",
@@ -12,9 +12,9 @@
   "dependencies": {
     "argumentative": "^2.0.32",
     "necessary": "^14.0.1",
-    "occam-custom-grammars": "^5.0.872",
-    "occam-entities": "^1.0.164",
-    "occam-file-system": "^6.0.203",
+    "occam-custom-grammars": "^5.0.873",
+    "occam-entities": "^1.0.165",
+    "occam-file-system": "^6.0.204",
     "occam-grammar-utilities": "^8.0.214",
     "occam-query": "^3.1.174"
   },

package/src/assertion/subproof.js

@@ -0,0 +1,84 @@
+"use strict";
+
+import Statement from "../statement";
+import LocalContext from "../context/local";
+import metaLevelUnifier from "../unifier/metaLevel";
+
+import { match } from "../utilities/array";
+import { nodeQuery, nodesQuery } from "../utilities/query";
+
+const statementNodesQuery = nodesQuery("/subproofAssertion/statement"),
+      subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion");
+
+export default class SubproofAssertion {
+  constructor(fileContext, string, statements) {
+    this.fileContext = fileContext;
+    this.string = string;
+    this.statements = statements;
+  }
+
+  getFileContext() {
+    return this.fileContext;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getStatements() {
+    return this.statements;
+  }
+
+  unifySubproof(subproof, substitutions, localContext) {
+    let subproofUnified;
+
+    const subproofString = subproof.getString(),
+          subproofStatements = subproof.getStatements(),
+          subproofAssertionString = this.string;  ///
+
+    localContext.trace(`Unifying the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion...`);
+
+    subproofUnified = match(this.statements, subproofStatements, (statement, subproofStatement) => {
+      const statementNode = statement.getNode(),
+            subproofStatementNode = subproofStatement.getNode(),
+            nodeA = statementNode,  ///
+            nodeB = subproofStatementNode,  ///
+            fileContextA = this.fileContext,  ///
+            localContextA = LocalContext.fromFileContext(fileContextA),
+            localContextB = localContext, ///
+            unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+
+      if (unified) {
+        return true;
+      }
+    });
+
+    if (subproofUnified) {
+      localContext.debug(`...unified the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion.`);
+    }
+
+    return subproofUnified;
+  }
+
+  static fromStatementNode(statementNode, fileContext) {
+    let subproofAssertion = null;
+
+    const subproofAssertionNode = subproofAssertionNodeQuery(statementNode);
+
+    if (subproofAssertionNode !== null) {
+      const node = subproofAssertionNode, ///
+            string = fileContext.nodeAsString(node),
+            localContext = LocalContext.fromFileContext(fileContext),
+            statementNodes = statementNodesQuery(subproofAssertionNode),
+            statements = statementNodes.map((statementNode) => {
+              const statement = Statement.fromStatementNode(statementNode, localContext);
+
+              return statement;
+            });
+
+      subproofAssertion = new SubproofAssertion(fileContext, string, statements);
+    }
+
+    return subproofAssertion;
+  }
+}

package/src/assignment/metavariable.js

@@ -16,8 +16,8 @@ export default class MetavariableAssignment {
           metavariableAssigned = metavariableAdded; ///
 
     metavariableAssigned ?
-      fileContext.trace(`Assigned the '${metavariableString}' metavariable.`, metavariableNode) :
-        fileContext.debug(`Unable to assign the '${metavariableString}' metavariable.`, metavariableNode);
+      fileContext.trace(`Assigned the '${metavariableString}' metavariable.`) :
+        fileContext.debug(`Unable to assign the '${metavariableString}' metavariable.`);
 
     return metavariableAssigned;
   }

package/src/combinator.js

@@ -1,32 +1,62 @@
 "use strict";
 
-import { nodeAsString } from "./utilities/string";
+import shim from "./shim";
+import LocalContext from "./context/local";
+
+import { nodeQuery } from "./utilities/query";
+
+const statementNodeQuery = nodeQuery("/combinatorDeclaration/statement");
 
 export default class Combinator {
-  constructor(statementNode, string) {
-    this.statementNode = statementNode;
-    this.string = string;
+  constructor(statement) {
+    this.statement = statement;
+  }
+
+  getStatement() {
+    return this.statement;
   }
 
+  getString() { return this.statement.getString(); }
+
   getStatementNode() {
-    return this.statementNode;
+    const statementNode = this.statement.getNode();
+
+    return statementNode;
+  }
+
+  verify(fileContext) {
+    const localContext = LocalContext.fromFileContext(fileContext),
+          statementVerifiedAsCombinator = this.statement.verifyAsCombinator(localContext),
+          verified = statementVerifiedAsCombinator; ///
+
+    return verified;
   }
 
-  getString() {
-    return this.string;
+  toJSON() {
+    const statementString = this.statement.getString(),
+          statement = statementString,  ///
+          json = {
+            statement
+          };
+
+    return json;
   }
 
-  static fromStatementNodeAndTokens(statementNode, tokens) {
-    const string = stringFromStatementNodeAndTokens(statementNode, tokens),
-          combinator = new Combinator(statementNode, string);
+  static fromJSON(json, fileContext) {
+    let combinator = null;
+
+    debugger
 
     return combinator;
   }
-}
 
-function stringFromStatementNodeAndTokens(statementNode, tokens) {
-  const statementString = nodeAsString(statementNode, tokens),
-        string = statementString; ///
+  static fromCombinatorDeclarationNode(combinatorDeclarationNode, fileContext) {
+    const { Statement } = shim,
+          statementNode = statementNodeQuery(combinatorDeclarationNode),
+          localContext = LocalContext.fromFileContext(fileContext),
+          statement = Statement.fromStatementNode(statementNode, localContext),
+          combinator = new Combinator(statement);
 
-  return string;
+    return combinator;
+  }
 }

package/src/conclusion.js

@@ -1,32 +1,102 @@
 "use strict";
 
 import metaLevelUnifier from "./unifier/metaLevel";
+import UnqualifiedStatement from "./statement/unqualified";
+
+import { nodeQuery } from "./utilities/query";
+import LocalContext from "./context/local";
+
+const unqualifiedStatementNodeQuery = nodeQuery("/conclusion/unqualifiedStatement");
 
 export default class Conclusion {
-  constructor(statementNode) {
-    this.statementNode = statementNode;
+  constructor(fileContext, unqualifiedStatement) {
+    this.fileContext = fileContext;
+    this.unqualifiedStatement = unqualifiedStatement;
+  }
+
+  getFileContext() {
+    return this.fileContext;
   }
 
-  getStatementNode() {
-    return this.statementNode;
+  getUnqualifiedStatement() {
+    return this.unqualifiedStatement;
   }
 
-  unifyStatement(statementNodeB, substitutions, localContextA, localContextB) {
-    let statementUnified = false;
+  getString() { return this.unqualifiedStatement.getString(); }
+
+  getStatement() { return this.unqualifiedStatement.getStatement(); }
+
+  unifyStatement(statement, substitutions, localContext) {
+    let statementUnified;
+
+    const conclusion = this, ///
+          statementString = statement.getString(),
+          conclusionStatement = conclusion.getStatement(),
+          conclusionStatementString = conclusionStatement.getString();
 
-    if (this.statementNode !== null) {
-      const nodeA = this.statementNode,  ///
-            nodeB = statementNodeB,  ///
-            unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+    localContext.trace(`Unifying the '${statementString}' statement with the conclusion's '${conclusionStatementString}' statement...`);
 
-      statementUnified = unified; ///
+    const statementNode = statement.getNode(),
+          conclusionStatementNode = conclusionStatement.getNode(),
+          nodeA = conclusionStatementNode,  ///
+          nodeB = statementNode,  ///
+          fileContextA = this.fileContext,  ///
+          localContextA = LocalContext.fromFileContext(fileContextA),
+          localContextB = localContext, ///
+          unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+
+    statementUnified = unified; ///
+
+    if (statementUnified) {
+      localContext.debug(`...unified the '${statementString}' statement with the conclusion's '${conclusionStatementString}' statement.`);
     }
 
     return statementUnified;
   }
 
-  static fromStatementNode(statementNode) {
-    const conclusion = new Conclusion(statementNode);
+  verify(localContext) {
+    let verified = false;
+
+    const conclusionString = this.getString();  ///
+
+    localContext.trace(`Verifying the '${conclusionString}' conclusion...`);
+
+    const stated = true,
+          assignments = [],
+          unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, localContext);
+
+    if (unqualifiedStatementVerified) {
+      verified = true;
+    }
+
+    if (verified) {
+      localContext.debug(`...verified the '${conclusionString}' conclusion.`);
+    }
+
+    return verified;
+  }
+
+  toJSON() {
+    const unqualifiedStatementString = this.unqualifiedStatement.getString(),
+          unqualifiedStatement = unqualifiedStatementString,  ///
+          json = {
+            unqualifiedStatement
+          };
+
+    return json;
+  }
+
+  static fromJSON(json, fileContext) {
+    let conclusion = null;
+
+    debugger
+
+    return conclusion;
+  }
+  static fromConclusionNode(conclusionNode, fileContext) {
+    const unqualifiedStatementNode = unqualifiedStatementNodeQuery(conclusionNode),
+          unqualifiedStatement = UnqualifiedStatement.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
+          conclusion = new Conclusion(fileContext, unqualifiedStatement);
 
     return conclusion;
   }