occam-verify-cli 1.0.448 → 1.0.457

package/lib/element/proofAssertion/premise.js

@@ -0,0 +1,308 @@
+"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 _transient = /*#__PURE__*/ _interop_require_default(require("../../context/transient"));
+var _assign = /*#__PURE__*/ _interop_require_default(require("../../process/assign"));
+var _elements = require("../../elements");
+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 _Premise;
+var _default = (0, _elements.define)((_Premise = /*#__PURE__*/ function(ProofAssertion) {
+    _inherits(Premise, ProofAssertion);
+    function Premise(context, string, node, statement, procedureCall) {
+        _class_call_check(this, Premise);
+        var _this;
+        _this = _call_super(this, Premise, [
+            context,
+            string,
+            node,
+            statement
+        ]);
+        _this.procedureCall = procedureCall;
+        return _this;
+    }
+    _create_class(Premise, [
+        {
+            key: "getProcedureCall",
+            value: function getProcedureCall() {
+                return this.procedureCall;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(context) {
+                var verifies = false;
+                var transientContext = _transient.default.fromNothing(context);
+                context = transientContext; ///
+                var node = this.getNode(), premiseString = this.getString(); ///
+                context.trace("Verifying the '".concat(premiseString, "' premise..."), node);
+                var statement = this.getStatement();
+                if (statement === null && this.procedureCall === null) {
+                    context.debug("Unable to verify the '".concat(premiseString, "' premise because it is nonsense."), node);
+                } else {
+                    if (statement !== null) {
+                        var stated = true, assignments = [], statementValidates = statement.validate(assignments, stated, context);
+                        if (statementValidates) {
+                            var assignmentsAssigned = (0, _assign.default)(assignments, context);
+                            if (assignmentsAssigned) {
+                                var subproofOrProofAssertion = this; ///
+                                context.addSubproofOrProofAssertion(subproofOrProofAssertion);
+                                verifies = true;
+                            }
+                        }
+                    }
+                    if (this.procedureCall !== null) {
+                        var stated1 = true, assignments1 = null, procedureCallVerifies = this.procedureCall.verify(assignments1, stated1, context);
+                        if (procedureCallVerifies) {
+                            verifies = true;
+                        }
+                    }
+                }
+                if (verifies) {
+                    this.setContext(context);
+                    context.debug("...verified the '".concat(premiseString, "' premise."), node);
+                }
+                return verifies;
+            }
+        },
+        {
+            key: "unifyIndependently",
+            value: function unifyIndependently(substitutions, context) {
+                var unifiesIndependently = false;
+                var premiseString = this.getString(); ///
+                context.trace("Unifying the '".concat(premiseString, "' premise 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(premiseString, "' premise independenly."));
+                }
+                return unifiesIndependently;
+            }
+        },
+        {
+            key: "unifySubproofOrProofAssertion",
+            value: function unifySubproofOrProofAssertion(subproofOrProofAssertion, substitutions, context) {
+                var subproofOrProofAssertionUnifies = false;
+                var subproofOrProofAssertionProofAssertion = subproofOrProofAssertion.isProofAssertion(), proofAssertion = subproofOrProofAssertionProofAssertion ? subproofOrProofAssertion : null, subproof = subproofOrProofAssertionProofAssertion ? null : subproofOrProofAssertion;
+                substitutions.snapshot();
+                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() : substitutions.rollback(context);
+                return subproofOrProofAssertionUnifies;
+            }
+        },
+        {
+            key: "unifyProofAssertion",
+            value: function unifyProofAssertion(proofAssertion, substitutions, context) {
+                var proofAssertionUnifies = false;
+                var premiseString = this.getString(), proofAssertionString = proofAssertion.getString();
+                context.trace("Unifying the '".concat(proofAssertionString, "' proof assertion with the '").concat(premiseString, "' premise..."));
+                context = this.getContext();
+                var generalContext = context; ///
+                context = proofAssertion.getContext();
+                var specificContext = context; ///
+                context = specificContext; ///
+                var statement = proofAssertion.getStatement(), statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+                if (statementUnifies) {
+                    proofAssertionUnifies = true;
+                }
+                if (proofAssertionUnifies) {
+                    context.debug("...unified the '".concat(proofAssertionString, "' proof assertion with the '").concat(premiseString, "' premise."));
+                }
+                return proofAssertionUnifies;
+            }
+        },
+        {
+            key: "unifySubproof",
+            value: function unifySubproof(subproof, substitutions, context) {
+                var subproofUnifies = false;
+                var node = this.getNode(), premiseString = this.getString(), subproofString = subproof.getString();
+                context.trace("Unifying the '".concat(subproofString, "' subproof with the '").concat(premiseString, "' premise..."), 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(premiseString, "' premise."), node);
+                }
+                return subproofUnifies;
+            }
+        },
+        {
+            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), transientContext = _transient.default.fromTermsAndFrames(terms, frames, context);
+                var string;
+                if (statement !== null) {
+                    string = statement.getString();
+                }
+                if (procedureCall !== null) {
+                    string = procedureCall.getString();
+                }
+                var node = null;
+                context = transientContext; ///
+                var premise = new Premise(context, string, node, statement, procedureCall);
+                return premise;
+            }
+        }
+    ]);
+    return Premise;
+}(_proofAssertion.default), _define_property(_Premise, "name", "Premise"), _Premise));
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/element/proofAssertion/premise.js"],"sourcesContent":["\"use strict\";\n\nimport ProofAssertion from \"../proofAssertion\";\nimport TransientContext from \"../../context/transient\";\nimport assignAssignments from \"../../process/assign\";\n\nimport { define } from \"../../elements\";\nimport { termsFromJSON,\n         framesFromJSON,\n         termsToTermsJSON,\n         statementFromJSON,\n         framesToFramesJSON,\n         procedureCallFromJSON,\n         statementToStatementJSON,\n         procedureCallToProcedureCallJSON } from \"../../utilities/json\";\n\nexport default define(class Premise 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  verify(context) {\n    let verifies = false;\n\n    const transientContext = TransientContext.fromNothing(context);\n\n    context = transientContext; ///\n\n    const node = this.getNode(),\n          premiseString = this.getString(); ///\n\n    context.trace(`Verifying the '${premiseString}' premise...`, node);\n\n    const statement = this.getStatement();\n\n    if ((statement === null) && (this.procedureCall === null)) {\n      context.debug(`Unable to verify the '${premiseString}' premise because it is nonsense.`, node);\n    } else {\n      if (statement !== null) {\n        const stated = true,\n              assignments = [],\n              statementValidates = statement.validate(assignments, stated, 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            verifies = true;\n          }\n        }\n      }\n\n      if (this.procedureCall !== null) {\n        const stated = true,\n              assignments = null,\n              procedureCallVerifies = this.procedureCall.verify(assignments, stated, context);\n\n        if (procedureCallVerifies) {\n          verifies = true;\n        }\n      }\n    }\n\n    if (verifies) {\n      this.setContext(context);\n\n      context.debug(`...verified the '${premiseString}' premise.`, node);\n    }\n\n    return verifies;\n  }\n\n  unifyIndependently(substitutions, context) {\n    let unifiesIndependently = false;\n\n    const premiseString = this.getString(); ///\n\n    context.trace(`Unifying the '${premiseString}' premise 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 '${premiseString}' premise independenly.`);\n    }\n\n    return unifiesIndependently;\n  }\n\n  unifySubproofOrProofAssertion(subproofOrProofAssertion, substitutions, context) {\n    let subproofOrProofAssertionUnifies = false;\n\n    const subproofOrProofAssertionProofAssertion = subproofOrProofAssertion.isProofAssertion(),\n          proofAssertion = subproofOrProofAssertionProofAssertion ?\n                             subproofOrProofAssertion :\n                               null,\n          subproof = subproofOrProofAssertionProofAssertion ?\n                        null :\n                          subproofOrProofAssertion;\n\n    substitutions.snapshot();\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() :\n        substitutions.rollback(context);\n\n    return subproofOrProofAssertionUnifies;\n  }\n\n  unifyProofAssertion(proofAssertion, substitutions, context) {\n    let proofAssertionUnifies = false;\n\n    const premiseString = this.getString(),\n          proofAssertionString = proofAssertion.getString();\n\n    context.trace(`Unifying the '${proofAssertionString}' proof assertion with the '${premiseString}' premise...`);\n\n    context = this.getContext();\n\n    const generalContext = context; ///\n\n    context = proofAssertion.getContext();\n\n    const specificContext = context;  ///\n\n    context = specificContext;  ///\n\n    const statement = proofAssertion.getStatement(),\n          statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);\n\n    if (statementUnifies) {\n      proofAssertionUnifies = true;\n    }\n\n    if (proofAssertionUnifies) {\n      context.debug(`...unified the '${proofAssertionString}' proof assertion with the '${premiseString}' premise.`);\n    }\n\n    return proofAssertionUnifies;\n  }\n\n  unifySubproof(subproof, substitutions, context) {\n    let subproofUnifies = false;\n\n    const node = this.getNode(),\n          premiseString = this.getString(),\n          subproofString = subproof.getString();\n\n    context.trace(`Unifying the '${subproofString}' subproof with the '${premiseString}' premise...`, 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 '${premiseString}' premise.`, node);\n    }\n\n    return subproofUnifies;\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 = \"Premise\";\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          transientContext = TransientContext.fromTermsAndFrames(terms, frames, 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    context = transientContext; ///\n\n    const premise = new Premise(context, string, node, statement, procedureCall);\n\n    return premise;\n  }\n});\n"],"names":["define","Premise","context","string","node","statement","procedureCall","getProcedureCall","verify","verifies","transientContext","TransientContext","fromNothing","getNode","premiseString","getString","trace","getStatement","debug","stated","assignments","statementValidates","validate","assignmentsAssigned","assignAssignments","subproofOrProofAssertion","addSubproofOrProofAssertion","procedureCallVerifies","setContext","unifyIndependently","substitutions","unifiesIndependently","specificContext","getContext","generalContext","statementUnifiesIndependently","procedureCallResolvedIndependently","unifySubproofOrProofAssertion","subproofOrProofAssertionUnifies","subproofOrProofAssertionProofAssertion","isProofAssertion","proofAssertion","subproof","snapshot","subproofUnifies","unifySubproof","proofAssertionUnifies","unifyProofAssertion","resolve","continue","rollback","proofAssertionString","statementUnifies","unifyStatement","subproofString","statementNode","subproofAssertionNode","getSubproofAssertionNode","assertionNode","assertion","findAssertionByAssertionNode","subproofAssertion","toJSON","frames","terms","getFrames","getTerms","procedureCallJSON","procedureCallToProcedureCallJSON","statementJSON","statementToStatementJSON","framesJSON","framesToFramesJSON","termsJSON","termsToTermsJSON","json","fromJSON","termsFromJSON","framesFromJSON","statementFromJSON","procedureCallFromJSON","fromTermsAndFrames","premise","ProofAssertion","name"],"mappings":"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"}