occam-verify-cli 1.0.420 → 1.0.427

package/lib/element/axiom.js

@@ -0,0 +1,332 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _axiomLemmaTheoremConjecture = /*#__PURE__*/ _interop_require_default(require("./axiomLemmaTheoremConjecture"));
+var _elements = require("../elements");
+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(target, property, receiver) {
+    if (typeof Reflect !== "undefined" && Reflect.get) {
+        _get = Reflect.get;
+    } else {
+        _get = function get(target, property, receiver) {
+            var base = _super_prop_base(target, property);
+            if (!base) return;
+            var desc = Object.getOwnPropertyDescriptor(base, property);
+            if (desc.get) {
+                return desc.get.call(receiver || target);
+            }
+            return desc.value;
+        };
+    }
+    return _get(target, property, receiver || target);
+}
+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 _super_prop_base(object, property) {
+    while(!Object.prototype.hasOwnProperty.call(object, property)){
+        object = _get_prototype_of(object);
+        if (object === null) break;
+    }
+    return object;
+}
+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 _Axiom;
+var _default = (0, _elements.define)((_Axiom = /*#__PURE__*/ function(AxiomLemmaTheoremConjecture) {
+    _inherits(Axiom, AxiomLemmaTheoremConjecture);
+    function Axiom() {
+        _class_call_check(this, Axiom);
+        return _call_super(this, Axiom, arguments);
+    }
+    _create_class(Axiom, [
+        {
+            key: "isSatisfiable",
+            value: function isSatisfiable() {
+                var signature = this.getSignature(), satisfiable = signature !== null;
+                return satisfiable;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify() {
+                var verifies;
+                var axiom = this, node = this.getNode(), context = this.getContext(), axiomString = axiom.getString();
+                context.trace("Verifying the '".concat(axiomString, "' axiom..."), node);
+                var signatureVerifies = this.verifySignature();
+                if (signatureVerifies) {
+                    verifies = _get(_get_prototype_of(Axiom.prototype), "verify", this).call(this);
+                }
+                if (verifies) {
+                    var axiom1 = this; ///
+                    context.addAxiom(axiom1);
+                    context.debug("...verified the '".concat(axiomString, "' axiom."), node);
+                }
+                return verifies;
+            }
+        },
+        {
+            key: "verifySignature",
+            value: function verifySignature() {
+                var signatureVerifies;
+                var satisfiable = this.isSatisfiable();
+                if (satisfiable) {
+                    var context = this.getContext(), signature = this.getSignature();
+                    signatureVerifies = signature.verify(context);
+                } else {
+                    signatureVerifies = true;
+                }
+                return signatureVerifies;
+            }
+        },
+        {
+            key: "matchSignature",
+            value: function matchSignature(signature, substitutions, context) {
+                var signatureMatches = false;
+                var satisfiable = this.isSatisfiable();
+                if (satisfiable) {
+                    var signatureA = signature; ///
+                    signature = this.getSignature();
+                    var signatureB = signature, specificContext = context; ///
+                    context = this.getContext();
+                    var generalContext = context; ///
+                    signatureMatches = signatureA.match(signatureB, substitutions, generalContext, specificContext);
+                }
+                return signatureMatches;
+            }
+        },
+        {
+            key: "unifyStep",
+            value: function unifyStep(step, substitutions, context) {
+                var stepUnifies = false;
+                context = step.getContext();
+                var node = this.getNode(), stepString = step.getString(), axiomString = this.getString();
+                context.trace("Unifying the '".concat(stepString, "' step with the '").concat(axiomString, "' axiom..."), node);
+                var unconditional = this.isUnconditional();
+                if (!unconditional) {
+                    context.trace("Cannot unify the '".concat(stepString, "' step with the '").concat(axiomString, "' axiom because the axiom is not unconditional."), node);
+                } else {
+                    var statement = step.getStatement(), statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, context);
+                    if (statementUnifiesWithDeduction) {
+                        stepUnifies = true;
+                    }
+                }
+                if (stepUnifies) {
+                    context.debug("...unified the '".concat(stepString, "' step with the '").concat(axiomString, "' axiom."), node);
+                }
+                return stepUnifies;
+            }
+        },
+        {
+            key: "unifyLastStep",
+            value: function unifyLastStep(lastStep, substitutions, context) {
+                var lastStepUnifies = false;
+                var node = this.getNode(), axiomString = this.getString(), lastStepString = lastStep.getString();
+                context.trace("Unifying the '".concat(lastStepString, "' last step with the '").concat(axiomString, "' axiom..."), node);
+                var statement = lastStep.getStatement(), statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, context);
+                if (statementUnifiesWithDeduction) {
+                    lastStepUnifies = true;
+                }
+                if (lastStepUnifies) {
+                    context.debug("...unified the '".concat(lastStepString, "' last step with the '").concat(axiomString, "' axiom."), node);
+                }
+                return lastStepUnifies;
+            }
+        },
+        {
+            key: "unifySubproof",
+            value: function unifySubproof(subproof, substitutions, context) {
+                var subproofUnifies = false;
+                var node = this.getNode(), axiomString = this.getString(), subproofString = subproof.getString();
+                context.trace("Unifying the '".concat(subproofString, "' subproof with the '").concat(axiomString, "' axiom..."), node);
+                var unconditional = this.isUnconditional();
+                if (unconditional) {
+                    context.trace("Cannot unify the '".concat(subproofString, "' subproof with the '").concat(axiomString, "' axiom because the axiom is unconditional."), node);
+                } else {
+                    var lastStep = subproof.getLastStep(), lastStepUnifies = this.unifyLastStep(lastStep, substitutions, context);
+                    if (lastStepUnifies) {
+                        var suppositions = subproof.getSuppositions(), suppositionsUnify = this.unifySuppositions(suppositions, substitutions, context);
+                        if (suppositionsUnify) {
+                            subproofUnifies = true;
+                        }
+                    }
+                }
+                if (subproofUnifies) {
+                    context.debug("...unified the '".concat(subproofString, "' subproof with the '").concat(axiomString, "' axiom."), node);
+                }
+                return subproofUnifies;
+            }
+        },
+        {
+            key: "unifyDeduction",
+            value: function unifyDeduction(deduction, substitutions, generalContext, specificContext) {
+                var deductionUnifies;
+                var specificDeduction = deduction; ///
+                deduction = this.getDeduction();
+                var generalDeduction = deduction; ///
+                deduction = specificDeduction; ///
+                deductionUnifies = generalDeduction.unifyDeduction(deduction, substitutions, generalContext, specificContext);
+                return deductionUnifies;
+            }
+        },
+        {
+            key: "unifySupposition",
+            value: function unifySupposition(supposition, index, substitutions, generalContext, specificContext) {
+                var suppositionUnifies;
+                var specificSupposition = supposition; ///
+                supposition = this.getSupposition(index);
+                var generalSupposition = supposition; ///
+                supposition = specificSupposition; ///
+                suppositionUnifies = generalSupposition.unifySupposition(supposition, substitutions, generalContext, specificContext);
+                return suppositionUnifies;
+            }
+        },
+        {
+            key: "unifySuppositions",
+            value: function unifySuppositions(suppositions, substitutions, generalContext, specificContext) {
+                var _this = this;
+                var suppositionsUnify = false;
+                var specificSuppositions = suppositions; ///
+                suppositions = this.getSuppositions();
+                var generalSuppositions = suppositions, generalSuppositionsLength = generalSuppositions.length, specificSuppositionsLength = specificSuppositions.length;
+                if (generalSuppositionsLength === specificSuppositionsLength) {
+                    suppositions = specificSuppositions; ///
+                    var suppositionsMatch = suppositions.every(function(supposition, index) {
+                        var suppositionUnifies = _this.unifySupposition(supposition, index, substitutions, generalContext, specificContext);
+                        if (suppositionUnifies) {
+                            return true;
+                        }
+                    });
+                    if (suppositionsMatch) {
+                        suppositionsUnify = true;
+                    }
+                }
+                return suppositionsUnify;
+            }
+        },
+        {
+            key: "unifyAxiomLemmaTheoremOrConjecture",
+            value: function unifyAxiomLemmaTheoremOrConjecture(axiomLemmaTheoremOrConjecture, substitutions, context) {
+                var axiomLemmaTheoremOrConjectureUnifies = false;
+                var node = this.getNode(), axiomString = this.getString(), axiomLemmaTheoremOrConjectureString = axiomLemmaTheoremOrConjecture.getString();
+                context.trace("Unifying the '".concat(axiomLemmaTheoremOrConjectureString, "' axiom, lemma, theorem or conjecture with the '").concat(axiomString, "' axiom..."), node);
+                var hypothesesCorrelate = axiomLemmaTheoremOrConjecture.correlateHypotheses(context);
+                if (hypothesesCorrelate) {
+                    var deduction = axiomLemmaTheoremOrConjecture.getDeduction(), specificContext = context; ///
+                    context = this.getContext();
+                    var generalContext = context, deductionUnifies = this.unifyDeduction(deduction, substitutions, generalContext, specificContext);
+                    if (deductionUnifies) {
+                        var suppositions = axiomLemmaTheoremOrConjecture.getSuppositions(), suppositionsUnify = this.unifySuppositions(suppositions, substitutions, generalContext, specificContext);
+                        axiomLemmaTheoremOrConjectureUnifies = suppositionsUnify; ///
+                    }
+                }
+                if (axiomLemmaTheoremOrConjectureUnifies) {
+                    context.debug("...unified the '".concat(axiomLemmaTheoremOrConjectureString, "' axiom, lemma, theorem or conjecture with the '").concat(axiomString, "' axiom."), node);
+                }
+                return axiomLemmaTheoremOrConjectureUnifies;
+            }
+        }
+    ], [
+        {
+            key: "fromJSON",
+            value: function fromJSON(json, context) {
+                return _axiomLemmaTheoremConjecture.default.fromJSON(Axiom, json, context);
+            }
+        }
+    ]);
+    return Axiom;
+}(_axiomLemmaTheoremConjecture.default), _define_property(_Axiom, "name", "Axiom"), _Axiom));
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/element/axiom.js"],"sourcesContent":["\"use strict\";\n\nimport AxiomLemmaTheoremConjecture  from \"./axiomLemmaTheoremConjecture\";\n\nimport { define } from \"../elements\";\n\nexport default define(class Axiom extends AxiomLemmaTheoremConjecture {\n  isSatisfiable() {\n    const signature = this.getSignature(),\n          satisfiable = (signature !== null);\n\n    return satisfiable;\n  }\n\n  verify() {\n    let verifies;\n\n    const axiom = this, ///\n          node = this.getNode(),\n          context = this.getContext(),\n          axiomString = axiom.getString();\n\n    context.trace(`Verifying the '${axiomString}' axiom...`, node);\n\n    const signatureVerifies = this.verifySignature();\n\n    if (signatureVerifies) {\n      verifies = super.verify();\n    }\n\n    if (verifies) {\n      const axiom = this; ///\n\n      context.addAxiom(axiom);\n\n      context.debug(`...verified the '${axiomString}' axiom.`, node);\n    }\n\n    return verifies;\n  }\n\n  verifySignature() {\n    let signatureVerifies;\n\n    const satisfiable = this.isSatisfiable();\n\n    if (satisfiable) {\n      const context = this.getContext(),\n            signature = this.getSignature();\n\n      signatureVerifies = signature.verify(context);\n    } else {\n      signatureVerifies = true\n    }\n\n    return signatureVerifies;\n  }\n\n  matchSignature(signature, substitutions, context) {\n    let signatureMatches = false;\n\n    const satisfiable = this.isSatisfiable();\n\n    if (satisfiable) {\n      const signatureA = signature; ///\n\n      signature = this.getSignature()\n\n      const signatureB = signature, ///\n            specificContext = context;  ///\n\n      context = this.getContext();\n\n      const generalContext = context;  ///\n\n      signatureMatches = signatureA.match(signatureB, substitutions, generalContext, specificContext);\n    }\n\n    return signatureMatches;\n  }\n\n  unifyStep(step, substitutions, context) {\n    let stepUnifies = false;\n\n    context = step.getContext();\n\n    const node = this.getNode(),\n          stepString = step.getString(),\n          axiomString = this.getString();\n\n    context.trace(`Unifying the '${stepString}' step with the '${axiomString}' axiom...`, node);\n\n    const unconditional = this.isUnconditional();\n\n    if (!unconditional) {\n      context.trace(`Cannot unify the '${stepString}' step with the '${axiomString}' axiom because the axiom is not unconditional.`, node);\n    } else {\n      const statement = step.getStatement(),\n            statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, context);\n\n      if (statementUnifiesWithDeduction) {\n        stepUnifies = true;\n      }\n    }\n\n    if (stepUnifies) {\n      context.debug(`...unified the '${stepString}' step with the '${axiomString}' axiom.`, node);\n    }\n\n    return stepUnifies;\n  }\n\n  unifyLastStep(lastStep, substitutions, context) {\n    let lastStepUnifies = false;\n\n    const node = this.getNode(),\n          axiomString = this.getString(),\n          lastStepString = lastStep.getString();\n\n    context.trace(`Unifying the '${lastStepString}' last step with the '${axiomString}' axiom...`, node)\n\n    const statement = lastStep.getStatement(),\n          statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, context);\n\n    if (statementUnifiesWithDeduction) {\n      lastStepUnifies = true;\n    }\n\n    if (lastStepUnifies) {\n      context.debug(`...unified the '${lastStepString}' last step with the '${axiomString}' axiom.`, node)\n    }\n\n    return lastStepUnifies;\n  }\n\n  unifySubproof(subproof, substitutions, context) {\n    let subproofUnifies = false;\n\n    const node = this.getNode(),\n          axiomString = this.getString(),\n          subproofString = subproof.getString();\n\n    context.trace(`Unifying the '${subproofString}' subproof with the '${axiomString}' axiom...`, node);\n\n    const unconditional = this.isUnconditional();\n\n    if (unconditional) {\n      context.trace(`Cannot unify the '${subproofString}' subproof with the '${axiomString}' axiom because the axiom is unconditional.`, node);\n    } else {\n      const lastStep = subproof.getLastStep(),\n            lastStepUnifies = this.unifyLastStep(lastStep, substitutions, context);\n\n      if (lastStepUnifies) {\n        const suppositions = subproof.getSuppositions(),\n              suppositionsUnify = this.unifySuppositions(suppositions, substitutions, context);\n\n        if (suppositionsUnify) {\n          subproofUnifies = true;\n        }\n      }\n    }\n\n    if (subproofUnifies) {\n      context.debug(`...unified the '${subproofString}' subproof with the '${axiomString}' axiom.`, node);\n    }\n\n    return subproofUnifies;\n  }\n\n  unifyDeduction(deduction, substitutions, generalContext, specificContext) {\n    let deductionUnifies;\n\n    const specificDeduction = deduction;  ///\n\n    deduction = this.getDeduction();\n\n    const generalDeduction = deduction; ///\n\n    deduction = specificDeduction;  ///\n\n    deductionUnifies = generalDeduction.unifyDeduction(deduction, substitutions, generalContext, specificContext);\n\n    return deductionUnifies;\n  }\n\n  unifySupposition(supposition, index, substitutions, generalContext, specificContext) {\n    let suppositionUnifies;\n\n    const specificSupposition = supposition;  ///\n\n    supposition = this.getSupposition(index);\n\n    const generalSupposition = supposition; ///\n\n    supposition = specificSupposition;  ///\n\n    suppositionUnifies = generalSupposition.unifySupposition(supposition, substitutions, generalContext, specificContext);\n\n    return suppositionUnifies;\n  }\n\n  unifySuppositions(suppositions, substitutions, generalContext, specificContext) {\n    let suppositionsUnify = false;\n\n    const specificSuppositions = suppositions;  ///\n\n    suppositions = this.getSuppositions();\n\n    const generalSuppositions = suppositions, ///\n          generalSuppositionsLength = generalSuppositions.length,\n          specificSuppositionsLength = specificSuppositions.length;\n\n    if (generalSuppositionsLength === specificSuppositionsLength) {\n      suppositions = specificSuppositions;  ///\n\n      const suppositionsMatch = suppositions.every((supposition, index) => {\n        const suppositionUnifies = this.unifySupposition(supposition, index, substitutions, generalContext, specificContext);\n\n        if (suppositionUnifies) {\n          return true;\n        }\n      });\n\n      if (suppositionsMatch) {\n        suppositionsUnify = true;\n      }\n    }\n\n    return suppositionsUnify;\n  }\n\n  unifyAxiomLemmaTheoremOrConjecture(axiomLemmaTheoremOrConjecture, substitutions, context) {\n    let axiomLemmaTheoremOrConjectureUnifies = false;\n\n    const node = this.getNode(),\n          axiomString = this.getString(),\n          axiomLemmaTheoremOrConjectureString = axiomLemmaTheoremOrConjecture.getString();\n\n    context.trace(`Unifying the '${axiomLemmaTheoremOrConjectureString}' axiom, lemma, theorem or conjecture with the '${axiomString}' axiom...`, node);\n\n    const hypothesesCorrelate = axiomLemmaTheoremOrConjecture.correlateHypotheses(context);\n\n    if (hypothesesCorrelate) {\n      const deduction = axiomLemmaTheoremOrConjecture.getDeduction(),  ///\n            specificContext = context;  ///\n\n      context = this.getContext();\n\n      const generalContext = context, ///\n            deductionUnifies = this.unifyDeduction(deduction, substitutions, generalContext, specificContext);\n\n      if (deductionUnifies) {\n        const suppositions = axiomLemmaTheoremOrConjecture.getSuppositions(),\n              suppositionsUnify = this.unifySuppositions(suppositions, substitutions, generalContext, specificContext);\n\n        axiomLemmaTheoremOrConjectureUnifies = suppositionsUnify; ///\n      }\n    }\n\n    if (axiomLemmaTheoremOrConjectureUnifies) {\n      context.debug(`...unified the '${axiomLemmaTheoremOrConjectureString}' axiom, lemma, theorem or conjecture with the '${axiomString}' axiom.`, node);\n    }\n\n    return axiomLemmaTheoremOrConjectureUnifies;\n  }\n\n  static name = \"Axiom\";\n\n  static fromJSON(json, context) { return AxiomLemmaTheoremConjecture.fromJSON(Axiom, json, context); }\n});\n"],"names":["define","Axiom","isSatisfiable","signature","getSignature","satisfiable","verify","verifies","axiom","node","getNode","context","getContext","axiomString","getString","trace","signatureVerifies","verifySignature","addAxiom","debug","matchSignature","substitutions","signatureMatches","signatureA","signatureB","specificContext","generalContext","match","unifyStep","step","stepUnifies","stepString","unconditional","isUnconditional","statement","getStatement","statementUnifiesWithDeduction","unifyStatementWithDeduction","unifyLastStep","lastStep","lastStepUnifies","lastStepString","unifySubproof","subproof","subproofUnifies","subproofString","getLastStep","suppositions","getSuppositions","suppositionsUnify","unifySuppositions","unifyDeduction","deduction","deductionUnifies","specificDeduction","getDeduction","generalDeduction","unifySupposition","supposition","index","suppositionUnifies","specificSupposition","getSupposition","generalSupposition","specificSuppositions","generalSuppositions","generalSuppositionsLength","length","specificSuppositionsLength","suppositionsMatch","every","unifyAxiomLemmaTheoremOrConjecture","axiomLemmaTheoremOrConjecture","axiomLemmaTheoremOrConjectureUnifies","axiomLemmaTheoremOrConjectureString","hypothesesCorrelate","correlateHypotheses","fromJSON","json","AxiomLemmaTheoremConjecture","name"],"mappings":"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"}