occam-verify-cli 1.0.448 → 1.0.472

package/lib/element/proofAssertion/supposition.js

@@ -0,0 +1,333 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _proofAssertion = /*#__PURE__*/ _interop_require_default(require("../proofAssertion"));
+var _assign = /*#__PURE__*/ _interop_require_default(require("../../process/assign"));
+var _elements = require("../../elements");
+var _context = require("../../utilities/context");
+var _json = require("../../utilities/json");
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+var _Supposition;
+var _default = (0, _elements.define)((_Supposition = /*#__PURE__*/ function(ProofAssertion) {
+    _inherits(Supposition, ProofAssertion);
+    function Supposition(context, string, node, statement, procedureCall) {
+        _class_call_check(this, Supposition);
+        var _this;
+        _this = _call_super(this, Supposition, [
+            context,
+            string,
+            node,
+            statement
+        ]);
+        _this.procedureCall = procedureCall;
+        return _this;
+    }
+    _create_class(Supposition, [
+        {
+            key: "getProcedureCall",
+            value: function getProcedureCall() {
+                return this.procedureCall;
+            }
+        },
+        {
+            key: "isStated",
+            value: function isStated() {
+                var stated = true; ///
+                return stated;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(context) {
+                var _this = this;
+                var verifies = false;
+                var node = this.getNode(), suppositionString = this.getString(); ///
+                context.trace("Verifying the '".concat(suppositionString, "' supposition..."), node);
+                var statement = this.getStatement(), procedureCall = this.getProcedureCall();
+                if (statement !== null || procedureCall !== null) {
+                    (0, _context.attempt)(function(context) {
+                        if (statement !== null) {
+                            var assignments = [], statementValidates = _this.validateStatement(assignments, context);
+                            if (statementValidates) {
+                                var assignmentsAssigned = (0, _assign.default)(assignments, context);
+                                if (assignmentsAssigned) {
+                                    var subproofOrProofAssertion = _this; ///
+                                    context.addSubproofOrProofAssertion(subproofOrProofAssertion);
+                                    _this.setContext(context);
+                                    verifies = true;
+                                }
+                            }
+                        }
+                        if (procedureCall !== null) {
+                            var procedureCallValidates = procedureCall.validate(context);
+                            if (procedureCallValidates) {
+                                _this.setContext(context);
+                                verifies = true;
+                            }
+                        }
+                    }, context);
+                } else {
+                    context.debug("Unable to verify the '".concat(suppositionString, "' supposition because it is nonsense."), node);
+                }
+                if (verifies) {
+                    context.debug("...verified the '".concat(suppositionString, "' supposition."), node);
+                }
+                return verifies;
+            }
+        },
+        {
+            key: "unifyIndependently",
+            value: function unifyIndependently(substitutions, context) {
+                var unifiesIndependently = false;
+                var suppositionString = this.getString(); ///
+                context.trace("Unifying the '".concat(suppositionString, "' supposition independently..."));
+                var specificContext = context; ///
+                context = this.getContext();
+                var generalContext = context; ///
+                context = specificContext; ///
+                var statement = this.getStatement();
+                if (statement !== null) {
+                    var statementUnifiesIndependently = statement.unifyIndependently(substitutions, generalContext, specificContext);
+                    if (statementUnifiesIndependently) {
+                        unifiesIndependently = true;
+                    }
+                }
+                if (this.procedureCall !== null) {
+                    var procedureCallResolvedIndependently = this.procedureCall.unifyIndependently(substitutions, context);
+                    if (procedureCallResolvedIndependently) {
+                        unifiesIndependently = true;
+                    }
+                }
+                if (unifiesIndependently) {
+                    context.debug("...unified the '".concat(suppositionString, "' supposition independenly."));
+                }
+                return unifiesIndependently;
+            }
+        },
+        {
+            key: "unifySubproofOrProosAssertion",
+            value: function unifySubproofOrProosAssertion(subproofOrProofAssertion, substitutions, context) {
+                var subproofOrProofAssertionUnifies = false;
+                var subproofOrProofAssertionProofAssertion = subproofOrProofAssertion.isProofAssertion(), subproof = subproofOrProofAssertionProofAssertion ? null : subproofOrProofAssertion, proofAssertion = subproofOrProofAssertionProofAssertion ? subproofOrProofAssertion : null;
+                substitutions.snapshot(context);
+                if (subproof !== null) {
+                    var subproofUnifies = this.unifySubproof(subproof, substitutions, context);
+                    if (subproofUnifies) {
+                        subproofOrProofAssertionUnifies = true;
+                    }
+                }
+                if (proofAssertion !== null) {
+                    var proofAssertionUnifies = this.unifyProofAssertion(proofAssertion, substitutions, context);
+                    if (proofAssertionUnifies) {
+                        subproofOrProofAssertionUnifies = true;
+                    }
+                }
+                if (subproofOrProofAssertionUnifies) {
+                    substitutions.resolve(context);
+                }
+                subproofOrProofAssertionUnifies ? substitutions.continue(context) : substitutions.rollback(context);
+                return subproofOrProofAssertionUnifies;
+            }
+        },
+        {
+            key: "unifyProofAssertion",
+            value: function unifyProofAssertion(proofAssertion, substitutions, context) {
+                var _this = this;
+                var proofAssertionUnifies = false;
+                var suppositionString = this.getString(), proofAssertionString = proofAssertion.getString();
+                context.trace("Unifying the '".concat(proofAssertionString, "' proof assertion with the '").concat(suppositionString, "' supposition..."));
+                var specificContext = context; ///
+                context = this.getContext();
+                var generalContext = context; ///
+                context = specificContext; ///
+                var proofAssertionContext = proofAssertion.getContext(), statementUnifies = (0, _context.synthetically)(function(specificContext) {
+                    var statement = proofAssertion.getStatement(), statementUnifies = _this.unifyStatement(statement, substitutions, generalContext, specificContext);
+                    return statementUnifies;
+                }, specificContext, proofAssertionContext);
+                if (statementUnifies) {
+                    proofAssertionUnifies = true;
+                }
+                if (proofAssertionUnifies) {
+                    context.debug("...unified the '".concat(proofAssertionString, "' proof assertion with the '").concat(suppositionString, "' supposition."));
+                }
+                return proofAssertionUnifies;
+            }
+        },
+        {
+            key: "unifySubproof",
+            value: function unifySubproof(subproof, substitutions, context) {
+                var subproofUnifies = false;
+                var node = this.getNode(), subproofString = subproof.getString(), suppositionString = this.getString(); ///
+                context.trace("Unifying the '".concat(subproofString, "' subproof with the '").concat(suppositionString, "' supposition..."), node);
+                var specificContext = context; ///
+                context = this.getContext();
+                var generalContext = context; ///
+                context = specificContext; ///
+                var statement = this.getStatement();
+                if (statement !== null) {
+                    var statementNode = statement.getNode(), subproofAssertionNode = statementNode.getSubproofAssertionNode();
+                    if (subproofAssertionNode !== null) {
+                        var _$context = generalContext, assertionNode = subproofAssertionNode, assertion = _$context.findAssertionByAssertionNode(assertionNode);
+                        if (assertion !== null) {
+                            var subproofAssertion = assertion; ///
+                            subproofUnifies = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);
+                        }
+                    }
+                }
+                if (subproofUnifies) {
+                    context.debug("...unified the '".concat(subproofString, "' subproof with the '").concat(suppositionString, "' supposition."), node);
+                }
+                return subproofUnifies;
+            }
+        },
+        {
+            key: "unifySupposition",
+            value: function unifySupposition(supposition, substitutions, generalContext, specificContext) {
+                var suppositionUnifies;
+                var node = this.getNode(), context = specificContext, specificSupposition = supposition, generalSuppositionString = this.getString(), specificSuppositionString = specificSupposition.getString();
+                context.trace("Unifying the '".concat(specificSuppositionString, "' supposition with the '").concat(generalSuppositionString, "' supposition..."), node);
+                var statement = specificSupposition.getStatement(), statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+                suppositionUnifies = statementUnifies; ///
+                if (suppositionUnifies) {
+                    context.debug("...unified the '".concat(specificSuppositionString, "' supposition with the '").concat(generalSuppositionString, "' supposition."), node);
+                }
+                return suppositionUnifies;
+            }
+        },
+        {
+            key: "toJSON",
+            value: function toJSON() {
+                var frames, terms;
+                frames = this.context.getFrames();
+                terms = this.context.getTerms();
+                var procedureCallJSON = (0, _json.procedureCallToProcedureCallJSON)(this.procedureCall), statementJSON = (0, _json.statementToStatementJSON)(this.statement), framesJSON = (0, _json.framesToFramesJSON)(frames), termsJSON = (0, _json.termsToTermsJSON)(terms);
+                frames = framesJSON; ///
+                terms = termsJSON; ///
+                var procedureCall = procedureCallJSON, statement = statementJSON, json = {
+                    procedureCall: procedureCall,
+                    statement: statement,
+                    frames: frames,
+                    terms: terms
+                };
+                return json;
+            }
+        }
+    ], [
+        {
+            key: "fromJSON",
+            value: function fromJSON(json, context) {
+                var terms = (0, _json.termsFromJSON)(json, context), frames = (0, _json.framesFromJSON)(json, context), statement = (0, _json.statementFromJSON)(json, context), procedureCall = (0, _json.procedureCallFromJSON)(json, context);
+                var string;
+                if (statement !== null) {
+                    string = statement.getString();
+                }
+                if (procedureCall !== null) {
+                    string = procedureCall.getString();
+                }
+                var node = null;
+                var supposition = new Supposition(context, string, node, statement, procedureCall);
+                return supposition;
+            }
+        }
+    ]);
+    return Supposition;
+}(_proofAssertion.default), _define_property(_Supposition, "name", "Supposition"), _Supposition));
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/element/proofAssertion/supposition.js"],"sourcesContent":["\"use strict\";\n\nimport ProofAssertion from \"../proofAssertion\";\nimport assignAssignments from \"../../process/assign\";\n\nimport { define } from \"../../elements\";\nimport { attempt, synthetically } from \"../../utilities/context\";\nimport { termsFromJSON,\n         framesFromJSON,\n         termsToTermsJSON,\n         statementFromJSON,\n         framesToFramesJSON,\n         procedureCallFromJSON,\n         statementToStatementJSON,\n         procedureCallToProcedureCallJSON } from \"../../utilities/json\";\n\nexport default define(class Supposition extends ProofAssertion {\n  constructor(context, string, node, statement, procedureCall) {\n    super(context, string, node, statement);\n\n    this.procedureCall = procedureCall;\n  }\n\n  getProcedureCall() {\n    return this.procedureCall;\n  }\n\n  isStated() {\n    const stated = true; ///\n\n    return stated;\n  }\n\n  verify(context) {\n    let verifies = false;\n\n    const node = this.getNode(),\n          suppositionString = this.getString(); ///\n\n    context.trace(`Verifying the '${suppositionString}' supposition...`, node);\n\n    const statement = this.getStatement(),\n          procedureCall = this.getProcedureCall();\n\n    if ((statement !== null) || (procedureCall !== null)) {\n      attempt((context) => {\n        if (statement !== null) {\n          const assignments = [],\n                statementValidates = this.validateStatement(assignments, context);\n\n          if (statementValidates) {\n            const assignmentsAssigned = assignAssignments(assignments, context);\n\n            if (assignmentsAssigned) {\n              const subproofOrProofAssertion = this;  ///\n\n              context.addSubproofOrProofAssertion(subproofOrProofAssertion);\n\n              this.setContext(context);\n\n              verifies = true;\n            }\n          }\n        }\n\n        if (procedureCall !== null) {\n          const procedureCallValidates = procedureCall.validate(context);\n\n          if (procedureCallValidates) {\n            this.setContext(context);\n\n            verifies = true;\n          }\n        }\n      }, context);\n    } else {\n      context.debug(`Unable to verify the '${suppositionString}' supposition because it is nonsense.`, node);\n    }\n\n    if (verifies) {\n      context.debug(`...verified the '${suppositionString}' supposition.`, node);\n    }\n\n    return verifies;\n  }\n\n  unifyIndependently(substitutions, context) {\n    let unifiesIndependently = false;\n\n    const suppositionString = this.getString(); ///\n\n    context.trace(`Unifying the '${suppositionString}' supposition independently...`);\n\n    const specificContext = context;  ///\n\n    context = this.getContext();\n\n    const generalContext = context; ///\n\n    context = specificContext;  ///\n\n    const statement = this.getStatement();\n\n    if (statement !== null) {\n      const statementUnifiesIndependently = statement.unifyIndependently(substitutions, generalContext, specificContext);\n\n      if (statementUnifiesIndependently) {\n        unifiesIndependently = true;\n      }\n    }\n\n    if (this.procedureCall !== null) {\n      const procedureCallResolvedIndependently = this.procedureCall.unifyIndependently(substitutions, context);\n\n      if (procedureCallResolvedIndependently) {\n        unifiesIndependently = true;\n      }\n    }\n\n    if (unifiesIndependently) {\n      context.debug(`...unified the '${suppositionString}' supposition independenly.`);\n    }\n\n    return unifiesIndependently;\n  }\n\n  unifySubproofOrProosAssertion(subproofOrProofAssertion, substitutions, context) {\n    let subproofOrProofAssertionUnifies = false;\n\n    const subproofOrProofAssertionProofAssertion = subproofOrProofAssertion.isProofAssertion(),\n          subproof = subproofOrProofAssertionProofAssertion ?\n                        null :\n                          subproofOrProofAssertion,\n          proofAssertion = subproofOrProofAssertionProofAssertion ?\n                             subproofOrProofAssertion :\n                               null;\n\n    substitutions.snapshot(context);\n\n    if (subproof !== null) {\n      const subproofUnifies = this.unifySubproof(subproof, substitutions, context);\n\n      if (subproofUnifies) {\n        subproofOrProofAssertionUnifies = true;\n      }\n    }\n\n    if (proofAssertion !== null) {\n      const proofAssertionUnifies = this.unifyProofAssertion(proofAssertion, substitutions, context);\n\n      if (proofAssertionUnifies) {\n        subproofOrProofAssertionUnifies = true;\n      }\n    }\n\n    if (subproofOrProofAssertionUnifies) {\n      substitutions.resolve(context);\n    }\n\n    subproofOrProofAssertionUnifies ?\n      substitutions.continue(context) :\n        substitutions.rollback(context);\n\n    return subproofOrProofAssertionUnifies;\n  }\n\n  unifyProofAssertion(proofAssertion, substitutions, context) {\n    let proofAssertionUnifies = false;\n\n    const suppositionString = this.getString(), ///\n          proofAssertionString = proofAssertion.getString();\n\n    context.trace(`Unifying the '${proofAssertionString}' proof assertion with the '${suppositionString}' supposition...`);\n\n    const specificContext = context;  ///\n\n    context = this.getContext();\n\n    const generalContext = context; ///\n\n    context = specificContext;  ///\n\n    const proofAssertionContext = proofAssertion.getContext(),\n          statementUnifies = synthetically((specificContext) => {\n            const statement = proofAssertion.getStatement(),\n                  statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);\n\n            return statementUnifies;\n          }, specificContext, proofAssertionContext);\n\n    if (statementUnifies) {\n      proofAssertionUnifies = true;\n    }\n\n    if (proofAssertionUnifies) {\n      context.debug(`...unified the '${proofAssertionString}' proof assertion with the '${suppositionString}' supposition.`);\n    }\n\n    return proofAssertionUnifies;\n  }\n\n  unifySubproof(subproof, substitutions, context) {\n    let subproofUnifies = false;\n\n    const node = this.getNode(),\n          subproofString = subproof.getString(),\n          suppositionString = this.getString(); ///\n\n    context.trace(`Unifying the '${subproofString}' subproof with the '${suppositionString}' supposition...`, node);\n\n    const specificContext = context;  ///\n\n    context = this.getContext();\n\n    const generalContext = context; ///\n\n    context = specificContext;  ///\n\n    const statement = this.getStatement();\n\n    if (statement !== null) {\n      const statementNode = statement.getNode(),\n            subproofAssertionNode = statementNode.getSubproofAssertionNode();\n\n      if (subproofAssertionNode !== null) {\n        const context = generalContext, ///\n              assertionNode = subproofAssertionNode,  ///\n              assertion = context.findAssertionByAssertionNode(assertionNode)\n\n        if (assertion !== null) {\n          const subproofAssertion = assertion;  ///\n\n          subproofUnifies = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);\n        }\n      }\n    }\n\n    if (subproofUnifies) {\n      context.debug(`...unified the '${subproofString}' subproof with the '${suppositionString}' supposition.`, node);\n    }\n\n    return subproofUnifies;\n  }\n\n  unifySupposition(supposition, substitutions, generalContext, specificContext) {\n    let suppositionUnifies;\n\n    const node = this.getNode(),\n          context = specificContext,  ///\n          specificSupposition = supposition,  ///\n          generalSuppositionString = this.getString(), ///\n          specificSuppositionString = specificSupposition.getString();\n\n    context.trace(`Unifying the '${specificSuppositionString}' supposition with the '${generalSuppositionString}' supposition...`, node);\n\n    const statement = specificSupposition.getStatement(),\n          statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);\n\n    suppositionUnifies = statementUnifies;  ///\n\n    if (suppositionUnifies) {\n      context.debug(`...unified the '${specificSuppositionString}' supposition with the '${generalSuppositionString}' supposition.`, node);\n    }\n\n    return suppositionUnifies;\n  }\n\n  toJSON() {\n    let frames,\n        terms;\n\n    frames = this.context.getFrames();\n\n    terms = this.context.getTerms();\n\n    const procedureCallJSON = procedureCallToProcedureCallJSON(this.procedureCall),\n          statementJSON = statementToStatementJSON(this.statement),\n          framesJSON = framesToFramesJSON(frames),\n          termsJSON = termsToTermsJSON(terms);\n\n    frames = framesJSON;  ///\n\n    terms = termsJSON;  ///\n\n    const procedureCall = procedureCallJSON,  ///\n          statement = statementJSON,  ///\n          json = {\n            procedureCall,\n            statement,\n            frames,\n            terms\n          };\n\n    return json;\n  }\n\n  static name = \"Supposition\";\n\n  static fromJSON(json, context) {\n    const terms = termsFromJSON(json, context),\n          frames = framesFromJSON(json, context),\n          statement = statementFromJSON(json, context),\n          procedureCall = procedureCallFromJSON(json, context);\n\n    let string;\n\n    if (statement !== null) {\n      string = statement.getString();\n    }\n\n    if (procedureCall !== null) {\n      string = procedureCall.getString();\n    }\n\n    const node = null;\n\n    const supposition = new Supposition(context, string, node, statement, procedureCall);\n\n    return supposition;\n  }\n});\n"],"names":["define","Supposition","context","string","node","statement","procedureCall","getProcedureCall","isStated","stated","verify","verifies","getNode","suppositionString","getString","trace","getStatement","attempt","assignments","statementValidates","validateStatement","assignmentsAssigned","assignAssignments","subproofOrProofAssertion","addSubproofOrProofAssertion","setContext","procedureCallValidates","validate","debug","unifyIndependently","substitutions","unifiesIndependently","specificContext","getContext","generalContext","statementUnifiesIndependently","procedureCallResolvedIndependently","unifySubproofOrProosAssertion","subproofOrProofAssertionUnifies","subproofOrProofAssertionProofAssertion","isProofAssertion","subproof","proofAssertion","snapshot","subproofUnifies","unifySubproof","proofAssertionUnifies","unifyProofAssertion","resolve","continue","rollback","proofAssertionString","proofAssertionContext","statementUnifies","synthetically","unifyStatement","subproofString","statementNode","subproofAssertionNode","getSubproofAssertionNode","assertionNode","assertion","findAssertionByAssertionNode","subproofAssertion","unifySupposition","supposition","suppositionUnifies","specificSupposition","generalSuppositionString","specificSuppositionString","toJSON","frames","terms","getFrames","getTerms","procedureCallJSON","procedureCallToProcedureCallJSON","statementJSON","statementToStatementJSON","framesJSON","framesToFramesJSON","termsJSON","termsToTermsJSON","json","fromJSON","termsFromJSON","framesFromJSON","statementFromJSON","procedureCallFromJSON","ProofAssertion","name"],"mappings":"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"}

package/lib/element/proofAssertion.js

@@ -165,7 +165,7 @@ var ProofAssertion = /*#__PURE__*/ function(Element) {
             key: "compareStatement",
             value: function compareStatement(statement, context) {
                 var comparesToStatement = false;
-                var statementString = statement.getString(), proofAssertionString = this.getString();
+                var statementString = statement.getString(), proofAssertionString = this.getString(); ///
                 context.trace("Comparing the '".concat(statementString, "' statement to the '").concat(proofAssertionString, "' proof assertion..."));
                 var leftStatement = statement, rightStatement = this.statement, leftStatementNode = leftStatement.getNode(), rightStatementNode = rightStatement.getNode(), statementsEquate = (0, _equate.equateStatements)(leftStatementNode, rightStatementNode, context);
                 if (statementsEquate) {
@@ -177,20 +177,30 @@ var ProofAssertion = /*#__PURE__*/ function(Element) {
                 return comparesToStatement;
             }
         },
+        {
+            key: "validateStatement",
+            value: function validateStatement(assignments, context) {
+                var statementValidates;
+                var statementString = this.statement.getString(), proofAssertionString = this.getString(); ///
+                context.trace("Validating the '".concat(proofAssertionString, "' proof assertion's '").concat(statementString, "' statement... "));
+                var stated = this.isStated();
+                statementValidates = this.statement.validate(assignments, stated, context);
+                if (statementValidates) {
+                    context.debug("...validated the '".concat(proofAssertionString, "' proof assertion's '").concat(statementString, "' reference. "));
+                }
+                return statementValidates;
+            }
+        },
         {
             key: "unifyStatement",
-            value: function unifyStatement(statement, substitutions, context) {
+            value: function unifyStatement(statement, substitutions, generalContext, specificContext) {
                 var statementUnifies = false;
                 if (this.statement !== null) {
-                    var node = this.getNode(), premiseString = this.getString(), statementString = statement.getString();
-                    context.trace("Unifying the '".concat(statementString, "' statement with the '").concat(premiseString, "' premise..."), node);
-                    var specificContext = context; ///
-                    context = this.getContext(); ///
-                    var generalContext = context; ///
-                    context = specificContext; ///
+                    var context = specificContext, statementString = statement.getString(), proorAssertionString = this.getString(); ///
+                    context.trace("Unifying the '".concat(statementString, "' statement with the '").concat(proorAssertionString, "' proof assertion..."));
                     statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
                     if (statementUnifies) {
-                        context.debug("...unified the '".concat(statementString, "' statement with the '").concat(premiseString, "' premise."), node);
+                        context.debug("...unified the '".concat(statementString, "' statement with the '").concat(proorAssertionString, "' proof assertion."));
                     }
                 }
                 return statementUnifies;
@@ -200,4 +210,4 @@ var ProofAssertion = /*#__PURE__*/ function(Element) {
     return ProofAssertion;
 }(_wrap_native_super(_element.default));
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/element/propertyRelation.js

@@ -179,7 +179,7 @@ var _default = (0, _elements.define)((_PropertyRelation = /*#__PURE__*/ function
             key: "verify",
             value: function verify(context) {
                 var verifies = false;
-                var propertyRelationString = this.string; ///
+                var propertyRelationString = this.getString(); ///
                 context.trace("Verifying the '".concat(propertyRelationString, "' property relation..."));
                 var termValidates = this.validateTerm(context);
                 if (termValidates) {
@@ -236,4 +236,4 @@ var _default = (0, _elements.define)((_PropertyRelation = /*#__PURE__*/ function
     return PropertyRelation;
 }(_wrap_native_super(_element.default)), _define_property(_PropertyRelation, "name", "PropertyRelation"), _PropertyRelation));
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9lbGVtZW50L3Byb3BlcnR5UmVsYXRpb24uanMiXSwic291cmNlc0NvbnRlbnQiOlsiXCJ1c2Ugc3RyaWN0XCI7XG5cbmltcG9ydCBFbGVtZW50IGZyb20gXCIuLi9lbGVtZW50XCI7XG5cbmltcG9ydCB7IGRlZmluZSB9IGZyb20gXCIuLi9lbGVtZW50c1wiO1xuXG5leHBvcnQgZGVmYXVsdCBkZWZpbmUoY2xhc3MgUHJvcGVydHlSZWxhdGlvbiBleHRlbmRzIEVsZW1lbnQge1xuICBjb25zdHJ1Y3Rvcihjb250ZXh0LCBzdHJpbmcsIG5vZGUsIHByb3BlcnR5LCB0ZXJtKSB7XG4gICAgc3VwZXIoY29udGV4dCwgc3RyaW5nLCBub2RlKTtcblxuICAgIHRoaXMucHJvcGVydHkgPSBwcm9wZXJ0eTtcbiAgICB0aGlzLnRlcm0gPSB0ZXJtO1xuICB9XG5cbiAgZ2V0UHJvcGVydHkoKSB7XG4gICAgcmV0dXJuIHRoaXMucHJvcGVydHk7XG4gIH1cblxuICBnZXRUZXJtKCkge1xuICAgIHJldHVybiB0aGlzLnRlcm07XG4gIH1cblxuICB2ZXJpZnkoY29udGV4dCkge1xuICAgIGxldCB2ZXJpZmllcyA9IGZhbHNlO1xuXG4gICAgY29uc3QgcHJvcGVydHlSZWxhdGlvblN0cmluZyA9IHRoaXMuc3RyaW5nOyAvLy9cblxuICAgIGNvbnRleHQudHJhY2UoYFZlcmlmeWluZyB0aGUgJyR7cHJvcGVydHlSZWxhdGlvblN0cmluZ30nIHByb3BlcnR5IHJlbGF0aW9uLi4uYCk7XG5cbiAgICBjb25zdCB0ZXJtVmFsaWRhdGVzID0gdGhpcy52YWxpZGF0ZVRlcm0oY29udGV4dCk7XG5cbiAgICBpZiAodGVybVZhbGlkYXRlcykge1xuICAgICAgY29uc3QgcHJvcGVydHlWZXJpZmllcyA9IHRoaXMudmVyaWZ5UHJvcGVydHkoY29udGV4dCk7XG5cbiAgICAgIHZlcmlmaWVzID0gcHJvcGVydHlWZXJpZmllcztcbiAgICB9XG5cbiAgICBpZiAodmVyaWZpZXMpIHtcbiAgICAgIGNvbnRleHQuZGVidWcoYC4uLnZlcmlmaWVkIHRoZSAnJHtwcm9wZXJ0eVJlbGF0aW9uU3RyaW5nfScgcHJvcGVydHkgcmVsYXRpb24uYCk7XG4gICAgfVxuXG4gICAgcmV0dXJuIHZlcmlmaWVzO1xuICB9XG5cbiAgdmFsaWRhdGVUZXJtKGNvbnRleHQpIHtcbiAgICBsZXQgdGVybVZhbGlkYXRlcztcblxuICAgIGNvbnN0IHRlcm1TdHJpbmcgPSB0aGlzLnRlcm0uZ2V0U3RyaW5nKCk7XG5cbiAgICBjb250ZXh0LnRyYWNlKGBWYWxpZGF0aW5nIHRoZSAnJHt0ZXJtU3RyaW5nfScgdGVybS4uLmApO1xuXG4gICAgdGVybVZhbGlkYXRlcyA9IHRoaXMudGVybS52YWxpZGF0ZShjb250ZXh0LCAoKSA9PiB7XG4gICAgICBjb25zdCB2ZXJpZmllc0FoZWFkID0gdHJ1ZTtcblxuICAgICAgcmV0dXJuIHZlcmlmaWVzQWhlYWQ7XG4gICAgfSk7XG5cbiAgICBpZiAodGVybVZhbGlkYXRlcykge1xuICAgICAgY29udGV4dC5kZWJ1ZyhgLi4udmFsaWRhdGVkIHRoZSAnJHt0ZXJtU3RyaW5nfScgdGVybS5gKTtcbiAgICB9XG5cbiAgICByZXR1cm4gdGVybVZhbGlkYXRlcztcbiAgfVxuXG4gIHZlcmlmeVByb3BlcnR5KGNvbnRleHQpIHtcbiAgICBsZXQgcHJvcGVydHlWZXJpZmllcztcblxuICAgIGNvbnN0IHByb3BlcnR5U3RyaW5nID0gdGhpcy5wcm9wZXJ0eS5nZXRTdHJpbmcoKTtcblxuICAgIGNvbnRleHQudHJhY2UoYFZlcmlmeWluZyB0aGUgJyR7cHJvcGVydHlTdHJpbmd9JyBwcm9wZXJ0eS4uLmApO1xuXG4gICAgY29uc3QgdGVybVR5cGUgPSB0aGlzLnRlcm0uZ2V0VHlwZSgpLFxuICAgICAgICAgIHByb3BlcnR5TmFtZSA9IHRoaXMucHJvcGVydHkuZ2V0TmFtZSgpLFxuICAgICAgICAgIHRlcm1UeXBlUHJvcGVydGllcyA9IHRlcm1UeXBlLmdldFByb3BlcnRpZXMoKSxcbiAgICAgICAgICB2YXJpYWJsZVR5cGVQcm9wZXJ0eSA9IHRlcm1UeXBlUHJvcGVydGllcy5maW5kKCh0ZXJtVHlwZVByb3BlcnR5KSA9PiB7XG4gICAgICAgICAgICBjb25zdCB0ZXJtVHlwZVByb3BlcnR5Q29tcGFyZXNUb1Byb3BlcnR5TmFtZSA9IHRlcm1UeXBlUHJvcGVydHkuY29tcGFyZVByb3BlcnR5TmFtZShwcm9wZXJ0eU5hbWUpO1xuXG4gICAgICAgICAgICBpZiAodGVybVR5cGVQcm9wZXJ0eUNvbXBhcmVzVG9Qcm9wZXJ0eU5hbWUpIHtcbiAgICAgICAgICAgICAgcmV0dXJuIHRydWU7XG4gICAgICAgICAgICB9XG4gICAgICAgICAgfSkgfHwgbnVsbDtcblxuICAgIGlmICh2YXJpYWJsZVR5cGVQcm9wZXJ0eSA9PT0gbnVsbCkge1xuICAgICAgY29uc3QgdmFyaWFibGVTdHJpbmcgPSB0aGlzLnRlcm0uZ2V0U3RyaW5nKCksXG4gICAgICAgICAgICB2YXJpYWJsZVR5cGVTdHJpbmcgPSB0ZXJtVHlwZS5nZXRTdHJpbmcoKTtcblxuICAgICAgY29udGV4dC5kZWJ1ZyhgVGhlICcke3Byb3BlcnR5TmFtZX0nIHByb3BlcnR5IGlzIG5vdCBhIHByb3BlcnR5IG9mIHRoZSAnJHt2YXJpYWJsZVN0cmluZ30nIHZhcmlhYmxlJ3MgJyR7dmFyaWFibGVUeXBlU3RyaW5nfScgdHlwZS5gKTtcbiAgICB9IGVsc2Uge1xuICAgICAgcHJvcGVydHlWZXJpZmllcyA9IHRydWU7XG4gICAgfVxuXG4gICAgaWYgKHByb3BlcnR5VmVyaWZpZXMpIHtcbiAgICAgIGNvbnRleHQuZGVidWcoYC4uLnZlcmlmaWVkIHRoZSAnJHtwcm9wZXJ0eVN0cmluZ30nIHByb3BlcnR5LmApO1xuICAgIH1cblxuICAgIHJldHVybiBwcm9wZXJ0eVZlcmlmaWVzO1xuICB9XG5cbiAgc3RhdGljIG5hbWUgPSBcIlByb3BlcnR5UmVsYXRpb25cIjtcbn0pO1xuIl0sIm5hbWVzIjpbImRlZmluZSIsIlByb3BlcnR5UmVsYXRpb24iLCJjb250ZXh0Iiwic3RyaW5nIiwibm9kZSIsInByb3BlcnR5IiwidGVybSIsImdldFByb3BlcnR5IiwiZ2V0VGVybSIsInZlcmlmeSIsInZlcmlmaWVzIiwicHJvcGVydHlSZWxhdGlvblN0cmluZyIsInRyYWNlIiwidGVybVZhbGlkYXRlcyIsInZhbGlkYXRlVGVybSIsInByb3BlcnR5VmVyaWZpZXMiLCJ2ZXJpZnlQcm9wZXJ0eSIsImRlYnVnIiwidGVybVN0cmluZyIsImdldFN0cmluZyIsInZhbGlkYXRlIiwidmVyaWZpZXNBaGVhZCIsInByb3BlcnR5U3RyaW5nIiwidGVybVR5cGUiLCJnZXRUeXBlIiwicHJvcGVydHlOYW1lIiwiZ2V0TmFtZSIsInRlcm1UeXBlUHJvcGVydGllcyIsImdldFByb3BlcnRpZXMiLCJ2YXJpYWJsZVR5cGVQcm9wZXJ0eSIsImZpbmQiLCJ0ZXJtVHlwZVByb3BlcnR5IiwidGVybVR5cGVQcm9wZXJ0eUNvbXBhcmVzVG9Qcm9wZXJ0eU5hbWUiLCJjb21wYXJlUHJvcGVydHlOYW1lIiwidmFyaWFibGVTdHJpbmciLCJ2YXJpYWJsZVR5cGVTdHJpbmciLCJFbGVtZW50IiwibmFtZSJdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7K0JBTUE7OztlQUFBOzs7OERBSm9CO3dCQUVHOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0lBRXZCLFdBQWVBLElBQUFBLGdCQUFNLHFDQUFDOzthQUFNQyxpQkFDZEMsT0FBTyxFQUFFQyxNQUFNLEVBQUVDLElBQUksRUFBRUMsUUFBUSxFQUFFQyxJQUFJO2dDQUR2Qkw7O2dCQUV4QixrQkFGd0JBO1lBRWxCQztZQUFTQztZQUFRQzs7UUFFdkIsTUFBS0MsUUFBUSxHQUFHQTtRQUNoQixNQUFLQyxJQUFJLEdBQUdBOzs7OztZQUdkQyxLQUFBQTttQkFBQUEsU0FBQUE7Z0JBQ0UsT0FBTyxJQUFJLENBQUNGLFFBQVE7WUFDdEI7OztZQUVBRyxLQUFBQTttQkFBQUEsU0FBQUE7Z0JBQ0UsT0FBTyxJQUFJLENBQUNGLElBQUk7WUFDbEI7OztZQUVBRyxLQUFBQTttQkFBQUEsU0FBQUEsT0FBT1AsT0FBTztnQkFDWixJQUFJUSxXQUFXO2dCQUVmLElBQU1DLHlCQUF5QixJQUFJLENBQUNSLE1BQU0sRUFBRSxHQUFHO2dCQUUvQ0QsUUFBUVUsS0FBSyxDQUFDLEFBQUMsa0JBQXdDLE9BQXZCRCx3QkFBdUI7Z0JBRXZELElBQU1FLGdCQUFnQixJQUFJLENBQUNDLFlBQVksQ0FBQ1o7Z0JBRXhDLElBQUlXLGVBQWU7b0JBQ2pCLElBQU1FLG1CQUFtQixJQUFJLENBQUNDLGNBQWMsQ0FBQ2Q7b0JBRTdDUSxXQUFXSztnQkFDYjtnQkFFQSxJQUFJTCxVQUFVO29CQUNaUixRQUFRZSxLQUFLLENBQUMsQUFBQyxvQkFBMEMsT0FBdkJOLHdCQUF1QjtnQkFDM0Q7Z0JBRUEsT0FBT0Q7WUFDVDs7O1lBRUFJLEtBQUFBO21CQUFBQSxTQUFBQSxhQUFhWixPQUFPO2dCQUNsQixJQUFJVztnQkFFSixJQUFNSyxhQUFhLElBQUksQ0FBQ1osSUFBSSxDQUFDYSxTQUFTO2dCQUV0Q2pCLFFBQVFVLEtBQUssQ0FBQyxBQUFDLG1CQUE2QixPQUFYTSxZQUFXO2dCQUU1Q0wsZ0JBQWdCLElBQUksQ0FBQ1AsSUFBSSxDQUFDYyxRQUFRLENBQUNsQixTQUFTO29CQUMxQyxJQUFNbUIsZ0JBQWdCO29CQUV0QixPQUFPQTtnQkFDVDtnQkFFQSxJQUFJUixlQUFlO29CQUNqQlgsUUFBUWUsS0FBSyxDQUFDLEFBQUMscUJBQStCLE9BQVhDLFlBQVc7Z0JBQ2hEO2dCQUVBLE9BQU9MO1lBQ1Q7OztZQUVBRyxLQUFBQTttQkFBQUEsU0FBQUEsZUFBZWQsT0FBTztnQkFDcEIsSUFBSWE7Z0JBRUosSUFBTU8saUJBQWlCLElBQUksQ0FBQ2pCLFFBQVEsQ0FBQ2MsU0FBUztnQkFFOUNqQixRQUFRVSxLQUFLLENBQUMsQUFBQyxrQkFBZ0MsT0FBZlUsZ0JBQWU7Z0JBRS9DLElBQU1DLFdBQVcsSUFBSSxDQUFDakIsSUFBSSxDQUFDa0IsT0FBTyxJQUM1QkMsZUFBZSxJQUFJLENBQUNwQixRQUFRLENBQUNxQixPQUFPLElBQ3BDQyxxQkFBcUJKLFNBQVNLLGFBQWEsSUFDM0NDLHVCQUF1QkYsbUJBQW1CRyxJQUFJLENBQUMsU0FBQ0M7b0JBQzlDLElBQU1DLHlDQUF5Q0QsaUJBQWlCRSxtQkFBbUIsQ0FBQ1I7b0JBRXBGLElBQUlPLHdDQUF3Qzt3QkFDMUMsT0FBTztvQkFDVDtnQkFDRixNQUFNO2dCQUVaLElBQUlILHlCQUF5QixNQUFNO29CQUNqQyxJQUFNSyxpQkFBaUIsSUFBSSxDQUFDNUIsSUFBSSxDQUFDYSxTQUFTLElBQ3BDZ0IscUJBQXFCWixTQUFTSixTQUFTO29CQUU3Q2pCLFFBQVFlLEtBQUssQ0FBQyxBQUFDLFFBQTJEaUIsT0FBcERULGNBQWEseUNBQXNFVSxPQUEvQkQsZ0JBQWUsa0JBQW1DLE9BQW5CQyxvQkFBbUI7Z0JBQzlILE9BQU87b0JBQ0xwQixtQkFBbUI7Z0JBQ3JCO2dCQUVBLElBQUlBLGtCQUFrQjtvQkFDcEJiLFFBQVFlLEtBQUssQ0FBQyxBQUFDLG9CQUFrQyxPQUFmSyxnQkFBZTtnQkFDbkQ7Z0JBRUEsT0FBT1A7WUFDVDs7OztxQkExRm1EcUIsZ0JBQU8sSUE0RjFELG9DQUFPQyxRQUFPIn0=
+//# sourceMappingURL=data:application/json;base64,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