occam-verify-cli 1.0.382 → 1.0.385

package/lib/ontology/assertion/satisfies.js

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _ontology = /*#__PURE__*/ _interop_require_wildcard(require("../../ontology"));
+var _substitutions = /*#__PURE__*/ _interop_require_default(require("../../substitutions"));
+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 _SatisfiesAssertion;
+var _default = (0, _ontology.define)((_SatisfiesAssertion = /*#__PURE__*/ function() {
+    function SatisfiesAssertion(string, node, tokens, signature, reference) {
+        _class_call_check(this, SatisfiesAssertion);
+        this.string = string;
+        this.node = node;
+        this.tokens = tokens;
+        this.signature = signature;
+        this.reference = reference;
+    }
+    _create_class(SatisfiesAssertion, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getNode",
+            value: function getNode() {
+                return this.node;
+            }
+        },
+        {
+            key: "getTokens",
+            value: function getTokens() {
+                return this.tokens;
+            }
+        },
+        {
+            key: "getSignature",
+            value: function getSignature() {
+                return this.signature;
+            }
+        },
+        {
+            key: "getReference",
+            value: function getReference() {
+                return this.reference;
+            }
+        },
+        {
+            key: "compareSubstitutions",
+            value: function compareSubstitutions(substitutions, context) {
+                return this.signature.compareSubstitutions(substitutions, context);
+            }
+        },
+        {
+            key: "correlateSubstitutions",
+            value: function correlateSubstitutions(substitutions, context) {
+                return this.signature.correlateSubstitutions(substitutions, context);
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(assignments, stated, context) {
+                var verifies = false;
+                var satisfiesAssertionString = this.string; ///
+                context.trace("Verifying the '".concat(satisfiesAssertionString, "' satisfies assertion..."));
+                var signatureVerifies = this.verifySignature(assignments, stated, context);
+                if (signatureVerifies) {
+                    var referenceVerifies = this.verifyReference(assignments, stated, context);
+                    verifies = referenceVerifies; ///
+                }
+                if (verifies) {
+                    context.debug("...verified the '".concat(satisfiesAssertionString, "' satisfies assertion."));
+                }
+                return verifies;
+            }
+        },
+        {
+            key: "verifySignature",
+            value: function verifySignature(assignments, stated, context) {
+                var signatureVerifies = this.signature.verify(context);
+                return signatureVerifies;
+            }
+        },
+        {
+            key: "verifyReference",
+            value: function verifyReference(assignments, stated, context) {
+                var referenceVerifies = false;
+                var referenceString = this.reference.getString();
+                context.trace("Verifying the '".concat(referenceString, "' reference..."));
+                var axiom = context.findAxiomByReference(this.reference, context);
+                if (axiom !== null) {
+                    var axiomSatisfiable = axiom.isSatisfiable();
+                    if (axiomSatisfiable) {
+                        referenceVerifies = true;
+                    }
+                }
+                if (referenceVerifies) {
+                    context.debug("...verified the '".concat(referenceString, "' reference."));
+                }
+                return referenceVerifies;
+            }
+        },
+        {
+            key: "unifyStatementAndStepsOrSubproofs",
+            value: function unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, context) {
+                var statementUnifies = false;
+                var statementString = statement.getString(), satisfiesAssertionString = this.string; ///
+                context.trace("Unifying the '".concat(statementString, "' statement with the '").concat(satisfiesAssertionString, "' satisfies assertion..."));
+                this.signature.verify(context);
+                var axiom = context.findAxiomByReference(this.reference), satisfiable = axiom.isSatisfiable();
+                if (satisfiable) {
+                    var substitutions;
+                    substitutions = _substitutions.default.fromNothing();
+                    var signatureMatches = axiom.matchSignature(this.signature, substitutions, context);
+                    if (signatureMatches) {
+                        var substitutionsB = substitutions; ///
+                        substitutions = _substitutions.default.fromNothing();
+                        statementUnifies = axiom.unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, substitutions, context);
+                        if (statementUnifies) {
+                            var substitutionsA = substitutions, substitutionsMatch = substitutionsA.correlateSubstitutions(substitutionsB);
+                            if (!substitutionsMatch) {
+                                var substitutionsAString = substitutionsA.asString(), substitutionsBString = substitutionsB.asString();
+                                context.trace("THe signature's ".concat(substitutionsBString, " substitutions do not correlate with the unification's ").concat(substitutionsAString, " substitutions."));
+                                statementUnifies = false;
+                            }
+                        }
+                    }
+                }
+                if (statementUnifies) {
+                    context.debug("...unified the '".concat(statementString, "' statement with the '").concat(satisfiesAssertionString, "' satisfies assertion."));
+                }
+                return statementUnifies;
+            }
+        }
+    ], [
+        {
+            key: "fromStepNode",
+            value: function fromStepNode(stepNode, context) {
+                var satisfiesAssertion = null;
+                var satisfiesAssertionNode = stepNode.getSatisfiedAssertionNode();
+                if (satisfiesAssertionNode !== null) {
+                    satisfiesAssertion = satisfiesAssertionFromSatisfiesAssertionNode(satisfiesAssertionNode, context);
+                }
+                return satisfiesAssertion;
+            }
+        },
+        {
+            key: "fromStatementNode",
+            value: function fromStatementNode(statementNode, context) {
+                var satisfiesAssertion = null;
+                var satisfiesAssertionNode = statementNode.getSatisfiedAssertionNode();
+                if (satisfiesAssertionNode !== null) {
+                    satisfiesAssertion = satisfiesAssertionFromSatisfiesAssertionNode(satisfiesAssertionNode, context);
+                }
+                return satisfiesAssertion;
+            }
+        }
+    ]);
+    return SatisfiesAssertion;
+}(), _define_property(_SatisfiesAssertion, "name", "SatisfiesAssertion"), _SatisfiesAssertion));
+function signatureFromSatisfiesAssertionNode(satisfiesAssertionNode, context) {
+    var Signature = _ontology.default.Signature, signatureNode = satisfiesAssertionNode.getSignatureNode(), signature = Signature.fromSignatureNode(signatureNode, context);
+    return signature;
+}
+function satisfiesAssertionFromSatisfiesAssertionNode(satisfiesAssertionNode, context) {
+    var Reference = _ontology.default.Reference, SatisfiesAssertion = _ontology.default.SatisfiesAssertion, node = satisfiesAssertionNode, string = context.nodeAsString(node), tokens = context.nodeAsTokens(node), signature = signatureFromSatisfiesAssertionNode(satisfiesAssertionNode, context), reference = Reference.fromSatisfiesAssertionNode(satisfiesAssertionNode, context), satisfiesAssertion = new SatisfiesAssertion(string, node, tokens, signature, reference);
+    return satisfiesAssertion;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/ontology/assertion/satisfies.js"],"sourcesContent":["\"use strict\";\n\nimport ontology from \"../../ontology\";\n\nimport { define } from \"../../ontology\";\n\nimport Substitutions from \"../../substitutions\";\n\nexport default define(class SatisfiesAssertion {\n  constructor(string, node, tokens, signature, reference) {\n    this.string = string;\n    this.node = node;\n    this.tokens = tokens;\n    this.signature = signature;\n    this.reference = reference;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getNode() {\n    return this.node;\n  }\n\n  getTokens() {\n    return this.tokens;\n  }\n\n  getSignature() {\n    return this.signature;\n  }\n\n  getReference() {\n    return this.reference;\n  }\n\n  compareSubstitutions(substitutions, context) { return this.signature.compareSubstitutions(substitutions, context); }\n\n  correlateSubstitutions(substitutions, context) { return this.signature.correlateSubstitutions(substitutions, context); }\n\n  verify(assignments, stated, context) {\n    let verifies = false;\n\n    const satisfiesAssertionString = this.string; ///\n\n    context.trace(`Verifying the '${satisfiesAssertionString}' satisfies assertion...`);\n\n    const signatureVerifies = this.verifySignature(assignments, stated, context);\n\n    if (signatureVerifies) {\n      const referenceVerifies = this.verifyReference(assignments, stated, context);\n\n      verifies = referenceVerifies; ///\n    }\n\n    if (verifies) {\n      context.debug(`...verified the '${satisfiesAssertionString}' satisfies assertion.`);\n    }\n\n    return verifies;\n  }\n\n  verifySignature(assignments, stated, context) {\n    const signatureVerifies = this.signature.verify(context);\n\n    return signatureVerifies;\n  }\n\n  verifyReference(assignments, stated, context) {\n    let referenceVerifies = false;\n\n    const referenceString = this.reference.getString();\n\n    context.trace(`Verifying the '${referenceString}' reference...`);\n\n    const axiom = context.findAxiomByReference(this.reference, context);\n\n    if (axiom !== null) {\n      const axiomSatisfiable = axiom.isSatisfiable();\n\n      if (axiomSatisfiable) {\n        referenceVerifies = true;\n      }\n    }\n\n    if (referenceVerifies) {\n      context.debug(`...verified the '${referenceString}' reference.`);\n    }\n\n    return referenceVerifies;\n  }\n\n  unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, context) {\n    let statementUnifies = false;\n\n    const statementString = statement.getString(),\n          satisfiesAssertionString = this.string; ///\n\n    context.trace(`Unifying the '${statementString}' statement with the '${satisfiesAssertionString}' satisfies assertion...`);\n\n    this.signature.verify(context);\n\n    const axiom = context.findAxiomByReference(this.reference),\n          satisfiable = axiom.isSatisfiable();\n\n    if (satisfiable) {\n      let substitutions;\n\n      substitutions = Substitutions.fromNothing();\n\n      const signatureMatches = axiom.matchSignature(this.signature, substitutions, context);\n\n      if (signatureMatches) {\n        const substitutionsB = substitutions; ///\n\n        substitutions = Substitutions.fromNothing();\n\n        statementUnifies = axiom.unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, substitutions, context);\n\n        if (statementUnifies) {\n          const substitutionsA = substitutions, ///\n                substitutionsMatch = substitutionsA.correlateSubstitutions(substitutionsB);\n\n          if (!substitutionsMatch) {\n            const substitutionsAString = substitutionsA.asString(),\n                  substitutionsBString = substitutionsB.asString();\n\n            context.trace(`THe signature's ${substitutionsBString} substitutions do not correlate with the unification's ${substitutionsAString} substitutions.`);\n\n            statementUnifies = false;\n          }\n        }\n      }\n    }\n\n    if (statementUnifies) {\n      context.debug(`...unified the '${statementString}' statement with the '${satisfiesAssertionString}' satisfies assertion.`);\n    }\n\n    return statementUnifies;\n  }\n\n  static name = \"SatisfiesAssertion\";\n\n  static fromStepNode(stepNode, context) {\n    let satisfiesAssertion = null;\n\n    const satisfiesAssertionNode = stepNode.getSatisfiedAssertionNode();\n\n    if (satisfiesAssertionNode !== null) {\n      satisfiesAssertion = satisfiesAssertionFromSatisfiesAssertionNode(satisfiesAssertionNode, context);\n    }\n\n    return satisfiesAssertion;\n  }\n\n  static fromStatementNode(statementNode, context) {\n    let satisfiesAssertion = null;\n\n    const satisfiesAssertionNode = statementNode.getSatisfiedAssertionNode();\n\n    if (satisfiesAssertionNode !== null) {\n      satisfiesAssertion = satisfiesAssertionFromSatisfiesAssertionNode(satisfiesAssertionNode, context);\n    }\n\n    return satisfiesAssertion;\n  }\n});\n\nfunction signatureFromSatisfiesAssertionNode(satisfiesAssertionNode, context) {\n  const { Signature } = ontology,\n        signatureNode = satisfiesAssertionNode.getSignatureNode(),\n        signature = Signature.fromSignatureNode(signatureNode, context);\n\n  return signature;\n}\n\nfunction satisfiesAssertionFromSatisfiesAssertionNode(satisfiesAssertionNode, context) {\n  const { Reference, SatisfiesAssertion } = ontology,\n        node = satisfiesAssertionNode,  ///\n        string = context.nodeAsString(node),\n        tokens = context.nodeAsTokens(node),\n        signature = signatureFromSatisfiesAssertionNode(satisfiesAssertionNode, context),\n        reference = Reference.fromSatisfiesAssertionNode(satisfiesAssertionNode, context),\n        satisfiesAssertion = new SatisfiesAssertion(string, node, tokens, signature, reference);\n\n  return satisfiesAssertion;\n}\n"],"names":["define","SatisfiesAssertion","string","node","tokens","signature","reference","getString","getNode","getTokens","getSignature","getReference","compareSubstitutions","substitutions","context","correlateSubstitutions","verify","assignments","stated","verifies","satisfiesAssertionString","trace","signatureVerifies","verifySignature","referenceVerifies","verifyReference","debug","referenceString","axiom","findAxiomByReference","axiomSatisfiable","isSatisfiable","unifyStatementAndStepsOrSubproofs","statement","stepsOrSubproofs","statementUnifies","statementString","satisfiable","Substitutions","fromNothing","signatureMatches","matchSignature","substitutionsB","substitutionsA","substitutionsMatch","substitutionsAString","asString","substitutionsBString","fromStepNode","stepNode","satisfiesAssertion","satisfiesAssertionNode","getSatisfiedAssertionNode","satisfiesAssertionFromSatisfiesAssertionNode","fromStatementNode","statementNode","name","signatureFromSatisfiesAssertionNode","Signature","ontology","signatureNode","getSignatureNode","fromSignatureNode","Reference","nodeAsString","nodeAsTokens","fromSatisfiesAssertionNode"],"mappings":"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"}

package/lib/ontology/assertion/subproof.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _necessary = require("necessary");
+var _ontology = /*#__PURE__*/ _interop_require_wildcard(require("../../ontology"));
+var _unification = require("../../utilities/unification");
+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 _SubproofAssertion;
+var match = _necessary.arrayUtilities.match;
+var _default = (0, _ontology.define)((_SubproofAssertion = /*#__PURE__*/ function() {
+    function SubproofAssertion(string, node, statements) {
+        _class_call_check(this, SubproofAssertion);
+        this.string = string;
+        this.node = node;
+        this.statements = statements;
+    }
+    _create_class(SubproofAssertion, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getNode",
+            value: function getNode() {
+                return this.node;
+            }
+        },
+        {
+            key: "getStatements",
+            value: function getStatements() {
+                return this.statements;
+            }
+        },
+        {
+            key: "unifySubproof",
+            value: function unifySubproof(subproof, substitutions, generalContext, specificContext) {
+                var subproofUnifies;
+                var subproofString = subproof.getString(), subproofAssertionString = this.string; ///
+                specificContext.trace("Unifying the '".concat(subproofString, "' subproof with the '").concat(subproofAssertionString, "' subproof assertion..."));
+                var subproofStatements = subproof.getStatements(), subproofAssertionStatements = this.statements; ///
+                subproofUnifies = match(subproofAssertionStatements, subproofStatements, function(subproofAssertionStatement, subproofStatement) {
+                    var generalStatement = subproofAssertionStatement, specificStatement = subproofStatement, statementUnifies = (0, _unification.unifyStatement)(generalStatement, specificStatement, substitutions, generalContext, specificContext);
+                    if (statementUnifies) {
+                        return true;
+                    }
+                });
+                if (subproofUnifies) {
+                    specificContext.debug("...unified the '".concat(subproofString, "' subproof with the '").concat(subproofAssertionString, "' subproof assertion."));
+                }
+                return subproofUnifies;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(assignments, stated, context) {
+                var verifies;
+                var subproofAssertionString = this.string; ///
+                context.trace("Verifying the '".concat(subproofAssertionString, "' subproof assertion..."));
+                var statementsVerify = this.verifyStatements(assignments, stated, context);
+                verifies = statementsVerify; ///
+                if (verifies) {
+                    context.debug("...verified the '".concat(subproofAssertionString, "' subproof assertion."));
+                }
+                return verifies;
+            }
+        },
+        {
+            key: "verifyStatements",
+            value: function verifyStatements(assignments, stated, context) {
+                stated = true; ///
+                assignments = null; ///
+                var statementsVerify = this.statements.map(function(statement) {
+                    var statementVerifies = statement.verify(assignments, stated, context);
+                    if (statementVerifies) {
+                        return true;
+                    }
+                });
+                return statementsVerify;
+            }
+        }
+    ], [
+        {
+            key: "fromStatementNode",
+            value: function fromStatementNode(statementNode, context) {
+                var subproofAssertion = null;
+                var subproofAssertionNode = statementNode.getSubproofAssertionNode();
+                if (subproofAssertionNode !== null) {
+                    var node = subproofAssertionNode, string = context.nodeAsString(node), statements = statementsFromSubproofAssertionNode(subproofAssertionNode, context);
+                    subproofAssertion = new SubproofAssertion(string, node, statements);
+                }
+                return subproofAssertion;
+            }
+        }
+    ]);
+    return SubproofAssertion;
+}(), _define_property(_SubproofAssertion, "name", "SubproofAssertion"), _SubproofAssertion));
+function statementsFromSubproofAssertionNode(subproofAssertionNode, context) {
+    var Statement = _ontology.default.Statement, statementNodes = subproofAssertionNode.getStatementNodes(), statements = statementNodes.map(function(statementNode) {
+        var statement = Statement.fromStatementNode(statementNode, context);
+        return statement;
+    });
+    return statements;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/ontology/assertion/subproof.js"],"sourcesContent":["\"use strict\";\n\nimport { arrayUtilities } from \"necessary\";\n\nimport ontology from \"../../ontology\";\n\nimport { define } from \"../../ontology\";\nimport { unifyStatement } from \"../../utilities/unification\";\n\nconst { match } = arrayUtilities;\n\nexport default define(class SubproofAssertion {\n  constructor(string, node, statements) {\n    this.string = string;\n    this.node = node;\n    this.statements = statements;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getNode() {\n    return this.node;\n  }\n\n  getStatements() {\n    return this.statements;\n  }\n\n  unifySubproof(subproof, substitutions, generalContext, specificContext) {\n    let subproofUnifies;\n\n    const subproofString = subproof.getString(),\n          subproofAssertionString = this.string;  ///\n\n    specificContext.trace(`Unifying the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion...`);\n\n    const subproofStatements = subproof.getStatements(),\n          subproofAssertionStatements = this.statements;  ///\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      specificContext.debug(`...unified the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion.`);\n    }\n\n    return subproofUnifies;\n  }\n\n  verify(assignments, stated, context) {\n    let verifies;\n\n    const subproofAssertionString = this.string;  ///\n\n    context.trace(`Verifying the '${subproofAssertionString}' subproof assertion...`);\n\n    const statementsVerify = this.verifyStatements(assignments, stated, context);\n\n    verifies = statementsVerify;  ///\n\n    if (verifies) {\n      context.debug(`...verified the '${subproofAssertionString}' subproof assertion.`);\n    }\n\n    return verifies;\n  }\n\n  verifyStatements(assignments, stated, context) {\n    stated = true;  ///\n\n    assignments = null; ///\n\n    const statementsVerify = this.statements.map((statement) => {\n      const statementVerifies = statement.verify(assignments, stated, context);\n\n      if (statementVerifies) {\n        return true;\n      }\n    });\n\n    return statementsVerify;\n  }\n\n  static name = \"SubproofAssertion\";\n\n  static fromStatementNode(statementNode, context) {\n    let subproofAssertion = null;\n\n    const subproofAssertionNode = statementNode.getSubproofAssertionNode();\n\n    if (subproofAssertionNode !== null) {\n      const node = subproofAssertionNode, ///\n            string = context.nodeAsString(node),\n            statements = statementsFromSubproofAssertionNode(subproofAssertionNode, context);\n\n      subproofAssertion = new SubproofAssertion(string, node, statements);\n    }\n\n    return subproofAssertion;\n  }\n});\n\nfunction statementsFromSubproofAssertionNode(subproofAssertionNode, context) {\n  const { Statement } = ontology,\n        statementNodes = subproofAssertionNode.getStatementNodes(),\n        statements = statementNodes.map((statementNode) => {\n          const statement = Statement.fromStatementNode(statementNode, context);\n\n          return statement;\n        });\n\n  return statements;\n}\n"],"names":["match","arrayUtilities","define","SubproofAssertion","string","node","statements","getString","getNode","getStatements","unifySubproof","subproof","substitutions","generalContext","specificContext","subproofUnifies","subproofString","subproofAssertionString","trace","subproofStatements","subproofAssertionStatements","subproofAssertionStatement","subproofStatement","generalStatement","specificStatement","statementUnifies","unifyStatement","debug","verify","assignments","stated","context","verifies","statementsVerify","verifyStatements","map","statement","statementVerifies","fromStatementNode","statementNode","subproofAssertion","subproofAssertionNode","getSubproofAssertionNode","nodeAsString","statementsFromSubproofAssertionNode","name","Statement","ontology","statementNodes","getStatementNodes"],"mappings":"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"}