occam-verify-cli 1.0.383 → 1.0.386

package/lib/ontology/section.js

@@ -0,0 +1,255 @@
+"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 _local = /*#__PURE__*/ _interop_require_default(require("../context/local"));
+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 _Section;
+var _default = (0, _ontology.define)((_Section = /*#__PURE__*/ function() {
+    function Section(context, node, string, hypotheses, axiom, lemma, theorem, conjecture) {
+        _class_call_check(this, Section);
+        this.context = context;
+        this.node = node;
+        this.string = string;
+        this.hypotheses = hypotheses;
+        this.axiom = axiom;
+        this.lemma = lemma;
+        this.theorem = theorem;
+        this.conjecture = conjecture;
+    }
+    _create_class(Section, [
+        {
+            key: "getContext",
+            value: function getContext() {
+                return this.context;
+            }
+        },
+        {
+            key: "getNode",
+            value: function getNode() {
+                return this.node;
+            }
+        },
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getHypotheses",
+            value: function getHypotheses() {
+                return this.hypotheses;
+            }
+        },
+        {
+            key: "getAxiom",
+            value: function getAxiom() {
+                return this.axiom;
+            }
+        },
+        {
+            key: "getLemma",
+            value: function getLemma() {
+                return this.lemma;
+            }
+        },
+        {
+            key: "getTheorem",
+            value: function getTheorem() {
+                return this.theorem;
+            }
+        },
+        {
+            key: "getConjecture",
+            value: function getConjecture() {
+                return this.conjecture;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify() {
+                var verifies = false;
+                var sectionString = this.string; ///
+                this.context.trace("Verifying the '".concat(sectionString, "' section..."), this.node);
+                var hypothesesVerify = this.verifyHypotheses();
+                if (hypothesesVerify) {
+                    var axiomLemmaTheoremOrConjecture = this.axiom || this.lemma || this.theorem || this.conjecture, axiomLemmaTheoremOrConjectureVerifies = axiomLemmaTheoremOrConjecture.verify(this.context);
+                    if (axiomLemmaTheoremOrConjectureVerifies) {
+                        axiomLemmaTheoremOrConjecture.setHypotheses(this.hypotheses);
+                        verifies = true;
+                    }
+                }
+                if (verifies) {
+                    this.context.debug("...verified the '".concat(sectionString, "' section."), this.node);
+                }
+                return verifies;
+            }
+        },
+        {
+            key: "verifyHypotheses",
+            value: function verifyHypotheses() {
+                var _this = this;
+                var hypothesesVerify = this.hypotheses.every(function(hypothesis) {
+                    var hypothesisVerifies = hypothesis.verify(_this.context);
+                    if (hypothesisVerifies) {
+                        return true;
+                    }
+                });
+                return hypothesesVerify;
+            }
+        }
+    ], [
+        {
+            key: "fromSectionNode",
+            value: function fromSectionNode(sectionNode, context) {
+                var localContext = _local.default.fromContext(context);
+                context = localContext; ///
+                var hypothesisNodes = sectionNode.getHypothesisNodes(), hypotheses = hypothesesFromHypothesisNodes(hypothesisNodes, context), axiom = axiomFroSectionNode(sectionNode, context), lemma = lemmaFroSectionNode(sectionNode, context), theorem = theoremFroSectionNode(sectionNode, context), conjecture = conjectureFroSectionNode(sectionNode, context), node = sectionNode, string = stringFromHypothesesAxiomLemmaTheoremAndConjecture(hypotheses, axiom, lemma, theorem, conjecture, context), section = new Section(context, node, string, hypotheses, axiom, lemma, theorem, conjecture);
+                return section;
+            }
+        }
+    ]);
+    return Section;
+}(), _define_property(_Section, "name", "Section"), _Section));
+function axiomFroSectionNode(sectionNode, context) {
+    var axiom = null;
+    var axiomNode = sectionNode.getAxiomNode();
+    if (axiomNode !== null) {
+        var Axiom = _ontology.default.Axiom;
+        axiom = Axiom.fromAxiomNode(axiomNode, context);
+    }
+    return axiom;
+}
+function lemmaFroSectionNode(sectionNode, context) {
+    var lemma = null;
+    var lemmaNode = sectionNode.getLemmaNode();
+    if (lemmaNode !== null) {
+        var Lemma = _ontology.default.Lemma;
+        lemma = Lemma.fromLemmaNode(lemmaNode, context);
+    }
+    return lemma;
+}
+function theoremFroSectionNode(sectionNode, context) {
+    var theorem = null;
+    var theoremNode = sectionNode.getTheoremNode();
+    if (theoremNode !== null) {
+        var Theorem = _ontology.default.Theorem;
+        theorem = Theorem.fromTheoremNode(theoremNode, context);
+    }
+    return theorem;
+}
+function conjectureFroSectionNode(sectionNode, context) {
+    var conjecture = null;
+    var conjectureNode = sectionNode.getConjectureNode();
+    if (conjectureNode !== null) {
+        var Conjecture = _ontology.default.Conjecture;
+        conjecture = Conjecture.fromConjectureNode(conjectureNode, context);
+    }
+    return conjecture;
+}
+function hypothesesFromHypothesisNodes(hypothesisNodes, context) {
+    var hypotheses = hypothesisNodes.map(function(hypothesisNode) {
+        var Hypothesis = _ontology.default.Hypothesis, hypothesis = Hypothesis.fromHypothesisNode(hypothesisNode, context);
+        return hypothesis;
+    });
+    return hypotheses;
+}
+function hypothesesStringFromHypotheses(hypotheses, context) {
+    var hypothesesString = hypotheses.reduce(function(hypothesesString, hypothesis) {
+        var hypothesisString = hypothesis.getString();
+        hypothesesString = hypothesesString !== null ? "".concat(hypothesesString, ", ").concat(hypothesisString) : hypothesisString; ///
+        return hypothesesString;
+    }, null);
+    return hypothesesString;
+}
+function stringFromHypothesesAxiomLemmaTheoremAndConjecture(hypotheses, axiom, lemma, theorem, conjecture, context) {
+    var axiomLemmaTheoremOrConjecture = axiom || lemma || theorem || conjecture, axiomLemmaTheoremOrConjectureString = axiomLemmaTheoremOrConjecture.getString(), hypothesesString = hypothesesStringFromHypotheses(hypotheses, context), string = axiomLemmaTheoremOrConjectureString !== null ? "[".concat(hypothesesString, "]::: ").concat(axiomLemmaTheoremOrConjectureString) : "[".concat(hypothesesString, "]::: ");
+    return string;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/ontology/section.js"],"sourcesContent":["\"use strict\";\n\nimport ontology from \"../ontology\";\nimport LocalContext from \"../context/local\";\n\nimport { define } from \"../ontology\";\n\nexport default define(class Section {\n  constructor(context, node, string, hypotheses, axiom, lemma, theorem, conjecture) {\n    this.context = context;\n    this.node = node;\n    this.string = string;\n    this.hypotheses = hypotheses;\n    this.axiom = axiom;\n    this.lemma = lemma;\n    this.theorem = theorem;\n    this.conjecture = conjecture;\n  }\n\n  getContext() {\n    return this.context;\n  }\n\n  getNode() {\n    return this.node;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getHypotheses() {\n    return this.hypotheses;\n  }\n\n  getAxiom() {\n    return this.axiom;\n  }\n\n  getLemma() {\n    return this.lemma;\n  }\n\n  getTheorem() {\n    return this.theorem;\n  }\n\n  getConjecture() {\n    return this.conjecture;\n  }\n\n  verify() {\n    let verifies = false;\n\n    const sectionString = this.string;  ///\n\n    this.context.trace(`Verifying the '${sectionString}' section...`, this.node);\n\n    const hypothesesVerify = this.verifyHypotheses();\n\n    if (hypothesesVerify) {\n      const axiomLemmaTheoremOrConjecture = (this.axiom || this.lemma || this.theorem || this.conjecture),\n            axiomLemmaTheoremOrConjectureVerifies = axiomLemmaTheoremOrConjecture.verify(this.context);\n\n      if (axiomLemmaTheoremOrConjectureVerifies) {\n        axiomLemmaTheoremOrConjecture.setHypotheses(this.hypotheses);\n\n        verifies = true;\n      }\n    }\n\n    if (verifies) {\n      this.context.debug(`...verified the '${sectionString}' section.`, this.node);\n    }\n\n    return verifies;\n  }\n\n  verifyHypotheses() {\n    const hypothesesVerify = this.hypotheses.every((hypothesis) => {\n      const hypothesisVerifies = hypothesis.verify(this.context);\n\n      if (hypothesisVerifies) {\n        return true;\n      }\n    });\n\n    return hypothesesVerify;\n  }\n\n  static name = \"Section\";\n\n  static fromSectionNode(sectionNode, context) {\n    const localContext = LocalContext.fromContext(context);\n\n    context = localContext; ///\n\n    const hypothesisNodes = sectionNode.getHypothesisNodes(),\n          hypotheses = hypothesesFromHypothesisNodes(hypothesisNodes, context),\n          axiom = axiomFroSectionNode(sectionNode, context),\n          lemma = lemmaFroSectionNode(sectionNode, context),\n          theorem = theoremFroSectionNode(sectionNode, context),\n          conjecture = conjectureFroSectionNode(sectionNode, context),\n          node = sectionNode, ///\n          string = stringFromHypothesesAxiomLemmaTheoremAndConjecture(hypotheses, axiom, lemma, theorem, conjecture, context),\n          section = new Section(context, node, string, hypotheses, axiom, lemma, theorem, conjecture);\n\n    return section;\n  }\n});\n\nfunction axiomFroSectionNode(sectionNode, context) {\n  let axiom = null;\n\n  const axiomNode = sectionNode.getAxiomNode();\n\n  if (axiomNode !== null) {\n    const { Axiom } = ontology;\n\n    axiom = Axiom.fromAxiomNode(axiomNode, context);\n  }\n\n  return axiom;\n}\n\nfunction lemmaFroSectionNode(sectionNode, context) {\n  let lemma = null;\n\n  const lemmaNode = sectionNode.getLemmaNode();\n\n  if (lemmaNode !== null) {\n    const { Lemma } = ontology;\n\n    lemma = Lemma.fromLemmaNode(lemmaNode, context);\n  }\n\n  return lemma;\n}\n\nfunction theoremFroSectionNode(sectionNode, context) {\n  let theorem = null;\n\n  const theoremNode = sectionNode.getTheoremNode();\n\n  if (theoremNode !== null) {\n    const { Theorem } = ontology;\n\n    theorem = Theorem.fromTheoremNode(theoremNode, context);\n  }\n\n  return theorem;\n}\n\nfunction conjectureFroSectionNode(sectionNode, context) {\n  let conjecture = null;\n\n  const conjectureNode = sectionNode.getConjectureNode();\n\n  if (conjectureNode !== null) {\n    const { Conjecture } = ontology;\n\n    conjecture = Conjecture.fromConjectureNode(conjectureNode, context);\n  }\n\n  return conjecture;\n}\n\nfunction hypothesesFromHypothesisNodes(hypothesisNodes, context) {\n  const hypotheses = hypothesisNodes.map((hypothesisNode) => {\n    const { Hypothesis } = ontology,\n          hypothesis = Hypothesis.fromHypothesisNode(hypothesisNode, context);\n\n    return hypothesis;\n  });\n\n  return hypotheses;\n}\n\nfunction hypothesesStringFromHypotheses(hypotheses, context) {\n  const hypothesesString = hypotheses.reduce((hypothesesString, hypothesis) => {\n    const hypothesisString = hypothesis.getString();\n\n    hypothesesString = (hypothesesString !== null) ?\n                         `${hypothesesString}, ${hypothesisString}` :\n                           hypothesisString;  ///\n\n    return hypothesesString;\n  }, null);\n\n  return hypothesesString;\n}\n\nfunction stringFromHypothesesAxiomLemmaTheoremAndConjecture(hypotheses, axiom, lemma, theorem, conjecture, context) {\n  const axiomLemmaTheoremOrConjecture = (axiom || lemma || theorem || conjecture),\n        axiomLemmaTheoremOrConjectureString = axiomLemmaTheoremOrConjecture.getString(),\n        hypothesesString = hypothesesStringFromHypotheses(hypotheses, context),\n        string = (axiomLemmaTheoremOrConjectureString !== null) ?\n                   `[${hypothesesString}]::: ${axiomLemmaTheoremOrConjectureString}` :\n                     `[${hypothesesString}]::: `;\n\n\n  return string;\n}\n"],"names":["define","Section","context","node","string","hypotheses","axiom","lemma","theorem","conjecture","getContext","getNode","getString","getHypotheses","getAxiom","getLemma","getTheorem","getConjecture","verify","verifies","sectionString","trace","hypothesesVerify","verifyHypotheses","axiomLemmaTheoremOrConjecture","axiomLemmaTheoremOrConjectureVerifies","setHypotheses","debug","every","hypothesis","hypothesisVerifies","fromSectionNode","sectionNode","localContext","LocalContext","fromContext","hypothesisNodes","getHypothesisNodes","hypothesesFromHypothesisNodes","axiomFroSectionNode","lemmaFroSectionNode","theoremFroSectionNode","conjectureFroSectionNode","stringFromHypothesesAxiomLemmaTheoremAndConjecture","section","name","axiomNode","getAxiomNode","Axiom","ontology","fromAxiomNode","lemmaNode","getLemmaNode","Lemma","fromLemmaNode","theoremNode","getTheoremNode","Theorem","fromTheoremNode","conjectureNode","getConjectureNode","Conjecture","fromConjectureNode","map","hypothesisNode","Hypothesis","fromHypothesisNode","hypothesesStringFromHypotheses","hypothesesString","reduce","hypothesisString","axiomLemmaTheoremOrConjectureString"],"mappings":"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"}

package/lib/ontology/signature.js

@@ -0,0 +1,220 @@
+"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 _json = require("../utilities/json");
+var _node = require("../utilities/node");
+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 _Signature;
+var match = _necessary.arrayUtilities.match, compare = _necessary.arrayUtilities.compare, correlate = _necessary.arrayUtilities.correlate;
+var _default = (0, _ontology.define)((_Signature = /*#__PURE__*/ function() {
+    function Signature(string, terms) {
+        _class_call_check(this, Signature);
+        this.string = string;
+        this.terms = terms;
+    }
+    _create_class(Signature, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getTerms",
+            value: function getTerms() {
+                return this.terms;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(context) {
+                var verifies;
+                var signatureString = this.string;
+                context.trace("Verifying the ".concat(signatureString, " signature..."));
+                verifies = this.terms.every(function(term) {
+                    var termVerifies = term.verify(context, function() {
+                        var verifiesAhead = true;
+                        return verifiesAhead;
+                    });
+                    if (termVerifies) {
+                        return true;
+                    }
+                });
+                if (verifies) {
+                    context.debug("...verified the ".concat(signatureString, " signature."));
+                }
+                return verifies;
+            }
+        },
+        {
+            key: "match",
+            value: function match1(signature, substitutions, generalContext, specificContext) {
+                var terms = signature.getTerms(), termsA = this.terms, termsB = terms, matches = match(termsA, termsB, function(termA, termB) {
+                    var termAType = termA.getType(), termBType = termB.getType(), termATypeEqualToOrSubTypeOfTermB = termAType.isEqualToOrSubTypeOf(termBType);
+                    if (termATypeEqualToOrSubTypeOfTermB) {
+                        var context, term;
+                        context = generalContext; ///
+                        term = termB; ///
+                        var variable = (0, _node.variableFromTerm)(term, context);
+                        context = specificContext; ///
+                        term = termA; ///
+                        var TermSubstitution = _ontology.default.TermSubstitution, termSubstitution = TermSubstitution.fromTernAndVariable(term, variable, context), substitution = termSubstitution; ///
+                        substitutions.addSubstitution(substitution, specificContext);
+                        return true;
+                    }
+                });
+                return matches;
+            }
+        },
+        {
+            key: "compareSubstitutions",
+            value: function compareSubstitutions(substitutions, context) {
+                var substitutionsCompares = false;
+                var signatureString = this.string, substitutionsString = substitutions.asString();
+                context.trace("Comparing the '".concat(substitutionsString, "' substitutions against the ").concat(signatureString, " signature..."));
+                var array = substitutions.getArray(), compares = compare(this.terms, array, function(term, substitution) {
+                    var substitutionTerm = substitution.getTerm(), substitutionTermEqualToTerm = substitutionTerm.isEqualTo(term);
+                    if (substitutionTermEqualToTerm) {
+                        return true;
+                    }
+                });
+                if (compares) {
+                    substitutionsCompares = true;
+                }
+                if (substitutionsCompares) {
+                    context.debug("...compared the '".concat(substitutionsString, "' substitutions against the ").concat(signatureString, " signature."));
+                }
+                return substitutionsCompares;
+            }
+        },
+        {
+            key: "correlateSubstitutions",
+            value: function correlateSubstitutions(substitutions, context) {
+                var substitutionsCorrelates = false;
+                var signatureString = this.string, substitutionsString = substitutions.asString();
+                context.trace("Correlating the '".concat(substitutionsString, "' substitutions against the ").concat(signatureString, " signature..."));
+                var array = substitutions.getArray(), correlates = correlate(this.terms, array, function(term, substitution) {
+                    var substitutionTerm = substitution.getTerm(), substitutionTermEqualToTerm = substitutionTerm.isEqualTo(term);
+                    if (substitutionTermEqualToTerm) {
+                        return true;
+                    }
+                });
+                if (correlates) {
+                    substitutionsCorrelates = true;
+                }
+                if (substitutionsCorrelates) {
+                    context.debug("...correlated the '".concat(substitutionsString, "' substitutions against the ").concat(signatureString, " signature."));
+                }
+                return substitutionsCorrelates;
+            }
+        },
+        {
+            key: "toJSON",
+            value: function toJSON() {
+                var termsJSON = (0, _json.termsToTermsJSON)(this.terms), terms = termsJSON, json = {
+                    terms: terms
+                };
+                return json;
+            }
+        }
+    ], [
+        {
+            key: "fromJSON",
+            value: function fromJSON(json, context) {
+                var terms = (0, _json.termsFromJSON)(json, context), string = (0, _node.stringFromTerms)(terms), signature = new Signature(string, terms);
+                return signature;
+            }
+        },
+        {
+            key: "fromSignatureNode",
+            value: function fromSignatureNode(signatureNode, context) {
+                var termNodes = signatureNode.getTermNodes(), terms = (0, _node.termsFromTermNodes)(termNodes, context), string = (0, _node.stringFromTerms)(terms), signature = new Signature(string, terms);
+                return signature;
+            }
+        }
+    ]);
+    return Signature;
+}(), _define_property(_Signature, "name", "Signature"), _Signature));
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/ontology/signature.js"],"sourcesContent":["\"use strict\";\n\nimport { arrayUtilities } from \"necessary\";\n\nimport ontology from \"../ontology\";\n\nimport { define } from \"../ontology\";\nimport { termsFromJSON, termsToTermsJSON } from \"../utilities/json\";\nimport { stringFromTerms, variableFromTerm, termsFromTermNodes } from \"../utilities/node\";\n\nconst { match, compare, correlate } = arrayUtilities;\n\nexport default define(class Signature {\n  constructor(string, terms) {\n    this.string = string;\n    this.terms = terms;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getTerms() {\n    return this.terms;\n  }\n\n  verify(context) {\n    let verifies;\n\n    const signatureString = this.string;\n\n    context.trace(`Verifying the ${signatureString} signature...`);\n\n    verifies = this.terms.every((term) => {\n      const termVerifies = term.verify(context, () => {\n        const verifiesAhead = true;\n\n        return verifiesAhead;\n      });\n\n      if (termVerifies) {\n        return true;\n      }\n    });\n\n    if (verifies) {\n      context.debug(`...verified the ${signatureString} signature.`);\n    }\n\n    return verifies;\n  }\n\n  match(signature, substitutions, generalContext, specificContext) {\n    const terms = signature.getTerms(),\n          termsA = this.terms,  ///\n          termsB = terms, ///\n          matches = match(termsA, termsB, (termA, termB) => {\n            const termAType = termA.getType(),\n                  termBType = termB.getType(),\n                  termATypeEqualToOrSubTypeOfTermB = termAType.isEqualToOrSubTypeOf(termBType);\n\n            if (termATypeEqualToOrSubTypeOfTermB) {\n              let context,\n                  term;\n\n              context = generalContext; ///\n\n              term = termB; ///\n\n              const variable = variableFromTerm(term, context);\n\n              context = specificContext;  ///\n\n              term = termA; ///\n\n              const { TermSubstitution } = ontology,\n                    termSubstitution = TermSubstitution.fromTernAndVariable(term, variable, context),\n                    substitution = termSubstitution;  ///\n\n              substitutions.addSubstitution(substitution, specificContext);\n\n              return true;\n            }\n          });\n\n    return matches;\n  }\n\n  compareSubstitutions(substitutions, context) {\n    let substitutionsCompares = false;\n\n    const signatureString = this.string,\n          substitutionsString = substitutions.asString();\n\n    context.trace(`Comparing the '${substitutionsString}' substitutions against the ${signatureString} signature...`);\n\n    const array = substitutions.getArray(),\n          compares = compare(this.terms, array, (term, substitution) => {\n            const substitutionTerm = substitution.getTerm(),\n                  substitutionTermEqualToTerm = substitutionTerm.isEqualTo(term);\n\n            if (substitutionTermEqualToTerm) {\n              return true;\n            }\n          });\n\n    if (compares) {\n      substitutionsCompares = true;\n    }\n\n    if (substitutionsCompares) {\n      context.debug(`...compared the '${substitutionsString}' substitutions against the ${signatureString} signature.`);\n    }\n\n    return substitutionsCompares;\n  }\n\n  correlateSubstitutions(substitutions, context) {\n    let substitutionsCorrelates = false;\n\n    const signatureString = this.string,\n          substitutionsString = substitutions.asString();\n\n    context.trace(`Correlating the '${substitutionsString}' substitutions against the ${signatureString} signature...`);\n\n    const array = substitutions.getArray(),\n          correlates = correlate(this.terms, array, (term, substitution) => {\n            const substitutionTerm = substitution.getTerm(),\n                  substitutionTermEqualToTerm = substitutionTerm.isEqualTo(term);\n\n            if (substitutionTermEqualToTerm) {\n              return true;\n            }\n          });\n\n    if (correlates) {\n      substitutionsCorrelates = true;\n    }\n\n    if (substitutionsCorrelates) {\n      context.debug(`...correlated the '${substitutionsString}' substitutions against the ${signatureString} signature.`);\n    }\n\n    return substitutionsCorrelates;\n  }\n\n  toJSON() {\n    const termsJSON = termsToTermsJSON(this.terms),\n          terms = termsJSON,  ///\n          json = {\n            terms\n          };\n\n    return json;\n  }\n\n  static name = \"Signature\";\n\n  static fromJSON(json, context) {\n    const terms = termsFromJSON(json, context),\n          string = stringFromTerms(terms),\n          signature = new Signature(string, terms);\n\n    return signature;\n  }\n\n  static fromSignatureNode(signatureNode, context) {\n    const termNodes = signatureNode.getTermNodes(),\n          terms = termsFromTermNodes(termNodes, context),\n          string = stringFromTerms(terms),\n          signature = new Signature(string, terms);\n\n    return signature;\n  }\n});\n"],"names":["match","arrayUtilities","compare","correlate","define","Signature","string","terms","getString","getTerms","verify","context","verifies","signatureString","trace","every","term","termVerifies","verifiesAhead","debug","signature","substitutions","generalContext","specificContext","termsA","termsB","matches","termA","termB","termAType","getType","termBType","termATypeEqualToOrSubTypeOfTermB","isEqualToOrSubTypeOf","variable","variableFromTerm","TermSubstitution","ontology","termSubstitution","fromTernAndVariable","substitution","addSubstitution","compareSubstitutions","substitutionsCompares","substitutionsString","asString","array","getArray","compares","substitutionTerm","getTerm","substitutionTermEqualToTerm","isEqualTo","correlateSubstitutions","substitutionsCorrelates","correlates","toJSON","termsJSON","termsToTermsJSON","json","fromJSON","termsFromJSON","stringFromTerms","fromSignatureNode","signatureNode","termNodes","getTermNodes","termsFromTermNodes","name"],"mappings":"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"}