occam-verify-cli 1.0.421 → 1.0.427

package/lib/element/statement.js

@@ -0,0 +1,386 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _necessary = require("necessary");
+var _verify = /*#__PURE__*/ _interop_require_default(require("../mixins/statement/verify"));
+var _elements = require("../elements");
+var _unify = require("../process/unify");
+var _instantiate = require("../process/instantiate");
+var _metaTypeNames = require("../metaTypeNames");
+var _brackets = require("../utilities/brackets");
+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
+    };
+}
+var _Statement;
+var match = _necessary.arrayUtilities.match, backwardsSome = _necessary.arrayUtilities.backwardsSome;
+var _default = (0, _elements.define)((_Statement = /*#__PURE__*/ function() {
+    function Statement(context, string, node) {
+        _class_call_check(this, Statement);
+        this.context = context;
+        this.string = string;
+        this.node = node;
+    }
+    _create_class(Statement, [
+        {
+            key: "getContext",
+            value: function getContext() {
+                return this.context;
+            }
+        },
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getNode",
+            value: function getNode() {
+                return this.node;
+            }
+        },
+        {
+            key: "getMetavariableName",
+            value: function getMetavariableName() {
+                var metavariableName = null;
+                var singular = this.isSingular();
+                if (singular) {
+                    metavariableName = this.node.getMetavariableName();
+                }
+                return metavariableName;
+            }
+        },
+        {
+            key: "isSingular",
+            value: function isSingular() {
+                return this.node.isSingular();
+            }
+        },
+        {
+            key: "isEqualTo",
+            value: function isEqualTo(statement) {
+                var statementNode = statement.getNode(), matches = this.node.match(statementNode), equalTo = matches; ///
+                return equalTo;
+            }
+        },
+        {
+            key: "isTermContained",
+            value: function isTermContained(term, context) {
+                var termContained;
+                var termString = term.getString(), statementString = this.string; ///
+                context.trace("Is the '".concat(termString, "' term contained in the '").concat(statementString, "' statement..."), this.node);
+                var termNode = term.getNode(), statementNode = this.node, statementNodeTermNodes = statementNode.getTermNodes();
+                termContained = statementNodeTermNodes.some(function(statementNodeTermNode) {
+                    var termNodeMatchesStatementNodeTermNode = termNode.match(statementNodeTermNode);
+                    if (termNodeMatchesStatementNodeTermNode) {
+                        return true;
+                    }
+                });
+                if (termContained) {
+                    context.debug("...the '".concat(termString, "' term is contained in the '").concat(statementString, "' statement."), this.node);
+                }
+                return termContained;
+            }
+        },
+        {
+            key: "isFrameContained",
+            value: function isFrameContained(frame, context) {
+                var frameContained;
+                var frameString = frame.getString(), statementString = this.string; ///
+                context.trace("Is the '".concat(frameString, "' frame contained in the '").concat(statementString, "' statement..."), this.node);
+                var frameNode = frame.getNode(), statementNode = this.node, statementNodeFrameNodes = statementNode.getFrameNodes();
+                frameContained = statementNodeFrameNodes.some(function(statementNodeFrameNode) {
+                    var frameNodeMatchesStatementNodeFrameNode = frameNode.match(statementNodeFrameNode);
+                    if (frameNodeMatchesStatementNodeFrameNode) {
+                        return true;
+                    }
+                });
+                if (frameContained) {
+                    context.debug("...the '".concat(frameString, "' frame is contained in the '").concat(statementString, "' statement."), this.node);
+                }
+                return frameContained;
+            }
+        },
+        {
+            key: "isMetavariableEqualToMetavariable",
+            value: function isMetavariableEqualToMetavariable(metavariable, context) {
+                var metavariableEqualToMetavariable;
+                var singular = this.isSingular();
+                if (singular) {
+                    var metavariableA = metavariable, singularMetavariableNode = this.node.getSingularMetavariableNode(), metavariableName = singularMetavariableNode.getMetavariableName();
+                    metavariable = context.findMetavariableByMetavariableName(metavariableName);
+                    var metavariableB = metavariable, equalTo = metavariableA.isEqualTo(metavariableB);
+                    metavariableEqualToMetavariable = equalTo; ///
+                }
+                return metavariableEqualToMetavariable;
+            }
+        },
+        {
+            key: "matchStatementNode",
+            value: function matchStatementNode(statementNode) {
+                return this.node.match(statementNode);
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(assignments, stated, context) {
+                var _this = this;
+                var verifies;
+                var statementString = this.string; ///
+                context.trace("Verifying the '".concat(statementString, "' statement..."), this.node);
+                verifies = _verify.default.some(function(verifyMixin) {
+                    var statement = _this, verifies = verifyMixin(statement, assignments, stated, context);
+                    if (verifies) {
+                        return true;
+                    }
+                });
+                if (verifies) {
+                    var statement = this; ///
+                    context.addStatement(statement);
+                    context.debug("...verified the '".concat(statementString, "' statement."), this.node);
+                }
+                return verifies;
+            }
+        },
+        {
+            key: "verifyGivenMetaType",
+            value: function verifyGivenMetaType(metaType, assignments, stated, context) {
+                var verifiesGivenMetaType = false;
+                var metaTypeString = metaType.getString(), statementString = this.string; ///
+                context.trace("Verifying the '".concat(statementString, "' statement given the '").concat(metaTypeString, "' meta-type..."), this.node);
+                var metaTypeName = metaType.getName();
+                if (metaTypeName === _metaTypeNames.STATEMENT_META_TYPE_NAME) {
+                    var verifies = this.verify(assignments, stated, context);
+                    verifiesGivenMetaType = verifies; ///
+                }
+                if (verifiesGivenMetaType) {
+                    context.debug("...verified the '".concat(statementString, "' statement given the '").concat(metaTypeString, "' meta-type."), this.node);
+                }
+                return verifiesGivenMetaType;
+            }
+        },
+        {
+            key: "unifySubproof",
+            value: function unifySubproof(subproof, substitutions, generalContext, specificContext) {
+                var subproofUnifies = false;
+                var context = specificContext, statementNode = this.node, subproofAssertionNode = statementNode.getSubproofAssertionNode(), assertionNode = subproofAssertionNode; ///
+                if (assertionNode !== null) {
+                    var assertion = generalContext.findAssertionByAssertionNode(assertionNode), subproofAssertion = assertion; ///
+                    var subproofString = subproof.getString(), subproofAssertionString = subproofAssertion.getString();
+                    context.trace("Unifying the '".concat(subproofString, "' subproof with the '").concat(subproofAssertionString, "' subproof assertion..."));
+                    var subproofStatements = subproof.getStatements(), subproofAssertionStatements = subproofAssertion.getStatements();
+                    subproofUnifies = match(subproofAssertionStatements, subproofStatements, function(subproofAssertionStatement, subproofStatement) {
+                        var generalStatement = subproofAssertionStatement, specificStatement = subproofStatement, statementUnifies = (0, _unify.unifyStatement)(generalStatement, specificStatement, substitutions, generalContext, specificContext);
+                        if (statementUnifies) {
+                            return true;
+                        }
+                    });
+                    if (subproofUnifies) {
+                        context.debug("...unified the '".concat(subproofString, "' subproof with the '").concat(subproofAssertionString, "' subproof assertion."));
+                    }
+                }
+                return subproofUnifies;
+            }
+        },
+        {
+            key: "unifyStatement",
+            value: function unifyStatement(statement, substitutions, generalContext, specificContext) {
+                var statementUnifies;
+                var generalStatement = this, specificStatement = statement, generalStatementString = generalStatement.getString(), specificStatementString = specificStatement.getString();
+                specificContext.trace("Unifying the '".concat(specificStatementString, "' statement with the '").concat(generalStatementString, "' statement..."));
+                statementUnifies = (0, _unify.unifyStatement)(generalStatement, specificStatement, substitutions, generalContext, specificContext);
+                if (statementUnifies) {
+                    specificContext.debug("...unified the '".concat(specificStatementString, "' statement with the '").concat(generalStatementString, "' statement."));
+                }
+                return statementUnifies;
+            }
+        },
+        {
+            key: "unifyIndependently",
+            value: function unifyIndependently(substitutions, generalContext, specificContext) {
+                var unifiesIndependently = false;
+                var context = specificContext, statementString = this.string; ///
+                context.trace("Unifying the '".concat(statementString, "' statement independently..."));
+                var statementNode = this.node, definedAssertionNode = statementNode.getDefinedAssertionNode(), containedAssertionNode = statementNode.getContainedAssertionNode();
+                if (definedAssertionNode !== null || containedAssertionNode !== null) {
+                    var assertionNode = definedAssertionNode || containedAssertionNode, assertion = generalContext.findAssertionByAssertionNode(assertionNode), assertionUnifiesIndependently = assertion.unifyIndependently(substitutions, generalContext, specificContext);
+                    if (assertionUnifiesIndependently) {
+                        unifiesIndependently = true;
+                    }
+                }
+                if (unifiesIndependently) {
+                    context.debug("...unified the '".concat(statementString, "' statement independently."));
+                }
+                return unifiesIndependently;
+            }
+        },
+        {
+            key: "equateWithStepsOrSubproofs",
+            value: function equateWithStepsOrSubproofs(stepsOrSubproofs, context) {
+                var _this = this;
+                var equatesWithStepsOrSubproofs;
+                equatesWithStepsOrSubproofs = backwardsSome(stepsOrSubproofs, function(stepOrSubproof) {
+                    var statement = _this, statementUnifies = stepOrSubproof.equateWithStatement(statement, context);
+                    if (statementUnifies) {
+                        return true;
+                    }
+                });
+                return equatesWithStepsOrSubproofs;
+            }
+        },
+        {
+            key: "toJSON",
+            value: function toJSON() {
+                var string = this.string, json = {
+                    string: string
+                };
+                return json;
+            }
+        }
+    ], [
+        {
+            key: "fromJSON",
+            value: function fromJSON(json, context) {
+                var string = json.string, statmentNode = (0, _instantiate.instantiateStatement)(string, context), node = statmentNode, statement = new Statement(string, node);
+                return statement;
+            }
+        },
+        {
+            key: "fromStepNode",
+            value: function fromStepNode(stepNode, context) {
+                var statement = null;
+                var statementNode = stepNode.getStatementNode();
+                if (statementNode !== null) {
+                    statement = statementFromStatementNode(statementNode, context);
+                }
+                return statement;
+            }
+        },
+        {
+            key: "fromPremiseNode",
+            value: function fromPremiseNode(premiseNode, context) {
+                var statement = null;
+                var statementNode = premiseNode.getStatementNode();
+                if (statementNode !== null) {
+                    statement = statementFromStatementNode(statementNode, context);
+                }
+                return statement;
+            }
+        },
+        {
+            key: "fromStatementNode",
+            value: function fromStatementNode(statementNode, context) {
+                var statement = statementFromStatementNode(statementNode, context);
+                return statement;
+            }
+        },
+        {
+            key: "fromDeductionNode",
+            value: function fromDeductionNode(deductionNode, context) {
+                var statement = null;
+                var statementNode = deductionNode.getStatementNode();
+                if (statementNode !== null) {
+                    statement = statementFromStatementNode(statementNode, context);
+                }
+                return statement;
+            }
+        },
+        {
+            key: "fromHypothesisNode",
+            value: function fromHypothesisNode(hypothesisNode, context) {
+                var statement = null;
+                var statementNode = hypothesisNode.getStatementNode();
+                if (statementNode !== null) {
+                    statement = statementFromStatementNode(statementNode, context);
+                }
+                return statement;
+            }
+        },
+        {
+            key: "fromConclusionNode",
+            value: function fromConclusionNode(conclusionNode, context) {
+                var statement = null;
+                var statementNode = conclusionNode.getStatementNode();
+                if (statementNode !== null) {
+                    statement = statementFromStatementNode(statementNode, context);
+                }
+                return statement;
+            }
+        },
+        {
+            key: "fromAssumptionNode",
+            value: function fromAssumptionNode(assumptionNode, context) {
+                var statement = null;
+                var statementNode;
+                statementNode = assumptionNode.getStatementNode(); ///
+                if (statementNode !== null) {
+                    statementNode = (0, _brackets.stripBracketsFromStatementNode)(statementNode); ///
+                    statement = statementFromStatementNode(statementNode, context);
+                }
+                return statement;
+            }
+        },
+        {
+            key: "fromSuppositionNode",
+            value: function fromSuppositionNode(suppositionNode, context) {
+                var statement = null;
+                var statementNode = suppositionNode.getStatementNode();
+                if (statementNode !== null) {
+                    statement = statementFromStatementNode(statementNode, context);
+                }
+                return statement;
+            }
+        },
+        {
+            key: "fromCombinatorDeclarationNode",
+            value: function fromCombinatorDeclarationNode(combinatorDeclarationNode, context) {
+                var statementNode = combinatorDeclarationNode.getStatementNode(), statement = statementFromStatementNode(statementNode, context);
+                return statement;
+            }
+        }
+    ]);
+    return Statement;
+}(), _define_property(_Statement, "name", "Statement"), _Statement));
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/element/statement.js"],"sourcesContent":["\"use strict\";\n\nimport { arrayUtilities } from \"necessary\";\n\nimport verifyMixins from \"../mixins/statement/verify\";\n\nimport { define } from \"../elements\";\nimport { unifyStatement } from \"../process/unify\";\nimport { instantiateStatement } from \"../process/instantiate\";\nimport { STATEMENT_META_TYPE_NAME } from \"../metaTypeNames\";\nimport { stripBracketsFromStatementNode } from \"../utilities/brackets\";\n\nconst { match, backwardsSome } = arrayUtilities;\n\nexport default define(class Statement {\n  constructor(context, string, node) {\n    this.context = context;\n    this.string = string;\n    this.node = node;\n  }\n\n  getContext() {\n    return this.context;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getNode() {\n    return this.node;\n  }\n\n  getMetavariableName() {\n    let metavariableName = null;\n\n    const singular = this.isSingular();\n\n    if (singular) {\n      metavariableName = this.node.getMetavariableName();\n    }\n\n    return metavariableName;\n  }\n\n  isSingular() { return this.node.isSingular(); }\n\n  isEqualTo(statement) {\n    const statementNode = statement.getNode(),\n          matches = this.node.match(statementNode),\n          equalTo = matches;  ///\n\n    return equalTo;\n  }\n\n  isTermContained(term, context) {\n    let termContained;\n\n    const termString = term.getString(),\n          statementString = this.string;  ///\n\n    context.trace(`Is the '${termString}' term contained in the '${statementString}' statement...`, this.node);\n\n    const termNode = term.getNode(),\n          statementNode = this.node,\n          statementNodeTermNodes = statementNode.getTermNodes();\n\n    termContained = statementNodeTermNodes.some((statementNodeTermNode) => {  ///\n      const termNodeMatchesStatementNodeTermNode = termNode.match(statementNodeTermNode);\n\n      if (termNodeMatchesStatementNodeTermNode) {\n        return true;\n      }\n    });\n\n    if (termContained) {\n      context.debug(`...the '${termString}' term is contained in the '${statementString}' statement.`, this.node);\n    }\n\n    return termContained;\n  }\n\n  isFrameContained(frame, context) {\n    let frameContained;\n\n    const frameString = frame.getString(),\n          statementString = this.string;  ///\n\n    context.trace(`Is the '${frameString}' frame contained in the '${statementString}' statement...`, this.node);\n\n    const frameNode = frame.getNode(),\n          statementNode = this.node,\n          statementNodeFrameNodes = statementNode.getFrameNodes();\n\n    frameContained = statementNodeFrameNodes.some((statementNodeFrameNode) => {  ///\n      const frameNodeMatchesStatementNodeFrameNode = frameNode.match(statementNodeFrameNode);\n\n      if (frameNodeMatchesStatementNodeFrameNode) {\n        return true;\n      }\n    });\n\n    if (frameContained) {\n      context.debug(`...the '${frameString}' frame is contained in the '${statementString}' statement.`, this.node);\n    }\n\n    return frameContained;\n  }\n\n  isMetavariableEqualToMetavariable(metavariable, context) {\n    let metavariableEqualToMetavariable;\n\n    const singular = this.isSingular();\n\n    if (singular) {\n      const metavariableA = metavariable, ///\n            singularMetavariableNode = this.node.getSingularMetavariableNode(),\n            metavariableName = singularMetavariableNode.getMetavariableName();\n\n      metavariable = context.findMetavariableByMetavariableName(metavariableName)\n\n      const metavariableB = metavariable,\n            equalTo = metavariableA.isEqualTo(metavariableB);\n\n      metavariableEqualToMetavariable = equalTo;  ///\n    }\n\n    return metavariableEqualToMetavariable;\n  }\n\n  matchStatementNode(statementNode) { return this.node.match(statementNode); }\n\n  verify(assignments, stated, context) {\n    let verifies;\n\n    const statementString = this.string;  ///\n\n    context.trace(`Verifying the '${statementString}' statement...`, this.node);\n\n    verifies = verifyMixins.some((verifyMixin) => {\n      const statement = this, ///\n            verifies = verifyMixin(statement, assignments, stated, context);\n\n      if (verifies) {\n        return true;\n      }\n    });\n\n    if (verifies) {\n      const statement = this; ///\n\n      context.addStatement(statement);\n\n      context.debug(`...verified the '${statementString}' statement.`, this.node);\n    }\n\n    return verifies;\n  }\n\n  verifyGivenMetaType(metaType, assignments, stated, context) {\n    let verifiesGivenMetaType = false;\n\n    const metaTypeString = metaType.getString(),\n          statementString = this.string;  ///\n\n    context.trace(`Verifying the '${statementString}' statement given the '${metaTypeString}' meta-type...`, this.node);\n\n    const metaTypeName = metaType.getName();\n\n    if (metaTypeName === STATEMENT_META_TYPE_NAME) {\n      const verifies = this.verify(assignments, stated, context)\n\n      verifiesGivenMetaType = verifies; ///\n    }\n\n    if (verifiesGivenMetaType) {\n      context.debug(`...verified the '${statementString}' statement given the '${metaTypeString}' meta-type.`, this.node);\n    }\n\n    return verifiesGivenMetaType;\n  }\n\n  unifySubproof(subproof, substitutions, generalContext, specificContext) {\n    let subproofUnifies = false;\n\n    const context = specificContext,  ///\n          statementNode = this.node,\n          subproofAssertionNode = statementNode.getSubproofAssertionNode(),\n          assertionNode = subproofAssertionNode;  ///\n\n    if (assertionNode !== null) {\n      const assertion = generalContext.findAssertionByAssertionNode(assertionNode),\n            subproofAssertion = assertion;  ///\n\n      const subproofString = subproof.getString(),\n            subproofAssertionString = subproofAssertion.getString();\n\n      context.trace(`Unifying the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion...`);\n\n      const subproofStatements = subproof.getStatements(),\n            subproofAssertionStatements = subproofAssertion.getStatements();\n\n      subproofUnifies = match(subproofAssertionStatements, subproofStatements, (subproofAssertionStatement, subproofStatement) => {\n        const generalStatement = subproofAssertionStatement,  ///\n              specificStatement = subproofStatement,  ///\n              statementUnifies = unifyStatement(generalStatement, specificStatement, substitutions, generalContext, specificContext);\n\n        if (statementUnifies) {\n          return true;\n        }\n      });\n\n      if (subproofUnifies) {\n        context.debug(`...unified the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion.`);\n      }\n    }\n\n    return subproofUnifies;\n  }\n\n  unifyStatement(statement, substitutions, generalContext, specificContext) {\n    let statementUnifies;\n\n    const generalStatement = this,  ///\n          specificStatement = statement, ///\n          generalStatementString = generalStatement.getString(),\n          specificStatementString = specificStatement.getString();\n\n    specificContext.trace(`Unifying the '${specificStatementString}' statement with the '${generalStatementString}' statement...`);\n\n    statementUnifies = unifyStatement(generalStatement, specificStatement, substitutions, generalContext, specificContext);\n\n    if (statementUnifies) {\n      specificContext.debug(`...unified the '${specificStatementString}' statement with the '${generalStatementString}' statement.`);\n    }\n\n    return statementUnifies;\n  }\n\n  unifyIndependently(substitutions, generalContext, specificContext) {\n    let unifiesIndependently = false;\n\n    const context = specificContext,  ///\n          statementString = this.string;  ///\n\n    context.trace(`Unifying the '${statementString}' statement independently...`);\n\n    const statementNode = this.node,\n          definedAssertionNode = statementNode.getDefinedAssertionNode(),\n          containedAssertionNode = statementNode.getContainedAssertionNode();\n\n    if ((definedAssertionNode !== null) || (containedAssertionNode !== null)) {\n      const assertionNode = (definedAssertionNode || containedAssertionNode),\n            assertion = generalContext.findAssertionByAssertionNode(assertionNode),\n            assertionUnifiesIndependently = assertion.unifyIndependently(substitutions, generalContext, specificContext);\n\n      if (assertionUnifiesIndependently) {\n        unifiesIndependently = true;\n      }\n    }\n\n    if (unifiesIndependently) {\n      context.debug(`...unified the '${statementString}' statement independently.`);\n    }\n\n    return unifiesIndependently;\n  }\n\n  equateWithStepsOrSubproofs(stepsOrSubproofs, context) {\n    let equatesWithStepsOrSubproofs;\n\n    equatesWithStepsOrSubproofs = backwardsSome(stepsOrSubproofs, (stepOrSubproof) => {\n      const statement = this, ///\n            statementUnifies = stepOrSubproof.equateWithStatement(statement, context);\n\n      if (statementUnifies) {\n        return true;\n      }\n    });\n\n    return equatesWithStepsOrSubproofs;\n  }\n\n  toJSON() {\n    const string = this.string, ///\n          json = {\n            string\n          };\n\n    return json;\n  }\n\n  static name = \"Statement\";\n\n  static fromJSON(json, context) {\n    const { string } = json,\n          statmentNode = instantiateStatement(string, context),\n          node = statmentNode,  ///,\n          statement = new Statement(string, node);\n\n    return statement;\n  }\n\n  static fromStepNode(stepNode, context) {\n    let statement = null;\n\n    const statementNode = stepNode.getStatementNode();\n\n    if (statementNode !== null) {\n      statement = statementFromStatementNode(statementNode, context);\n    }\n\n    return statement;\n  }\n\n  static fromPremiseNode(premiseNode, context) {\n    let statement = null;\n\n    const statementNode = premiseNode.getStatementNode();\n\n    if (statementNode !== null) {\n      statement = statementFromStatementNode(statementNode, context);\n    }\n\n    return statement;\n  }\n\n  static fromStatementNode(statementNode, context) {\n    const statement = statementFromStatementNode(statementNode, context);\n\n    return statement;\n  }\n\n  static fromDeductionNode(deductionNode, context) {\n    let statement = null;\n\n    const statementNode = deductionNode.getStatementNode();\n\n    if (statementNode !== null) {\n      statement = statementFromStatementNode(statementNode, context);\n    }\n\n    return statement;\n  }\n\n  static fromHypothesisNode(hypothesisNode, context) {\n    let statement = null;\n\n    const statementNode = hypothesisNode.getStatementNode();\n\n    if (statementNode !== null) {\n      statement = statementFromStatementNode(statementNode, context);\n    }\n\n    return statement;\n  }\n\n  static fromConclusionNode(conclusionNode, context) {\n    let statement = null;\n\n    const statementNode = conclusionNode.getStatementNode();\n\n    if (statementNode !== null) {\n      statement = statementFromStatementNode(statementNode, context);\n    }\n\n    return statement;\n  }\n\n  static fromAssumptionNode(assumptionNode, context) {\n    let statement = null;\n\n    let statementNode;\n\n    statementNode = assumptionNode.getStatementNode(); ///\n\n    if (statementNode !== null) {\n      statementNode = stripBracketsFromStatementNode(statementNode);  ///\n\n      statement = statementFromStatementNode(statementNode, context);\n    }\n\n    return statement;\n  }\n\n  static fromSuppositionNode(suppositionNode, context) {\n    let statement = null;\n\n    const statementNode = suppositionNode.getStatementNode();\n\n    if (statementNode !== null) {\n      statement = statementFromStatementNode(statementNode, context);\n    }\n\n    return statement;\n  }\n\n  static fromCombinatorDeclarationNode(combinatorDeclarationNode, context) {\n    const statementNode = combinatorDeclarationNode.getStatementNode(),\n          statement = statementFromStatementNode(statementNode, context);\n\n    return statement;\n  }\n});\n"],"names":["match","arrayUtilities","backwardsSome","define","Statement","context","string","node","getContext","getString","getNode","getMetavariableName","metavariableName","singular","isSingular","isEqualTo","statement","statementNode","matches","equalTo","isTermContained","term","termContained","termString","statementString","trace","termNode","statementNodeTermNodes","getTermNodes","some","statementNodeTermNode","termNodeMatchesStatementNodeTermNode","debug","isFrameContained","frame","frameContained","frameString","frameNode","statementNodeFrameNodes","getFrameNodes","statementNodeFrameNode","frameNodeMatchesStatementNodeFrameNode","isMetavariableEqualToMetavariable","metavariable","metavariableEqualToMetavariable","metavariableA","singularMetavariableNode","getSingularMetavariableNode","findMetavariableByMetavariableName","metavariableB","matchStatementNode","verify","assignments","stated","verifies","verifyMixins","verifyMixin","addStatement","verifyGivenMetaType","metaType","verifiesGivenMetaType","metaTypeString","metaTypeName","getName","STATEMENT_META_TYPE_NAME","unifySubproof","subproof","substitutions","generalContext","specificContext","subproofUnifies","subproofAssertionNode","getSubproofAssertionNode","assertionNode","assertion","findAssertionByAssertionNode","subproofAssertion","subproofString","subproofAssertionString","subproofStatements","getStatements","subproofAssertionStatements","subproofAssertionStatement","subproofStatement","generalStatement","specificStatement","statementUnifies","unifyStatement","generalStatementString","specificStatementString","unifyIndependently","unifiesIndependently","definedAssertionNode","getDefinedAssertionNode","containedAssertionNode","getContainedAssertionNode","assertionUnifiesIndependently","equateWithStepsOrSubproofs","stepsOrSubproofs","equatesWithStepsOrSubproofs","stepOrSubproof","equateWithStatement","toJSON","json","fromJSON","statmentNode","instantiateStatement","fromStepNode","stepNode","getStatementNode","statementFromStatementNode","fromPremiseNode","premiseNode","fromStatementNode","fromDeductionNode","deductionNode","fromHypothesisNode","hypothesisNode","fromConclusionNode","conclusionNode","fromAssumptionNode","assumptionNode","stripBracketsFromStatementNode","fromSuppositionNode","suppositionNode","fromCombinatorDeclarationNode","combinatorDeclarationNode","name"],"mappings":"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"}