occam-verify-cli 0.0.1111 → 0.0.1112

package/lib/dom/frame.js

@@ -0,0 +1,372 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _necessary = require("necessary");
+var _dom = /*#__PURE__*/ _interop_require_wildcard(require("../dom"));
+var _metaTypeNames = require("../metaTypeNames");
+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 _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 _Frame;
+var frameNodeQuery = (0, _query.nodeQuery)("/*/frame"), declarationNodesQuery = (0, _query.nodesQuery)("/frame/declaration"), metavariableNodeQuery = (0, _query.nodeQuery)("/frame/metavariable!"), metavariableNodesQuery = (0, _query.nodesQuery)("/frame/metavariable");
+var first = _necessary.arrayUtilities.first;
+var _default = (0, _dom.domAssigned)((_Frame = /*#__PURE__*/ function() {
+    function Frame(string, node, tokens, declarations, metavariables) {
+        _class_call_check(this, Frame);
+        this.string = string;
+        this.node = node;
+        this.tokens = tokens;
+        this.declarations = declarations;
+        this.metavariables = metavariables;
+    }
+    _create_class(Frame, [
+        {
+            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: "getDeclarations",
+            value: function getDeclarations() {
+                return this.declarations;
+            }
+        },
+        {
+            key: "getMetavariables",
+            value: function getMetavariables() {
+                return this.metavariables;
+            }
+        },
+        {
+            key: "getMetavariable",
+            value: function getMetavariable() {
+                var metavariable = null;
+                var declarationsLength = this.declarations.length;
+                if (declarationsLength === 0) {
+                    var metavariablesLength = this.metavariables.length;
+                    if (metavariablesLength === 1) {
+                        var firstMetavariable = first(this.metavariables);
+                        metavariable = firstMetavariable; ///
+                    }
+                }
+                return metavariable;
+            }
+        },
+        {
+            key: "isEqualTo",
+            value: function isEqualTo(frame) {
+                var frameString = frame.getString(), equalTo = frameString === this.string;
+                return equalTo;
+            }
+        },
+        {
+            key: "unifySubstitution",
+            value: function unifySubstitution(substitution, context) {
+                var substitutionUnified = false;
+                var frameString = this.string, substitutionString = substitution.getString();
+                context.trace("Unifying the '".concat(substitutionString, "' substitution with the '").concat(frameString, "' frame..."));
+                if (!substitutionUnified) {
+                    substitutionUnified = this.declarations.some(function(declaration) {
+                        var substitutionUnified = declaration.unifySubstitution(substitution, context);
+                        if (substitutionUnified) {
+                            return true;
+                        }
+                    });
+                }
+                if (!substitutionUnified) {
+                    substitutionUnified = this.metavariables.some(function(metavariable) {
+                        var substitutionUnified = metavariable.unifySubstitution(substitution, context);
+                        if (substitutionUnified) {
+                            return true;
+                        }
+                    });
+                }
+                if (substitutionUnified) {
+                    context.debug("...unified the '".concat(substitutionString, "' substitution with the '").concat(frameString, "' frame..."));
+                }
+                return substitutionUnified;
+            }
+        },
+        {
+            key: "unifyMetaLemmaMetatheorem",
+            value: function unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context) {
+                var _this = this;
+                var metaLemmaMetatheoremUnified;
+                var frameString = this.string, metaLemmaMetatheoremString = metaLemmaMetatheorem.getString();
+                context.trace("Unifying the '".concat(metaLemmaMetatheoremString, "' meta-lemma or metatheorem with the '").concat(frameString, "' frame..."));
+                var substitutions = metaLemmaMetatheorem.getSubstitutions(), substitutionsUnified = substitutions.everySubstitution(function(substitution) {
+                    var substitutionUnified = _this.unifySubstitution(substitution, context);
+                    if (substitutionUnified) {
+                        return true;
+                    }
+                });
+                metaLemmaMetatheoremUnified = substitutionsUnified; ///
+                if (metaLemmaMetatheoremUnified) {
+                    context.debug("...unified the '".concat(metaLemmaMetatheoremString, "' meta-lemma or metatheorem with the '").concat(frameString, "' frame."));
+                }
+                return metaLemmaMetatheoremUnified;
+            }
+        },
+        {
+            key: "unifyAxiomLemmaTheoremOrConjecture",
+            value: function unifyAxiomLemmaTheoremOrConjecture(axiomLemmaTheoremOrConjecture, context) {
+                var _this = this;
+                var axiomLemmaTheoremOrConjectureUnified;
+                var frameString = this.string, axiomLemmaTheoremStringOrConjecture = axiomLemmaTheoremOrConjecture.getString();
+                context.trace("Unifying the '".concat(axiomLemmaTheoremStringOrConjecture, "' axiom, lemma, theorem or conjecture with the '").concat(frameString, "' frame..."));
+                var substitutions = axiomLemmaTheoremOrConjecture.getSubstitutions(), substitutionsUnified = substitutions.everySubstitution(function(substitution) {
+                    var substitutionUnified = _this.unifySubstitution(substitution, context);
+                    if (substitutionUnified) {
+                        return true;
+                    }
+                });
+                axiomLemmaTheoremOrConjectureUnified = substitutionsUnified; ///
+                if (axiomLemmaTheoremOrConjectureUnified) {
+                    context.debug("...unified the '".concat(axiomLemmaTheoremStringOrConjecture, "' axiom, lemma, theorem or conjecture with the '").concat(frameString, "' frame."));
+                }
+                return axiomLemmaTheoremOrConjectureUnified;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(assignments, stated, context) {
+                var verified = false;
+                var frameString = this.string; ///
+                context.trace("Verifying the '".concat(frameString, "' frame..."));
+                var declarationsVerified = this.verifyDeclarations(this.declarations, assignments, stated, context);
+                if (declarationsVerified) {
+                    var metavariablesVerified = this.metavariables.every(function(metavariable) {
+                        var metavariableVerified = metavariable.verify(context);
+                        return metavariableVerified;
+                    });
+                    if (metavariablesVerified) {
+                        var verifiedWhenStated = false, verifiedWhenDerived = false;
+                        if (stated) {
+                            verifiedWhenStated = this.verifyWhenStated(assignments, context);
+                        } else {
+                            verifiedWhenDerived = this.verifyWhenDerived(assignments, context);
+                        }
+                        if (verifiedWhenStated || verifiedWhenDerived) {
+                            verified = true;
+                        }
+                    }
+                }
+                if (verified) {
+                    context.debug("...verified the '".concat(frameString, "' frame."));
+                }
+                return verified;
+            }
+        },
+        {
+            key: "verifyDeclarations",
+            value: function verifyDeclarations(declarations, assignments, stated, context) {
+                stated = true; ///
+                assignments = null; ///
+                var declarationsVerified = declarations.every(function(declaration) {
+                    var frame = null, declarationVerified = declaration.verify(frame, assignments, stated, context);
+                    return declarationVerified;
+                });
+                return declarationsVerified;
+            }
+        },
+        {
+            key: "verifyWhenStated",
+            value: function verifyWhenStated(assignments, context) {
+                var verifiedWhenStated = false;
+                var frameString = this.string; ///
+                context.trace("Verifying the '".concat(frameString, "' stated frame..."));
+                var declarationsLength = this.declarations.length;
+                if (declarationsLength > 0) {
+                    context.trace("The '".concat(frameString, "' stated frame cannot have declarations."));
+                } else {
+                    var metavariablesLength = this.metavariables.length;
+                    if (metavariablesLength > 1) {
+                        context.trace("The '".concat(frameString, "' stated frame cannot have more than one metavariable."));
+                    } else {
+                        verifiedWhenStated = true;
+                    }
+                }
+                if (verifiedWhenStated) {
+                    context.debug("...verified the '".concat(frameString, "' stated frame."));
+                }
+                return verifiedWhenStated;
+            }
+        },
+        {
+            key: "verifyWhenDerived",
+            value: function verifyWhenDerived(assignments, context) {
+                var verifiedWhenDerived;
+                var frameString = this.string; ///
+                context.trace("Verifying the '".concat(frameString, "' derived frame..."));
+                verifiedWhenDerived = true;
+                if (verifiedWhenDerived) {
+                    context.debug("...verified the '".concat(frameString, "' derived frame."));
+                }
+                return verifiedWhenDerived;
+            }
+        },
+        {
+            key: "verifyGivenMetaType",
+            value: function verifyGivenMetaType(metaType, assignments, stated, context) {
+                var verifiedGivenMetaType = false;
+                var frameString = this.string, metaTypeString = metaType.getString();
+                context.trace("Verifying the '".concat(frameString, "' frame given the '").concat(metaTypeString, "' meta-type..."));
+                var metaTypeName = metaType.getName();
+                if (metaTypeName === _metaTypeNames.FRAME_META_TYPE_NAME) {
+                    var verified = this.verify(assignments, stated, context);
+                    verifiedGivenMetaType = verified; ///
+                }
+                if (verifiedGivenMetaType) {
+                    context.debug("...verified the '".concat(frameString, "' frame given the '").concat(metaTypeString, "' meta-type."));
+                }
+                return verifiedGivenMetaType;
+            }
+        }
+    ], [
+        {
+            key: "fromFrameNode",
+            value: function fromFrameNode(frameNode, context) {
+                var frame = null;
+                if (frameNode !== null) {
+                    var Declaration = _dom.default.Declaration, Metavariable = _dom.default.Metavariable, node = frameNode, string = context.nodeAsString(node), tokens = context.nodeAsTokens(node), declarationNodes = declarationNodesQuery(frameNode), metavariableNodes = metavariableNodesQuery(frameNode), declarations = declarationNodes.map(function(declarationNode) {
+                        var declaration = Declaration.fromDeclarationNode(declarationNode, context);
+                        return declaration;
+                    }), metavariables = metavariableNodes.map(function(metavariableNode) {
+                        var metavariable = Metavariable.fromMetavariableNode(metavariableNode, context);
+                        return metavariable;
+                    });
+                    frame = new Frame(string, node, tokens, declarations, metavariables);
+                }
+                return frame;
+            }
+        },
+        {
+            key: "fromDefinedAssertionNode",
+            value: function fromDefinedAssertionNode(definedAssertionNode, context) {
+                var frame = null;
+                var frameNode = frameNodeQuery(definedAssertionNode);
+                if (frameNode !== null) {
+                    var metavariableNode = metavariableNodeQuery(frameNode);
+                    if (metavariableNode !== null) {
+                        var Metavariable = _dom.default.Metavariable, metavariable = Metavariable.fromMetavariableNode(metavariableNode, context), declarations = [], metavariables = [
+                            metavariable
+                        ], node = frameNode, string = context.nodeAsString(node), tokens = context.nodeAsTokens(node);
+                        frame = new Frame(string, node, tokens, declarations, metavariables);
+                    }
+                }
+                return frame;
+            }
+        },
+        {
+            key: "fromContainedAssertionNode",
+            value: function fromContainedAssertionNode(containedAssertionNode, context) {
+                var frame = null;
+                var frameNode = frameNodeQuery(containedAssertionNode);
+                if (frameNode !== null) {
+                    var metavariableNode = metavariableNodeQuery(frameNode);
+                    if (metavariableNode !== null) {
+                        var Metavariable = _dom.default.Metavariable, metavariable = Metavariable.fromMetavariableNode(metavariableNode, context), declarations = [], metavariables = [
+                            metavariable
+                        ], node = frameNode, string = context.nodeAsString(node), tokens = context.nodeAsTokens(node);
+                        frame = new Frame(string, node, tokens, declarations, metavariables);
+                    }
+                }
+                return frame;
+            }
+        }
+    ]);
+    return Frame;
+}(), _define_property(_Frame, "name", "Frame"), _Frame));
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/dom/frame.js"],"sourcesContent":["\"use strict\";\n\nimport { arrayUtilities } from \"necessary\";\n\nimport dom from \"../dom\";\n\nimport { domAssigned } from \"../dom\";\nimport { FRAME_META_TYPE_NAME } from \"../metaTypeNames\";\nimport { nodeQuery, nodesQuery } from \"../utilities/query\";\n\nconst frameNodeQuery = nodeQuery(\"/*/frame\"),\n      declarationNodesQuery = nodesQuery(\"/frame/declaration\"),\n      metavariableNodeQuery = nodeQuery(\"/frame/metavariable!\"),\n      metavariableNodesQuery = nodesQuery(\"/frame/metavariable\");\n\nconst { first } = arrayUtilities;\n\nexport default domAssigned(class Frame {\n  constructor(string, node, tokens, declarations, metavariables) {\n    this.string = string;\n    this.node = node;\n    this.tokens = tokens;\n    this.declarations = declarations;\n    this.metavariables = metavariables;\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  getDeclarations() {\n    return this.declarations;\n  }\n\n  getMetavariables() {\n    return this.metavariables;\n  }\n\n  getMetavariable() {\n    let metavariable = null;\n\n    const declarationsLength = this.declarations.length;\n\n    if (declarationsLength === 0) {\n      const metavariablesLength = this.metavariables.length;\n\n      if (metavariablesLength === 1) {\n        const firstMetavariable = first(this.metavariables);\n\n        metavariable = firstMetavariable; ///\n      }\n    }\n\n    return metavariable;\n  }\n\n  isEqualTo(frame) {\n    const frameString = frame.getString(),\n          equalTo = (frameString === this.string);\n\n    return equalTo;\n  }\n\n  unifySubstitution(substitution, context) {\n    let substitutionUnified = false;\n\n    const frameString = this.string,  ///\n          substitutionString = substitution.getString();\n\n    context.trace(`Unifying the '${substitutionString}' substitution with the '${frameString}' frame...`)\n\n    if (!substitutionUnified) {\n      substitutionUnified = this.declarations.some((declaration) => {\n        const substitutionUnified = declaration.unifySubstitution(substitution, context);\n\n        if (substitutionUnified) {\n          return true;\n        }\n      });\n    }\n\n    if (!substitutionUnified) {\n      substitutionUnified = this.metavariables.some((metavariable) => {\n        const substitutionUnified = metavariable.unifySubstitution(substitution, context);\n\n        if (substitutionUnified) {\n          return true;\n        }\n      });\n    }\n\n    if (substitutionUnified) {\n      context.debug(`...unified the '${substitutionString}' substitution with the '${frameString}' frame...`)\n    }\n\n    return substitutionUnified;\n  }\n\n  unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context) {\n    let metaLemmaMetatheoremUnified;\n\n    const frameString = this.string,  ///\n          metaLemmaMetatheoremString = metaLemmaMetatheorem.getString();\n\n    context.trace(`Unifying the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${frameString}' frame...`);\n\n    const substitutions = metaLemmaMetatheorem.getSubstitutions(),\n          substitutionsUnified = substitutions.everySubstitution((substitution) => {\n            const substitutionUnified = this.unifySubstitution(substitution, context);\n\n            if (substitutionUnified) {\n              return true;\n            }\n          });\n\n    metaLemmaMetatheoremUnified = substitutionsUnified; ///\n\n    if (metaLemmaMetatheoremUnified) {\n      context.debug(`...unified the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${frameString}' frame.`);\n    }\n\n    return metaLemmaMetatheoremUnified;\n  }\n\n  unifyAxiomLemmaTheoremOrConjecture(axiomLemmaTheoremOrConjecture, context) {\n    let axiomLemmaTheoremOrConjectureUnified;\n\n    const frameString = this.string,  ///\n          axiomLemmaTheoremStringOrConjecture = axiomLemmaTheoremOrConjecture.getString();\n\n    context.trace(`Unifying the '${axiomLemmaTheoremStringOrConjecture}' axiom, lemma, theorem or conjecture with the '${frameString}' frame...`);\n\n    const substitutions = axiomLemmaTheoremOrConjecture.getSubstitutions(),\n          substitutionsUnified = substitutions.everySubstitution((substitution) => {\n            const substitutionUnified = this.unifySubstitution(substitution, context);\n\n            if (substitutionUnified) {\n              return true;\n            }\n          });\n\n    axiomLemmaTheoremOrConjectureUnified = substitutionsUnified; ///\n\n    if (axiomLemmaTheoremOrConjectureUnified) {\n      context.debug(`...unified the '${axiomLemmaTheoremStringOrConjecture}' axiom, lemma, theorem or conjecture with the '${frameString}' frame.`);\n    }\n\n    return axiomLemmaTheoremOrConjectureUnified;\n  }\n\n  verify(assignments, stated, context) {\n    let verified = false;\n\n    const frameString = this.string;  ///\n\n    context.trace(`Verifying the '${frameString}' frame...`);\n\n    const declarationsVerified = this.verifyDeclarations(this.declarations, assignments, stated, context);\n\n    if (declarationsVerified) {\n      const  metavariablesVerified = this.metavariables.every((metavariable) => {\n        const metavariableVerified = metavariable.verify(context);\n\n        return metavariableVerified;\n      });\n\n      if (metavariablesVerified) {\n        let verifiedWhenStated = false,\n            verifiedWhenDerived = false;\n\n        if (stated) {\n          verifiedWhenStated = this.verifyWhenStated(assignments, context);\n        } else {\n          verifiedWhenDerived = this.verifyWhenDerived(assignments, context);\n        }\n\n        if (verifiedWhenStated || verifiedWhenDerived) {\n          verified = true;\n        }\n      }\n    }\n\n    if (verified) {\n      context.debug(`...verified the '${frameString}' frame.`);\n    }\n\n    return verified;\n  }\n\n  verifyDeclarations(declarations, assignments, stated, context) {\n    stated = true;  ///\n\n    assignments = null; ///\n\n    const declarationsVerified = declarations.every((declaration) => {\n      const frame = null, ///\n            declarationVerified = declaration.verify(frame, assignments, stated, context);\n\n      return declarationVerified;\n    });\n\n    return declarationsVerified;\n  }\n\n  verifyWhenStated(assignments, context) {\n    let verifiedWhenStated = false;\n\n    const frameString = this.string;  ///\n\n    context.trace(`Verifying the '${frameString}' stated frame...`);\n\n    const declarationsLength = this.declarations.length;\n\n    if (declarationsLength > 0) {\n      context.trace(`The '${frameString}' stated frame cannot have declarations.`);\n    } else {\n      const metavariablesLength = this.metavariables.length;\n\n      if (metavariablesLength > 1) {\n        context.trace(`The '${frameString}' stated frame cannot have more than one metavariable.`);\n      } else {\n        verifiedWhenStated = true;\n      }\n    }\n\n    if (verifiedWhenStated) {\n      context.debug(`...verified the '${frameString}' stated frame.`);\n    }\n\n    return verifiedWhenStated;\n  }\n\n  verifyWhenDerived(assignments, context) {\n    let verifiedWhenDerived;\n\n    const frameString = this.string;  ///\n\n    context.trace(`Verifying the '${frameString}' derived frame...`);\n\n    verifiedWhenDerived = true;\n\n    if (verifiedWhenDerived) {\n      context.debug(`...verified the '${frameString}' derived frame.`);\n    }\n\n    return verifiedWhenDerived;\n  }\n\n  verifyGivenMetaType(metaType, assignments, stated, context) {\n    let verifiedGivenMetaType = false;\n\n    const frameString = this.string,  ///\n          metaTypeString = metaType.getString();\n\n    context.trace(`Verifying the '${frameString}' frame given the '${metaTypeString}' meta-type...`);\n\n    const metaTypeName = metaType.getName();\n\n    if (metaTypeName === FRAME_META_TYPE_NAME) {\n      const verified = this.verify(assignments, stated, context)\n\n      verifiedGivenMetaType = verified; ///\n    }\n\n    if (verifiedGivenMetaType) {\n      context.debug(`...verified the '${frameString}' frame given the '${metaTypeString}' meta-type.`);\n    }\n\n    return verifiedGivenMetaType;\n  }\n\n  static name = \"Frame\";\n\n  static fromFrameNode(frameNode, context) {\n    let frame = null;\n\n    if (frameNode !== null) {\n      const { Declaration, Metavariable } = dom,\n            node = frameNode, ///\n            string = context.nodeAsString(node),\n            tokens = context.nodeAsTokens(node),\n            declarationNodes = declarationNodesQuery(frameNode),\n            metavariableNodes = metavariableNodesQuery(frameNode),\n            declarations = declarationNodes.map((declarationNode) => {\n              const declaration = Declaration.fromDeclarationNode(declarationNode, context);\n\n              return declaration;\n            }),\n            metavariables = metavariableNodes.map((metavariableNode) => {\n              const metavariable = Metavariable.fromMetavariableNode(metavariableNode, context);\n\n              return metavariable;\n            });\n\n      frame = new Frame(string, node, tokens, declarations, metavariables);\n    }\n\n    return frame;\n  }\n\n  static fromDefinedAssertionNode(definedAssertionNode, context) {\n    let frame = null;\n\n    const frameNode = frameNodeQuery(definedAssertionNode);\n\n    if (frameNode !== null) {\n      const metavariableNode = metavariableNodeQuery(frameNode);\n\n      if (metavariableNode !== null) {\n        const { Metavariable } = dom,\n              metavariable = Metavariable.fromMetavariableNode(metavariableNode, context),\n              declarations = [],\n              metavariables = [\n                metavariable\n              ],\n              node = frameNode,  ///\n              string = context.nodeAsString(node),\n              tokens = context.nodeAsTokens(node);\n\n        frame = new Frame(string, node, tokens, declarations, metavariables);\n      }\n    }\n\n    return frame;\n  }\n\n  static fromContainedAssertionNode(containedAssertionNode, context) {\n    let frame = null;\n\n    const frameNode = frameNodeQuery(containedAssertionNode);\n\n    if (frameNode !== null) {\n      const metavariableNode = metavariableNodeQuery(frameNode);\n\n      if (metavariableNode !== null) {\n        const { Metavariable } = dom,\n              metavariable = Metavariable.fromMetavariableNode(metavariableNode, context),\n              declarations = [],\n              metavariables = [\n                metavariable\n              ],\n              node = frameNode,  ///\n              string = context.nodeAsString(node),\n              tokens = context.nodeAsTokens(node);\n\n        frame = new Frame(string, node, tokens, declarations, metavariables);\n      }\n    }\n\n    return frame;\n  }\n});\n"],"names":["frameNodeQuery","nodeQuery","declarationNodesQuery","nodesQuery","metavariableNodeQuery","metavariableNodesQuery","first","arrayUtilities","domAssigned","Frame","string","node","tokens","declarations","metavariables","getString","getNode","getTokens","getDeclarations","getMetavariables","getMetavariable","metavariable","declarationsLength","length","metavariablesLength","firstMetavariable","isEqualTo","frame","frameString","equalTo","unifySubstitution","substitution","context","substitutionUnified","substitutionString","trace","some","declaration","debug","unifyMetaLemmaMetatheorem","metaLemmaMetatheorem","metaLemmaMetatheoremUnified","metaLemmaMetatheoremString","substitutions","getSubstitutions","substitutionsUnified","everySubstitution","unifyAxiomLemmaTheoremOrConjecture","axiomLemmaTheoremOrConjecture","axiomLemmaTheoremOrConjectureUnified","axiomLemmaTheoremStringOrConjecture","verify","assignments","stated","verified","declarationsVerified","verifyDeclarations","metavariablesVerified","every","metavariableVerified","verifiedWhenStated","verifiedWhenDerived","verifyWhenStated","verifyWhenDerived","declarationVerified","verifyGivenMetaType","metaType","verifiedGivenMetaType","metaTypeString","metaTypeName","getName","FRAME_META_TYPE_NAME","fromFrameNode","frameNode","Declaration","dom","Metavariable","nodeAsString","nodeAsTokens","declarationNodes","metavariableNodes","map","declarationNode","fromDeclarationNode","metavariableNode","fromMetavariableNode","fromDefinedAssertionNode","definedAssertionNode","fromContainedAssertionNode","containedAssertionNode","name"],"mappings":"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"}

package/lib/dom/judgement.js

@@ -0,0 +1,198 @@
+"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 _judgement = /*#__PURE__*/ _interop_require_default(require("../assignment/judgement"));
+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 _Judgement;
+var frameNodeQuery = (0, _query.nodeQuery)("/judgement/frame"), judgementNodeQuery = (0, _query.nodeQuery)("/statement/judgement"), declarationNodeQuery = (0, _query.nodeQuery)("/judgement/declaration");
+var _default = (0, _dom.domAssigned)((_Judgement = /*#__PURE__*/ function() {
+    function Judgement(string, frame, declaration) {
+        _class_call_check(this, Judgement);
+        this.string = string;
+        this.frame = frame;
+        this.declaration = declaration;
+    }
+    _create_class(Judgement, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getFrame",
+            value: function getFrame() {
+                return this.frame;
+            }
+        },
+        {
+            key: "getDeclaration",
+            value: function getDeclaration() {
+                return this.declaration;
+            }
+        },
+        {
+            key: "getMetavariable",
+            value: function getMetavariable() {
+                return this.frame.getMetavariable();
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(assignments, stated, context) {
+                var verified = false;
+                var judgementString = this.string; ///
+                context.trace("Verifying the '".concat(judgementString, "' judgement..."));
+                var frameVerified = this.frame.verify(assignments, stated, context);
+                if (frameVerified) {
+                    var declarationVerified = this.declaration.verify(this.frame, assignments, stated, context);
+                    if (declarationVerified) {
+                        var verifiedWhenStated = false, verifiedWhenDerived = false;
+                        if (stated) {
+                            verifiedWhenStated = this.verifyWhenStated(assignments, context);
+                        } else {
+                            verifiedWhenDerived = this.verifyWhenDerived(context);
+                        }
+                        verified = verifiedWhenStated || verifiedWhenDerived;
+                    }
+                }
+                if (verified) {
+                    context.debug("...verified the '".concat(judgementString, "' judgement."));
+                }
+                return verified;
+            }
+        },
+        {
+            key: "verifyWhenStated",
+            value: function verifyWhenStated(assignments, context) {
+                var verifiedWhenStated;
+                var judgementString = this.string; ///
+                context.trace("Verifying the '".concat(judgementString, "' stated judgement..."));
+                if (assignments !== null) {
+                    var judgement = this, judgementAssignment = _judgement.default.fromJudgement(judgement), assignment = judgementAssignment;
+                    assignments.push(assignment);
+                }
+                verifiedWhenStated = true;
+                if (verifiedWhenStated) {
+                    context.debug("...verified the '".concat(judgementString, "' stated judgement."));
+                }
+                return verifiedWhenStated;
+            }
+        },
+        {
+            key: "verifyWhenDerived",
+            value: function verifyWhenDerived(context) {
+                var verifiedWhenDerived;
+                var judgementString = this.string; ///
+                context.trace("Verifying the '".concat(judgementString, "' derived judgement..."));
+                verifiedWhenDerived = true;
+                if (verifiedWhenDerived) {
+                    context.debug("...verified the '".concat(judgementString, "' derived judgement."));
+                }
+                return verifiedWhenDerived;
+            }
+        }
+    ], [
+        {
+            key: "fromStatementNode",
+            value: function fromStatementNode(statementNode, context) {
+                var judgement = null;
+                var judgementNode = judgementNodeQuery(statementNode);
+                if (judgementNode !== null) {
+                    var Frame = _dom.default.Frame, Declaration = _dom.default.Declaration, frameNode = frameNodeQuery(judgementNode), declarationNode = declarationNodeQuery(judgementNode), node = judgementNode, frame = Frame.fromFrameNode(frameNode, context), string = context.nodeAsString(node), declaration = Declaration.fromDeclarationNode(declarationNode, context);
+                    judgement = new Judgement(string, frame, declaration);
+                }
+                return judgement;
+            }
+        }
+    ]);
+    return Judgement;
+}(), _define_property(_Judgement, "name", "Judgement"), _Judgement));
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/dom/judgement.js"],"sourcesContent":["\"use strict\";\n\nimport dom from \"../dom\";\nimport JudgementAssignment from \"../assignment/judgement\";\n\nimport { nodeQuery } from \"../utilities/query\";\nimport { domAssigned } from \"../dom\";\n\nconst frameNodeQuery = nodeQuery(\"/judgement/frame\"),\n      judgementNodeQuery = nodeQuery(\"/statement/judgement\"),\n      declarationNodeQuery = nodeQuery(\"/judgement/declaration\");\n\nexport default domAssigned(class Judgement {\n  constructor(string, frame, declaration) {\n    this.string = string;\n    this.frame = frame;\n    this.declaration = declaration;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getFrame() {\n    return this.frame;\n  }\n\n  getDeclaration() {\n    return this.declaration;\n  }\n\n  getMetavariable() { return this.frame.getMetavariable(); }\n\n  verify(assignments, stated, context) {\n    let verified = false;\n\n    const judgementString = this.string;  ///\n\n    context.trace(`Verifying the '${judgementString}' judgement...`);\n\n    const frameVerified = this.frame.verify(assignments, stated, context);\n\n    if (frameVerified) {\n      const declarationVerified = this.declaration.verify(this.frame, assignments, stated, context);\n\n      if (declarationVerified) {\n        let verifiedWhenStated = false,\n            verifiedWhenDerived = false;\n\n        if (stated) {\n          verifiedWhenStated = this.verifyWhenStated(assignments, context);\n        } else {\n          verifiedWhenDerived = this.verifyWhenDerived(context);\n        }\n\n        verified = (verifiedWhenStated || verifiedWhenDerived);\n      }\n    }\n\n    if (verified) {\n      context.debug(`...verified the '${judgementString}' judgement.`);\n    }\n\n    return verified;\n  }\n\n  verifyWhenStated(assignments, context) {\n    let verifiedWhenStated;\n\n    const judgementString = this.string;  ///\n\n    context.trace(`Verifying the '${judgementString}' stated judgement...`);\n\n    if (assignments !== null) {\n      const judgement = this, ///\n            judgementAssignment = JudgementAssignment.fromJudgement(judgement),\n            assignment = judgementAssignment;\n\n      assignments.push(assignment);\n    }\n\n    verifiedWhenStated = true;\n\n    if (verifiedWhenStated) {\n      context.debug(`...verified the '${judgementString}' stated judgement.`);\n    }\n\n    return verifiedWhenStated;\n  }\n\n  verifyWhenDerived(context) {\n    let verifiedWhenDerived ;\n\n    const judgementString = this.string;  ///\n\n    context.trace(`Verifying the '${judgementString}' derived judgement...`);\n\n    verifiedWhenDerived = true;\n\n    if (verifiedWhenDerived) {\n      context.debug(`...verified the '${judgementString}' derived judgement.`);\n    }\n\n    return verifiedWhenDerived;\n  }\n\n  static name = \"Judgement\";\n\n  static fromStatementNode(statementNode, context) {\n    let judgement = null;\n\n    const judgementNode = judgementNodeQuery(statementNode);\n\n    if (judgementNode !== null) {\n      const { Frame, Declaration } = dom,\n            frameNode = frameNodeQuery(judgementNode),\n            declarationNode = declarationNodeQuery(judgementNode),\n            node = judgementNode, ///\n            frame = Frame.fromFrameNode(frameNode, context),\n            string = context.nodeAsString(node),\n            declaration = Declaration.fromDeclarationNode(declarationNode, context);\n\n      judgement = new Judgement(string, frame, declaration);\n    }\n\n    return judgement;\n  }\n});\n"],"names":["frameNodeQuery","nodeQuery","judgementNodeQuery","declarationNodeQuery","domAssigned","Judgement","string","frame","declaration","getString","getFrame","getDeclaration","getMetavariable","verify","assignments","stated","context","verified","judgementString","trace","frameVerified","declarationVerified","verifiedWhenStated","verifiedWhenDerived","verifyWhenStated","verifyWhenDerived","debug","judgement","judgementAssignment","JudgementAssignment","fromJudgement","assignment","push","fromStatementNode","statementNode","judgementNode","Frame","dom","Declaration","frameNode","declarationNode","node","fromFrameNode","nodeAsString","fromDeclarationNode","name"],"mappings":"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"}