occam-verify-cli 1.0.421 → 1.0.428

package/lib/element/assertion/satisfies.js

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _elements = /*#__PURE__*/ _interop_require_wildcard(require("../../elements"));
+var _assertion = /*#__PURE__*/ _interop_require_default(require("../assertion"));
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+var _SatisfiesAssertion;
+var _default = (0, _elements.define)((_SatisfiesAssertion = /*#__PURE__*/ function(Assertion) {
+    _inherits(SatisfiesAssertion, Assertion);
+    function SatisfiesAssertion(string, node, signature, reference) {
+        _class_call_check(this, SatisfiesAssertion);
+        var _this;
+        _this = _call_super(this, SatisfiesAssertion, [
+            string,
+            node
+        ]);
+        _this.signature = signature;
+        _this.reference = reference;
+        return _this;
+    }
+    _create_class(SatisfiesAssertion, [
+        {
+            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.getString(); ///
+                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.getString(); ///
+                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;
+                    var Substitutions = _elements.default.Substitutions;
+                    substitutions = Substitutions.fromNothing();
+                    var signatureMatches = axiom.matchSignature(this.signature, substitutions, context);
+                    if (signatureMatches) {
+                        var substitutionsB = substitutions; ///
+                        substitutions = Substitutions.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;
+            }
+        }
+    ]);
+    return SatisfiesAssertion;
+}(_assertion.default), _define_property(_SatisfiesAssertion, "name", "SatisfiesAssertion"), _SatisfiesAssertion));
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/element/assertion/satisfies.js"],"sourcesContent":["\"use strict\";\n\nimport elements from \"../../elements\";\nimport Assertion from \"../assertion\";\n\nimport { define } from \"../../elements\";\n\nexport default define(class SatisfiesAssertion extends Assertion {\n  constructor(string, node, signature, reference) {\n    super(string, node);\n\n    this.signature = signature;\n    this.reference = reference;\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.getString(); ///\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.getString(); ///\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      const { Substitutions } = elements;\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"],"names":["define","SatisfiesAssertion","string","node","signature","reference","getSignature","getReference","compareSubstitutions","substitutions","context","correlateSubstitutions","verify","assignments","stated","verifies","satisfiesAssertionString","getString","trace","signatureVerifies","verifySignature","referenceVerifies","verifyReference","debug","referenceString","axiom","findAxiomByReference","axiomSatisfiable","isSatisfiable","unifyStatementAndStepsOrSubproofs","statement","stepsOrSubproofs","statementUnifies","statementString","satisfiable","Substitutions","elements","fromNothing","signatureMatches","matchSignature","substitutionsB","substitutionsA","substitutionsMatch","substitutionsAString","asString","substitutionsBString","Assertion","name"],"mappings":"AAAA;;;;+BAOA;;;eAAA;;;gEALqB;gEACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAItB,WAAeA,IAAAA,gBAAM,uCAAC;;aAAMC,mBACdC,MAAM,EAAEC,IAAI,EAAEC,SAAS,EAAEC,SAAS;gCADpBJ;;gBAExB,kBAFwBA;YAElBC;YAAQC;;QAEd,MAAKC,SAAS,GAAGA;QACjB,MAAKC,SAAS,GAAGA;;;;;YAGnBC,KAAAA;mBAAAA,SAAAA;gBACE,OAAO,IAAI,CAACF,SAAS;YACvB;;;YAEAG,KAAAA;mBAAAA,SAAAA;gBACE,OAAO,IAAI,CAACF,SAAS;YACvB;;;YAEAG,KAAAA;mBAAAA,SAAAA,qBAAqBC,aAAa,EAAEC,OAAO;gBAAI,OAAO,IAAI,CAACN,SAAS,CAACI,oBAAoB,CAACC,eAAeC;YAAU;;;YAEnHC,KAAAA;mBAAAA,SAAAA,uBAAuBF,aAAa,EAAEC,OAAO;gBAAI,OAAO,IAAI,CAACN,SAAS,CAACO,sBAAsB,CAACF,eAAeC;YAAU;;;YAEvHE,KAAAA;mBAAAA,SAAAA,OAAOC,WAAW,EAAEC,MAAM,EAAEJ,OAAO;gBACjC,IAAIK,WAAW;gBAEf,IAAMC,2BAA2B,IAAI,CAACC,SAAS,IAAI,GAAG;gBAEtDP,QAAQQ,KAAK,CAAC,AAAC,kBAA0C,OAAzBF,0BAAyB;gBAEzD,IAAMG,oBAAoB,IAAI,CAACC,eAAe,CAACP,aAAaC,QAAQJ;gBAEpE,IAAIS,mBAAmB;oBACrB,IAAME,oBAAoB,IAAI,CAACC,eAAe,CAACT,aAAaC,QAAQJ;oBAEpEK,WAAWM,mBAAmB,GAAG;gBACnC;gBAEA,IAAIN,UAAU;oBACZL,QAAQa,KAAK,CAAC,AAAC,oBAA4C,OAAzBP,0BAAyB;gBAC7D;gBAEA,OAAOD;YACT;;;YAEAK,KAAAA;mBAAAA,SAAAA,gBAAgBP,WAAW,EAAEC,MAAM,EAAEJ,OAAO;gBAC1C,IAAMS,oBAAoB,IAAI,CAACf,SAAS,CAACQ,MAAM,CAACF;gBAEhD,OAAOS;YACT;;;YAEAG,KAAAA;mBAAAA,SAAAA,gBAAgBT,WAAW,EAAEC,MAAM,EAAEJ,OAAO;gBAC1C,IAAIW,oBAAoB;gBAExB,IAAMG,kBAAkB,IAAI,CAACnB,SAAS,CAACY,SAAS;gBAEhDP,QAAQQ,KAAK,CAAC,AAAC,kBAAiC,OAAhBM,iBAAgB;gBAEhD,IAAMC,QAAQf,QAAQgB,oBAAoB,CAAC,IAAI,CAACrB,SAAS,EAAEK;gBAE3D,IAAIe,UAAU,MAAM;oBAClB,IAAME,mBAAmBF,MAAMG,aAAa;oBAE5C,IAAID,kBAAkB;wBACpBN,oBAAoB;oBACtB;gBACF;gBAEA,IAAIA,mBAAmB;oBACrBX,QAAQa,KAAK,CAAC,AAAC,oBAAmC,OAAhBC,iBAAgB;gBACpD;gBAEA,OAAOH;YACT;;;YAEAQ,KAAAA;mBAAAA,SAAAA,kCAAkCC,SAAS,EAAEC,gBAAgB,EAAErB,OAAO;gBACpE,IAAIsB,mBAAmB;gBAEvB,IAAMC,kBAAkBH,UAAUb,SAAS,IACrCD,2BAA2B,IAAI,CAACC,SAAS,IAAI,GAAG;gBAEtDP,QAAQQ,KAAK,CAAC,AAAC,iBAAwDF,OAAxCiB,iBAAgB,0BAAiD,OAAzBjB,0BAAyB;gBAEhG,IAAI,CAACZ,SAAS,CAACQ,MAAM,CAACF;gBAEtB,IAAMe,QAAQf,QAAQgB,oBAAoB,CAAC,IAAI,CAACrB,SAAS,GACnD6B,cAAcT,MAAMG,aAAa;gBAEvC,IAAIM,aAAa;oBACf,IAAIzB;oBAEJ,IAAM,AAAE0B,gBAAkBC,iBAAQ,CAA1BD;oBAER1B,gBAAgB0B,cAAcE,WAAW;oBAEzC,IAAMC,mBAAmBb,MAAMc,cAAc,CAAC,IAAI,CAACnC,SAAS,EAAEK,eAAeC;oBAE7E,IAAI4B,kBAAkB;wBACpB,IAAME,iBAAiB/B,eAAe,GAAG;wBAEzCA,gBAAgB0B,cAAcE,WAAW;wBAEzCL,mBAAmBP,MAAMI,iCAAiC,CAACC,WAAWC,kBAAkBtB,eAAeC;wBAEvG,IAAIsB,kBAAkB;4BACpB,IAAMS,iBAAiBhC,eACjBiC,qBAAqBD,eAAe9B,sBAAsB,CAAC6B;4BAEjE,IAAI,CAACE,oBAAoB;gCACvB,IAAMC,uBAAuBF,eAAeG,QAAQ,IAC9CC,uBAAuBL,eAAeI,QAAQ;gCAEpDlC,QAAQQ,KAAK,CAAC,AAAC,mBAAgGyB,OAA9EE,sBAAqB,2DAA8E,OAArBF,sBAAqB;gCAEpIX,mBAAmB;4BACrB;wBACF;oBACF;gBACF;gBAEA,IAAIA,kBAAkB;oBACpBtB,QAAQa,KAAK,CAAC,AAAC,mBAA0DP,OAAxCiB,iBAAgB,0BAAiD,OAAzBjB,0BAAyB;gBACpG;gBAEA,OAAOgB;YACT;;;;EA1HqDc,kBAAS,GA4H9D,sCAAOC,QAAO"}

package/lib/element/assertion/subproof.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _necessary = require("necessary");
+var _assertion = /*#__PURE__*/ _interop_require_default(require("../assertion"));
+var _elements = require("../../elements");
+var _unify = require("../../process/unify");
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+var _SubproofAssertion;
+var match = _necessary.arrayUtilities.match;
+var _default = (0, _elements.define)((_SubproofAssertion = /*#__PURE__*/ function(Assertion) {
+    _inherits(SubproofAssertion, Assertion);
+    function SubproofAssertion(string, node, statements) {
+        _class_call_check(this, SubproofAssertion);
+        var _this;
+        _this = _call_super(this, SubproofAssertion, [
+            string,
+            node
+        ]);
+        _this.statements = statements;
+        return _this;
+    }
+    _create_class(SubproofAssertion, [
+        {
+            key: "getStatements",
+            value: function getStatements() {
+                return this.statements;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(assignments, stated, context) {
+                var verifies;
+                var subproofAssertionString = this.getString(); ///
+                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: "unifySubproof",
+            value: function unifySubproof(subproof, substitutions, generalContext, specificContext) {
+                var subproofUnifies;
+                var subproofString = subproof.getString(), subproofAssertionString = this.getString(); ///
+                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, _unify.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;
+            }
+        }
+    ]);
+    return SubproofAssertion;
+}(_assertion.default), _define_property(_SubproofAssertion, "name", "SubproofAssertion"), _SubproofAssertion));
+
+//# sourceMappingURL=data:application/json;base64,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