occam-verify-cli 0.0.1111 → 0.0.1112

package/lib/dom/premise.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 _Premise;
+var _default = (0, _dom.domAssigned)((_Premise = /*#__PURE__*/ function() {
+    function Premise(string, statement) {
+        _class_call_check(this, Premise);
+        this.string = string;
+        this.statement = statement;
+    }
+    _create_class(Premise, [
+        {
+            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 premise = this, premiseString = premise.getString(), statementString = statement.getString();
+                specificContext.trace("Unifying the '".concat(statementString, "' statement with the '").concat(premiseString, "' premise..."));
+                statementUnified = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
+                if (statementUnified) {
+                    specificContext.debug("...unified the '".concat(statementString, "' statement with the '").concat(premiseString, "' premise."));
+                }
+                return statementUnified;
+            }
+        },
+        {
+            key: "unifySubproof",
+            value: function unifySubproof(subproof, substitutions, generalContext, specificContext) {
+                var subproofUnified = false;
+                var premise = this, subproofString = subproof.getString(), premiseStatement = premise.getStatement(), premiseStatementString = premiseStatement.getString();
+                specificContext.trace("Unifying the '".concat(subproofString, "' subproof with the premise's '").concat(premiseStatementString, "' 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 premise's '").concat(premiseStatementString, "' statement."));
+                }
+                return subproofUnified;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(context) {
+                var verified = false;
+                var premiseString = this.string; ///
+                if (this.statement !== null) {
+                    context.trace("Verifying the '".concat(premiseString, "' premise..."));
+                    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(premiseString, "' premise."));
+                    }
+                } else {
+                    context.debug("Unable to verify the '".concat(premiseString, "' premise 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(), premise = new Premise(string, statement);
+                return premise;
+            }
+        },
+        {
+            key: "fromPremiseNode",
+            value: function fromPremiseNode(premiseNode, fileContext) {
+                var Statement = _dom.default.Statement, statement = Statement.fromPremiseNode(premiseNode, fileContext), statementString = statement.getString(), string = statementString, premise = new Premise(string, statement);
+                return premise;
+            }
+        }
+    ]);
+    return Premise;
+}(), _define_property(_Premise, "name", "Premise"), _Premise));
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/dom/premise.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 Premise {\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 premise = this, ///\n          premiseString = premise.getString(),\n          statementString = statement.getString();\n\n    specificContext.trace(`Unifying the '${statementString}' statement with the '${premiseString}' premise...`);\n\n    statementUnified = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);\n\n    if (statementUnified) {\n      specificContext.debug(`...unified the '${statementString}' statement with the '${premiseString}' premise.`);\n    }\n\n    return statementUnified;\n  }\n\n  unifySubproof(subproof, substitutions, generalContext, specificContext) {\n    let subproofUnified = false;\n\n    const premise = this, ///\n          subproofString = subproof.getString(),\n          premiseStatement = premise.getStatement(),\n          premiseStatementString = premiseStatement.getString();\n\n    specificContext.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' 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 premise's '${premiseStatementString}' statement.`);\n    }\n\n    return subproofUnified;\n  }\n\n  verify(context) {\n    let verified = false;\n\n    const premiseString = this.string; ///\n\n    if (this.statement !== null) {\n      context.trace(`Verifying the '${premiseString}' premise...`);\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 '${premiseString}' premise.`);\n      }\n    } else {\n      context.debug(`Unable to verify the '${premiseString}' premise 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 = \"Premise\";\n\n  static fromJSON(json, fileContext) {\n    const statement = statementFromJSON(json, fileContext),\n          string = statement.getString(),\n          premise = new Premise(string, statement);\n\n    return premise;\n  }\n\n  static fromPremiseNode(premiseNode, fileContext) {\n    const { Statement } = dom,\n          statement = Statement.fromPremiseNode(premiseNode, fileContext),\n          statementString = statement.getString(),\n          string = statementString, ///\n          premise = new Premise(string, statement);\n\n    return premise\n  }\n});\n"],"names":["domAssigned","Premise","string","statement","getString","getStatement","unifyIndependently","substitutions","generalContext","specificContext","unifiedIndependently","statementResolvedIndependently","unifyProofStep","proofStep","proofStepUnified","subproof","getSubproof","snapshot","subproofUnified","unifySubproof","statementUnified","unifyStatement","resolve","context","continue","rollback","premise","premiseString","statementString","trace","debug","subproofString","premiseStatement","premiseStatementString","subproofAssertion","subproofAssertionFromStatement","verify","verified","stated","assignments","statementVerified","assignmentsAssigned","assignAssignments","ProofStep","dom","fromStatement","addProofStep","toJSON","statementJSON","statementToStatementJSON","json","fromJSON","fileContext","statementFromJSON","fromPremiseNode","premiseNode","Statement","name"],"mappings":"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"}

package/lib/dom/proof.js

@@ -0,0 +1,154 @@
+"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");
+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;
+}
+var _Proof;
+var derivationNodeQuery = (0, _query.nodeQuery)("/proof/derivation");
+var _default = (0, _dom.domAssigned)((_Proof = /*#__PURE__*/ function() {
+    function Proof(derivation) {
+        _class_call_check(this, Proof);
+        this.derivation = derivation;
+    }
+    _create_class(Proof, [
+        {
+            key: "getDerivation",
+            value: function getDerivation() {
+                return this.derivation;
+            }
+        },
+        {
+            key: "getLastProofStep",
+            value: function getLastProofStep() {
+                return this.derivation.getLastProofStep();
+            }
+        },
+        {
+            key: "getStatement",
+            value: function getStatement() {
+                var lastProofStep = this.getLastProofStep(), lastProofStepStatement = lastProofStep.getStatement(), statement = lastProofStepStatement; ///
+                return statement;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(substitutions, conclusion, context) {
+                var verified = false;
+                var localContext = _local.default.fromContext(context); ///
+                context = localContext; ///
+                var derivationVerified = this.derivation.verify(substitutions, context);
+                if (derivationVerified) {
+                    var lastProofStep = context.getLastProofStep();
+                    if (lastProofStep !== null) {
+                        var statement = this.getStatement(), conclusionStatement = conclusion.getStatement(), conclusionStatementEqualToStatement = conclusionStatement.isEqualTo(statement);
+                        if (conclusionStatementEqualToStatement) {
+                            verified = true;
+                        }
+                    }
+                }
+                return verified;
+            }
+        }
+    ], [
+        {
+            key: "fromProofNode",
+            value: function fromProofNode(proofNode, fileContext) {
+                var proof = null;
+                if (proofNode !== null) {
+                    var Derivation = _dom.default.Derivation, derivationNode = derivationNodeQuery(proofNode), derivation = Derivation.fromDerivationNode(derivationNode, fileContext);
+                    proof = new Proof(derivation);
+                }
+                return proof;
+            }
+        }
+    ]);
+    return Proof;
+}(), _define_property(_Proof, "name", "Proof"), _Proof));
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/dom/proofStep.js

@@ -0,0 +1,239 @@
+"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 _unify = /*#__PURE__*/ _interop_require_default(require("../mixins/proofStep/unify"));
+var _substitutions = /*#__PURE__*/ _interop_require_default(require("../substitutions"));
+var _assignments = require("../utilities/assignments");
+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;
+}
+var _ProofStep;
+var _default = (0, _dom.domAssigned)((_ProofStep = /*#__PURE__*/ function() {
+    function ProofStep(string, subproof, statement, reference) {
+        _class_call_check(this, ProofStep);
+        this.string = string;
+        this.subproof = subproof;
+        this.statement = statement;
+        this.reference = reference;
+    }
+    _create_class(ProofStep, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getSubproof",
+            value: function getSubproof() {
+                return this.subproof;
+            }
+        },
+        {
+            key: "getStatement",
+            value: function getStatement() {
+                return this.statement;
+            }
+        },
+        {
+            key: "getReference",
+            value: function getReference() {
+                return this.reference;
+            }
+        },
+        {
+            key: "isQualified",
+            value: function isQualified() {
+                var qualified = this.reference !== null;
+                return qualified;
+            }
+        },
+        {
+            key: "unify",
+            value: function unify(substitutions, context) {
+                var _this = this;
+                var unified;
+                if (this.subproof !== null) {
+                    unified = true; ///
+                }
+                if (this.statement !== null) {
+                    var proofStepString = this.string; ///
+                    context.trace("Unifying the '".concat(proofStepString, "' proof step..."));
+                    unified = _unify.default.some(function(unifyMixin) {
+                        var unified = unifyMixin(_this.statement, _this.reference, substitutions, context);
+                        if (unified) {
+                            return true;
+                        }
+                    });
+                    if (unified) {
+                        context.debug("...unified the '".concat(proofStepString, "' proof step."));
+                    }
+                }
+                return unified;
+            }
+        },
+        {
+            key: "unifyStatement",
+            value: function unifyStatement(statement, context) {
+                var statementUnified;
+                var specificContext = context, generalContext = context, substitutions = _substitutions.default.fromNothing();
+                if (this.subproof !== null) {
+                    var subproofUnified = statement.unifySubproof(this.subproof, substitutions, generalContext, specificContext);
+                    statementUnified = subproofUnified; ///
+                }
+                if (this.statement !== null) {
+                    statementUnified = statement.unifyStatement(this.statement, substitutions, generalContext, specificContext);
+                }
+                if (statementUnified) {
+                    var equivalences = context.getEquivalences(), substitutionsUnified = equivalences.unifySubstitutions(substitutions);
+                    statementUnified = substitutionsUnified; ///
+                }
+                return statementUnified;
+            }
+        },
+        {
+            key: "verifyAndUnify",
+            value: function verifyAndUnify(substitutions, context) {
+                var verifiedAndUnified = false;
+                var assignments = [], verified = this.verify(substitutions, assignments, context);
+                if (verified) {
+                    var unified = this.unify(substitutions, context);
+                    if (unified) {
+                        var proofStep = this; ///
+                        (0, _assignments.assignAssignments)(assignments, context);
+                        context.addProofStep(proofStep);
+                    }
+                    verifiedAndUnified = unified; ///
+                }
+                return verifiedAndUnified;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(substitutions, assignments, context) {
+                var verified = false;
+                if (false) {
+                ///
+                } else if (this.subproof !== null) {
+                    var subproofVerified = this.subproof.verify(substitutions, context);
+                    verified = subproofVerified; ///
+                } else if (this.statement !== null) {
+                    var qualified = this.isQualified(), stated = qualified, statementVerified = this.statement.verify(assignments, stated, context);
+                    if (statementVerified) {
+                        if (this.reference === null) {
+                            verified = true;
+                        } else {
+                            var referenceVerified = this.reference.verify(context);
+                            verified = referenceVerified; ///
+                        }
+                    }
+                } else {
+                    var proofStepString = this.string;
+                    context.debug("Cannot verify the '".concat(proofStepString, "' proof step because it is nonsense."));
+                }
+                return verified;
+            }
+        }
+    ], [
+        {
+            key: "fromStatement",
+            value: function fromStatement(statement, context) {
+                var statementString = statement.getString(), string = statementString, subproof = null, reference = null, proofStep = new ProofStep(string, subproof, statement, reference);
+                return proofStep;
+            }
+        },
+        {
+            key: "fromProofStepNode",
+            value: function fromProofStepNode(proofStepNode, fileContext) {
+                var Subproof = _dom.default.Subproof, Statement = _dom.default.Statement, Reference = _dom.default.Reference, node = proofStepNode, string = fileContext.nodeAsString(node), subproof = Subproof.fromProofStepNode(proofStepNode, fileContext), statement = Statement.fromProofStepNode(proofStepNode, fileContext), reference = Reference.fromProofStepNode(proofStepNode, fileContext), proofStep = new ProofStep(string, subproof, statement, reference);
+                return proofStep;
+            }
+        }
+    ]);
+    return ProofStep;
+}(), _define_property(_ProofStep, "name", "ProofStep"), _ProofStep));
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/dom/proofStep.js"],"sourcesContent":["\"use strict\";\n\nimport dom from \"../dom\";\nimport unifyMixins from \"../mixins/proofStep/unify\";\nimport Substitutions from \"../substitutions\";\n\nimport { domAssigned } from \"../dom\";\nimport { assignAssignments } from \"../utilities/assignments\";\n\nexport default domAssigned(class ProofStep {\n  constructor(string, subproof, statement, reference) {\n    this.string = string;\n    this.subproof = subproof;\n    this.statement = statement;\n    this.reference = reference;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getSubproof() {\n    return this.subproof;\n  }\n\n  getStatement() {\n    return this.statement;\n  }\n\n  getReference() {\n    return this.reference;\n  }\n\n  isQualified() {\n    const qualified = (this.reference !== null);\n\n    return qualified;\n  }\n\n  unify(substitutions, context) {\n    let unified;\n\n    if (this.subproof !== null) {\n      unified = true; ///\n    }\n\n    if (this.statement !== null) {\n      const proofStepString = this.string;  ///\n\n      context.trace(`Unifying the '${proofStepString}' proof step...`);\n\n      unified = unifyMixins.some((unifyMixin) => {\n        const unified = unifyMixin(this.statement, this.reference, substitutions, context);\n\n        if (unified) {\n          return true;\n        }\n      });\n\n      if (unified) {\n        context.debug(`...unified the '${proofStepString}' proof step.`);\n      }\n    }\n\n    return unified;\n  }\n\n  unifyStatement(statement, context) {\n    let statementUnified;\n\n    const specificContext = context, ///\n          generalContext = context, ///\n          substitutions = Substitutions.fromNothing();\n\n    if (this.subproof !== null) {\n      const subproofUnified = statement.unifySubproof(this.subproof, substitutions, generalContext, specificContext);\n\n      statementUnified = subproofUnified; ///\n    }\n\n    if (this.statement !== null) {\n      statementUnified = statement.unifyStatement(this.statement, substitutions, generalContext, specificContext);\n    }\n\n    if (statementUnified) {\n      const equivalences = context.getEquivalences(),\n            substitutionsUnified = equivalences.unifySubstitutions(substitutions);\n\n      statementUnified = substitutionsUnified;  ///\n    }\n\n    return statementUnified;\n  }\n\n  verifyAndUnify(substitutions, context) {\n    let verifiedAndUnified = false;\n\n    const assignments = [],\n          verified = this.verify(substitutions, assignments, context);\n\n    if (verified) {\n      const unified = this.unify(substitutions, context);\n\n      if (unified) {\n        const proofStep = this; ///\n\n        assignAssignments(assignments, context);\n\n        context.addProofStep(proofStep);\n      }\n\n      verifiedAndUnified = unified; ///\n    }\n\n    return verifiedAndUnified;\n  }\n\n  verify(substitutions, assignments, context) {\n    let verified = false;\n\n    if (false) {\n      ///\n    } else if (this.subproof !== null) {\n      const subproofVerified = this.subproof.verify(substitutions, context);\n\n      verified = subproofVerified;  ///\n    } else if (this.statement !== null) {\n      const qualified = this.isQualified(),\n            stated = qualified, ///\n            statementVerified = this.statement.verify(assignments, stated, context);\n\n      if (statementVerified) {\n        if (this.reference === null) {\n          verified = true;\n        } else {\n          const referenceVerified = this.reference.verify(context);\n\n          verified = referenceVerified; ///\n        }\n      }\n    } else {\n      const proofStepString = this.string;\n\n      context.debug(`Cannot verify the '${proofStepString}' proof step because it is nonsense.`);\n    }\n\n    return verified;\n  }\n\n  static name = \"ProofStep\";\n\n  static fromStatement(statement, context) {\n    const statementString = statement.getString(),\n          string = statementString, ///\n          subproof = null,\n          reference = null,\n          proofStep = new ProofStep(string, subproof, statement, reference);\n\n    return proofStep;\n  }\n\n  static fromProofStepNode(proofStepNode, fileContext) {\n    const { Subproof, Statement, Reference } = dom,\n          node = proofStepNode, ///\n          string = fileContext.nodeAsString(node),\n          subproof = Subproof.fromProofStepNode(proofStepNode, fileContext),\n          statement = Statement.fromProofStepNode(proofStepNode, fileContext),\n          reference = Reference.fromProofStepNode(proofStepNode, fileContext),\n          proofStep = new ProofStep(string, subproof, statement, reference);\n\n    return proofStep;\n  }\n});\n"],"names":["domAssigned","ProofStep","string","subproof","statement","reference","getString","getSubproof","getStatement","getReference","isQualified","qualified","unify","substitutions","context","unified","proofStepString","trace","unifyMixins","some","unifyMixin","debug","unifyStatement","statementUnified","specificContext","generalContext","Substitutions","fromNothing","subproofUnified","unifySubproof","equivalences","getEquivalences","substitutionsUnified","unifySubstitutions","verifyAndUnify","verifiedAndUnified","assignments","verified","verify","proofStep","assignAssignments","addProofStep","subproofVerified","stated","statementVerified","referenceVerified","fromStatement","statementString","fromProofStepNode","proofStepNode","fileContext","Subproof","dom","Statement","Reference","node","nodeAsString","name"],"mappings":"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"}