occam-verify-cli 0.0.1111 → 0.0.1114

package/lib/dom/subproof.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _dom = /*#__PURE__*/ _interop_require_wildcard(require("../dom"));
+var _local = /*#__PURE__*/ _interop_require_default(require("../context/local"));
+var _query = require("../utilities/query");
+var _subproof = require("../utilities/subproof");
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+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 _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var _Subproof;
+var subproofNodeQuery = (0, _query.nodeQuery)("/proofStep/subproof"), suppositionNodesQuery = (0, _query.nodesQuery)("/subproof/supposition"), subDerivationNodeQuery = (0, _query.nodeQuery)("/subproof/subDerivation");
+var _default = (0, _dom.domAssigned)((_Subproof = /*#__PURE__*/ function() {
+    function Subproof(string, suppositions, subDerivation) {
+        _class_call_check(this, Subproof);
+        this.string = string;
+        this.suppositions = suppositions;
+        this.subDerivation = subDerivation;
+    }
+    _create_class(Subproof, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getNode",
+            value: function getNode() {
+                return this.node;
+            }
+        },
+        {
+            key: "getSuppositions",
+            value: function getSuppositions() {
+                return this.suppositions;
+            }
+        },
+        {
+            key: "getSubDerivation",
+            value: function getSubDerivation() {
+                return this.subDerivation;
+            }
+        },
+        {
+            key: "getLastProofStep",
+            value: function getLastProofStep() {
+                return this.subDerivation.getLastProofStep();
+            }
+        },
+        {
+            key: "getStatements",
+            value: function getStatements() {
+                var lastProofStep = this.getLastProofStep(), suppositionStatements = this.suppositions.map(function(supposition) {
+                    var suppositionStatement = supposition.getStatement();
+                    return suppositionStatement;
+                }), lastProofStepStatement = lastProofStep.getStatement(), statements = _to_consumable_array(suppositionStatements).concat([
+                    lastProofStepStatement
+                ]);
+                return statements;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(substitutions, context) {
+                var subproofVerified = false;
+                var localContext = _local.default.fromContext(context); ///
+                context = localContext; ///
+                var suppositionsVerified = this.suppositions.every(function(supposition) {
+                    var suppositionVerified = supposition.verify(context);
+                    if (suppositionVerified) {
+                        return true;
+                    }
+                });
+                if (suppositionsVerified) {
+                    var subDerivationVerified = this.subDerivation.verify(substitutions, context);
+                    if (subDerivationVerified) {
+                        subproofVerified = true;
+                    }
+                }
+                return subproofVerified;
+            }
+        }
+    ], [
+        {
+            key: "fromProofStepNode",
+            value: function fromProofStepNode(proofStepNode, fileContext) {
+                var subproof = null;
+                var subproofNode = subproofNodeQuery(proofStepNode);
+                if (subproofNode !== null) {
+                    var Supposition = _dom.default.Supposition, SubDerivation = _dom.default.SubDerivation, subproofString = (0, _subproof.subproofStringFromSubproofNode)(subproofNode, fileContext), suppositionNodes = suppositionNodesQuery(subproofNode), subDerivationNode = subDerivationNodeQuery(subproofNode), string = subproofString, suppositions = suppositionNodes.map(function(suppositionNode) {
+                        var supposition = Supposition.fromSuppositionNode(suppositionNode, fileContext);
+                        return supposition;
+                    }), subDerivation = SubDerivation.fromSubDerivationNode(subDerivationNode, fileContext);
+                    subproof = new Subproof(string, suppositions, subDerivation);
+                }
+                return subproof;
+            }
+        }
+    ]);
+    return Subproof;
+}(), _define_property(_Subproof, "name", "Subproof"), _Subproof));
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/dom/supposition.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _dom = /*#__PURE__*/ _interop_require_wildcard(require("../dom"));
+var _assignments = require("../utilities/assignments");
+var _verification = require("../utilities/verification");
+var _json = require("../utilities/json");
+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 _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var _Supposition;
+var _default = (0, _dom.domAssigned)((_Supposition = /*#__PURE__*/ function() {
+    function Supposition(string, statement) {
+        _class_call_check(this, Supposition);
+        this.string = string;
+        this.statement = statement;
+    }
+    _create_class(Supposition, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getStatement",
+            value: function getStatement() {
+                return this.statement;
+            }
+        },
+        {
+            key: "unifyIndependently",
+            value: function unifyIndependently(substitutions, generalContext, specificContext) {
+                var unifiedIndependently;
+                var statementResolvedIndependently = this.statement.unifyIndependently(substitutions, generalContext, specificContext);
+                unifiedIndependently = statementResolvedIndependently; ///
+                return unifiedIndependently;
+            }
+        },
+        {
+            key: "unifyProofStep",
+            value: function unifyProofStep(proofStep, substitutions, generalContext, specificContext) {
+                var proofStepUnified = false;
+                var subproof = proofStep.getSubproof(), statement = proofStep.getStatement();
+                substitutions.snapshot();
+                if (subproof !== null) {
+                    var subproofUnified = this.unifySubproof(subproof, substitutions, generalContext, specificContext);
+                    proofStepUnified = subproofUnified; ///
+                }
+                if (statement !== null) {
+                    var statementUnified = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+                    proofStepUnified = statementUnified; ///
+                }
+                if (proofStepUnified) {
+                    substitutions.resolve(generalContext, specificContext);
+                }
+                var context = specificContext; ///
+                proofStepUnified ? substitutions.continue() : substitutions.rollback(context);
+                return proofStepUnified;
+            }
+        },
+        {
+            key: "unifyStatement",
+            value: function unifyStatement(statement, substitutions, generalContext, specificContext) {
+                var statementUnified;
+                var supposition = this, suppositionString = supposition.getString(), statementString = statement.getString();
+                specificContext.trace("Unifying the '".concat(statementString, "' statement with the '").concat(suppositionString, "' supposition..."));
+                statementUnified = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
+                if (statementUnified) {
+                    specificContext.debug("...unified the '".concat(statementString, "' statement with the '").concat(suppositionString, "' supposition."));
+                }
+                return statementUnified;
+            }
+        },
+        {
+            key: "unifySubproof",
+            value: function unifySubproof(subproof, substitutions, generalContext, specificContext) {
+                var subproofUnified = false;
+                var supposition = this, subproofString = subproof.getString(), suppositionStatement = supposition.getStatement(), suppositionStatementString = suppositionStatement.getString();
+                specificContext.trace("Unifying the '".concat(subproofString, "' subproof with the supposition's '").concat(suppositionStatementString, "' statement..."));
+                var context = generalContext, subproofAssertion = (0, _verification.subproofAssertionFromStatement)(this.statement, context);
+                if (subproofAssertion !== null) {
+                    subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);
+                }
+                if (subproofUnified) {
+                    specificContext.debug("...unified the '".concat(subproofString, "' subproof with the supposition's '").concat(suppositionStatementString, "' statement."));
+                }
+                return subproofUnified;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(context) {
+                var verified = false;
+                var suppositionString = this.string; ///
+                if (this.statement !== null) {
+                    context.trace("Verifying the '".concat(suppositionString, "' supposition..."));
+                    var stated = true, assignments = [], statementVerified = this.statement.verify(assignments, stated, context);
+                    if (statementVerified) {
+                        var assignmentsAssigned = (0, _assignments.assignAssignments)(assignments, context);
+                        if (assignmentsAssigned) {
+                            var ProofStep = _dom.default.ProofStep, proofStep = ProofStep.fromStatement(this.statement, context);
+                            context.addProofStep(proofStep);
+                            verified = true;
+                        }
+                    }
+                    if (verified) {
+                        context.debug("...verified the '".concat(suppositionString, "' supposition."));
+                    }
+                } else {
+                    context.debug("Unable to verify the '".concat(suppositionString, "' supposition because it is nonsense."));
+                }
+                return verified;
+            }
+        },
+        {
+            key: "toJSON",
+            value: function toJSON() {
+                var statementJSON = (0, _json.statementToStatementJSON)(this.statement), statement = statementJSON, json = {
+                    statement: statement
+                };
+                return json;
+            }
+        }
+    ], [
+        {
+            key: "fromJSON",
+            value: function fromJSON(json, fileContext) {
+                var statement = (0, _json.statementFromJSON)(json, fileContext), string = statement.getString(), supposition = new Supposition(string, statement);
+                return supposition;
+            }
+        },
+        {
+            key: "fromSuppositionNode",
+            value: function fromSuppositionNode(suppositionNode, fileContext) {
+                var Statement = _dom.default.Statement, statement = Statement.fromSuppositionNode(suppositionNode, fileContext), statementString = statement.getString(), string = statementString, supposition = new Supposition(string, statement);
+                return supposition;
+            }
+        }
+    ]);
+    return Supposition;
+}(), _define_property(_Supposition, "name", "Supposition"), _Supposition));
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/dom/supposition.js"],"sourcesContent":["\"use strict\";\n\nimport dom from \"../dom\";\n\nimport { domAssigned } from \"../dom\";\nimport { assignAssignments } from \"../utilities/assignments\";\nimport { subproofAssertionFromStatement } from \"../utilities/verification\";\nimport { statementFromJSON, statementToStatementJSON } from \"../utilities/json\";\n\nexport default domAssigned(class Supposition {\n  constructor(string, statement) {\n    this.string = string;\n    this.statement = statement;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getStatement() {\n    return this.statement;\n  }\n\n  unifyIndependently(substitutions, generalContext, specificContext) {\n    let unifiedIndependently;\n\n    const statementResolvedIndependently = this.statement.unifyIndependently(substitutions, generalContext, specificContext);\n\n    unifiedIndependently = statementResolvedIndependently;  ///\n\n    return unifiedIndependently;\n  }\n\n  unifyProofStep(proofStep, substitutions, generalContext, specificContext) {\n    let proofStepUnified = false;\n\n    const subproof = proofStep.getSubproof(),\n          statement = proofStep.getStatement();\n\n    substitutions.snapshot();\n\n    if (subproof !== null) {\n      const subproofUnified = this.unifySubproof(subproof, substitutions, generalContext, specificContext);\n\n      proofStepUnified = subproofUnified; ///\n    }\n\n    if (statement !== null) {\n      const statementUnified = this.unifyStatement(statement, substitutions, generalContext, specificContext);\n\n      proofStepUnified = statementUnified;  ///\n    }\n\n    if (proofStepUnified) {\n      substitutions.resolve(generalContext, specificContext);\n    }\n\n    const context = specificContext;  ///\n\n    proofStepUnified ?\n      substitutions.continue() :\n        substitutions.rollback(context);\n\n    return proofStepUnified;\n  }\n\n  unifyStatement(statement, substitutions, generalContext, specificContext) {\n    let statementUnified;\n\n    const supposition = this, ///\n          suppositionString = supposition.getString(),\n          statementString = statement.getString();\n\n    specificContext.trace(`Unifying the '${statementString}' statement with the '${suppositionString}' supposition...`);\n\n    statementUnified = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);\n\n    if (statementUnified) {\n      specificContext.debug(`...unified the '${statementString}' statement with the '${suppositionString}' supposition.`);\n    }\n\n    return statementUnified;\n  }\n\n  unifySubproof(subproof, substitutions, generalContext, specificContext) {\n    let subproofUnified = false;\n\n    const supposition = this, ///\n          subproofString = subproof.getString(),\n          suppositionStatement = supposition.getStatement(),\n          suppositionStatementString = suppositionStatement.getString();\n\n    specificContext.trace(`Unifying the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement...`);\n\n    const context = generalContext,\n          subproofAssertion = subproofAssertionFromStatement(this.statement, context);\n\n    if (subproofAssertion !== null) {\n      subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);\n    }\n\n    if (subproofUnified) {\n      specificContext.debug(`...unified the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement.`);\n    }\n\n    return subproofUnified;\n  }\n\n  verify(context) {\n    let verified = false;\n\n    const suppositionString = this.string; ///\n\n    if (this.statement !== null) {\n      context.trace(`Verifying the '${suppositionString}' supposition...`);\n\n      const stated = true,\n            assignments = [],\n            statementVerified = this.statement.verify(assignments, stated, context);\n\n      if (statementVerified) {\n        const assignmentsAssigned = assignAssignments(assignments, context);\n\n        if (assignmentsAssigned) {\n          const { ProofStep } = dom,\n                proofStep = ProofStep.fromStatement(this.statement, context);\n\n          context.addProofStep(proofStep);\n\n          verified = true;\n        }\n      }\n\n      if (verified) {\n        context.debug(`...verified the '${suppositionString}' supposition.`);\n      }\n    } else {\n      context.debug(`Unable to verify the '${suppositionString}' supposition because it is nonsense.`);\n    }\n\n    return verified;\n  }\n\n  toJSON() {\n    const statementJSON = statementToStatementJSON(this.statement),\n          statement = statementJSON,  ///\n          json = {\n            statement\n          };\n\n    return json;\n  }\n\n  static name = \"Supposition\";\n\n  static fromJSON(json, fileContext) {\n    const statement = statementFromJSON(json, fileContext),\n          string = statement.getString(),\n          supposition = new Supposition(string, statement);\n\n    return supposition;\n  }\n\n  static fromSuppositionNode(suppositionNode, fileContext) {\n    const { Statement } = dom,\n          statement = Statement.fromSuppositionNode(suppositionNode, fileContext),\n          statementString = statement.getString(),\n          string = statementString, ///\n          supposition = new Supposition(string, statement);\n\n    return supposition\n  }\n});\n"],"names":["domAssigned","Supposition","string","statement","getString","getStatement","unifyIndependently","substitutions","generalContext","specificContext","unifiedIndependently","statementResolvedIndependently","unifyProofStep","proofStep","proofStepUnified","subproof","getSubproof","snapshot","subproofUnified","unifySubproof","statementUnified","unifyStatement","resolve","context","continue","rollback","supposition","suppositionString","statementString","trace","debug","subproofString","suppositionStatement","suppositionStatementString","subproofAssertion","subproofAssertionFromStatement","verify","verified","stated","assignments","statementVerified","assignmentsAssigned","assignAssignments","ProofStep","dom","fromStatement","addProofStep","toJSON","statementJSON","statementToStatementJSON","json","fromJSON","fileContext","statementFromJSON","fromSuppositionNode","suppositionNode","Statement","name"],"mappings":"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"}