occam-verify-cli 1.0.396 → 1.0.405

package/lib/ontology/equivalence.js

@@ -0,0 +1,295 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _necessary = require("necessary");
+var _ontology = require("../ontology");
+var _brackets = require("../utilities/brackets");
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+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 _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var compress = _necessary.arrayUtilities.compress;
+var _default = (0, _ontology.define)(/*#__PURE__*/ function() {
+    function Equivalence(terms) {
+        _class_call_check(this, Equivalence);
+        this.terms = terms;
+    }
+    _create_class(Equivalence, [
+        {
+            key: "getTerms",
+            value: function getTerms() {
+                return this.terms;
+            }
+        },
+        {
+            key: "addTerm",
+            value: function addTerm(term, context) {
+                var termString = term.getString(), equivalenceString = this.asString(); ///
+                context.trace("Adding the '".concat(termString, "' term to the '").concat(equivalenceString, "' equivalence...."));
+                var termA = term, termPresent = this.someTerm(function(term) {
+                    var termB = term, termAEqualToTermB = termA.isEqualTo(termB);
+                    if (termAEqualToTermB) {
+                        return true;
+                    }
+                });
+                if (!termPresent) {
+                    this.terms.push(term);
+                    context.debug("...added the '".concat(termString, "' term to the '").concat(equivalenceString, "' equivalence."));
+                }
+            }
+        },
+        {
+            key: "getType",
+            value: function getType() {
+                var type = this.terms.reduce(function(type, term) {
+                    var termType = term.getType();
+                    if (type === null) {
+                        type = termType; ///
+                    } else {
+                        var termTypeSubTypeOfType = termType.isSubTypeOf(type);
+                        if (termTypeSubTypeOfType) {
+                            type = termType; ///
+                        }
+                    }
+                    return type;
+                }, null);
+                return type;
+            }
+        },
+        {
+            key: "equateTerm",
+            value: function equateTerm(term) {
+                var termA = term, termEquates = this.someTerm(function(term) {
+                    var termB = term, termAEqualToTermB = termA.isEqualTo(termB);
+                    if (termAEqualToTermB) {
+                        return true;
+                    }
+                });
+                return termEquates;
+            }
+        },
+        {
+            key: "matchTermNode",
+            value: function matchTermNode(termNode) {
+                termNode = (0, _brackets.stripBracketsFromTermNode)(termNode); ///
+                var termNodeMatches = this.someTerm(function(term) {
+                    var termNodeMatches = term.matchTermNode(termNode);
+                    if (termNodeMatches) {
+                        return true;
+                    }
+                });
+                return termNodeMatches;
+            }
+        },
+        {
+            key: "matchTermNodes",
+            value: function matchTermNodes(termNodes) {
+                var _this = this;
+                var termNodesMatch = termNodes.every(function(termNode) {
+                    var termNodeMatches = _this.matchTermNode(termNode);
+                    if (termNodeMatches) {
+                        return true;
+                    }
+                });
+                return termNodesMatch;
+            }
+        },
+        {
+            key: "matchVariableNode",
+            value: function matchVariableNode(variableNode) {
+                var variableNodeA = variableNode, variableNodeMatches = this.someTerm(function(term) {
+                    var termNode = term.getNode(), singularVariableNode = termNode.getSingularVariableNode();
+                    if (singularVariableNode !== null) {
+                        var variableNodeB = singularVariableNode, variableNodeAMatchesVariableNodeB = variableNodeA.match(variableNodeB);
+                        if (variableNodeAMatchesVariableNodeB) {
+                            return true;
+                        }
+                    }
+                });
+                return variableNodeMatches;
+            }
+        },
+        {
+            key: "isDisjointFrom",
+            value: function isDisjointFrom(equivalence) {
+                var _this = this;
+                var disjointFrom = equivalence.everyTerm(function(term) {
+                    var termEquates = _this.equateTerm(term);
+                    if (!termEquates) {
+                        return true;
+                    }
+                });
+                return disjointFrom;
+            }
+        },
+        {
+            key: "mergedWith",
+            value: function mergedWith(equivalence) {
+                var equivalenceA = this, equivalenceB = equivalence, equivalenceATerms = equivalenceA.getTerms(), equivalenceTermsB = equivalenceB.getTerms(), terms = _to_consumable_array(equivalenceATerms).concat(_to_consumable_array(equivalenceTermsB));
+                compress(terms, function(termA, termB) {
+                    var termAEqualToTermB = termA.isEqualTo(termB);
+                    if (termAEqualToTermB) {
+                        return true;
+                    }
+                });
+                equivalence = new Equivalence(terms);
+                return equivalence;
+            }
+        },
+        {
+            key: "someTerm",
+            value: function someTerm(callback) {
+                return this.terms.some(callback);
+            }
+        },
+        {
+            key: "everyTerm",
+            value: function everyTerm(callback) {
+                return this.terms.every(callback);
+            }
+        },
+        {
+            key: "someOtherTerm",
+            value: function someOtherTerm(term, callback) {
+                var termA = term, terms = this.terms.filter(function(term) {
+                    var termB = term, termAEqualToTermB = termA.isEqualTo(termB);
+                    if (!termAEqualToTermB) {
+                        return true;
+                    }
+                }), result = terms.some(callback);
+                return result;
+            }
+        },
+        {
+            key: "getGroundedTerms",
+            value: function getGroundedTerms(definedVariables, groundedTerms, context) {
+                this.terms.forEach(function(term) {
+                    var termGrounded = term.isGrounded(definedVariables, context);
+                    if (termGrounded) {
+                        var termMatchesGroundedTerm = groundedTerms.some(function(groundedTerm) {
+                            var groundedTermNode = groundedTerm.getNode(), groundedTermNodeMatches = term.matchTermNode(groundedTermNode);
+                            if (groundedTermNodeMatches) {
+                                return true;
+                            }
+                        });
+                        if (!termMatchesGroundedTerm) {
+                            var groundedTerm = term;
+                            groundedTerms.push(groundedTerm);
+                        }
+                    }
+                });
+            }
+        },
+        {
+            key: "isInitiallyGrounded",
+            value: function isInitiallyGrounded(context) {
+                var initiallyGroundedTerms = this.getInitiallyGroundedTerms(context), initiallyGroundedTermsLength = initiallyGroundedTerms.length, initiallyGrounded = initiallyGroundedTermsLength > 0;
+                return initiallyGrounded;
+            }
+        },
+        {
+            key: "isImplicitlyGrounded",
+            value: function isImplicitlyGrounded(definedVariables, context) {
+                var implicitlyGroundedTerms = this.getImplicitlyGroundedTerms(definedVariables, context), implicitlyGroundedTermsLength = implicitlyGroundedTerms.length, implicitlyGrounded = implicitlyGroundedTermsLength > 0;
+                return implicitlyGrounded;
+            }
+        },
+        {
+            key: "getInitiallyGroundedTerms",
+            value: function getInitiallyGroundedTerms(context) {
+                var initiallyGroundedTerms = this.terms.reduce(function(initiallyGroundedTerms, term) {
+                    var termInitiallyGrounded = term.isInitiallyGrounded(context);
+                    if (termInitiallyGrounded) {
+                        var initiallyGroundedTerm = term; ///
+                        initiallyGroundedTerms.push(initiallyGroundedTerm);
+                    }
+                    return initiallyGroundedTerms;
+                }, []);
+                return initiallyGroundedTerms;
+            }
+        },
+        {
+            key: "getImplicitlyGroundedTerms",
+            value: function getImplicitlyGroundedTerms(definedVariables, context) {
+                var implicitlyGroundedTerms = this.terms.reduce(function(implicitlyGroundedTerms, term) {
+                    var termImplicitlyGrounded = term.isImplicitlyGrounded(definedVariables, context);
+                    if (termImplicitlyGrounded) {
+                        var implicitlyGroundedTerm = term; ///
+                        implicitlyGroundedTerms.push(implicitlyGroundedTerm);
+                    }
+                    return implicitlyGroundedTerms;
+                }, []);
+                return implicitlyGroundedTerms;
+            }
+        },
+        {
+            key: "asString",
+            value: function asString() {
+                var type = this.getType(), typeString = type.getString(), termsString = this.terms.reduce(function(termsString, term) {
+                    var termString = term.getString();
+                    termsString = termsString === null ? termString : "".concat(termsString, " = ").concat(termString);
+                    return termsString;
+                }, null), string = "".concat(termsString, ":").concat(typeString);
+                return string;
+            }
+        }
+    ], [
+        {
+            key: "fromEquality",
+            value: function fromEquality(equality) {
+                var terms = equality.getTerms(), equivalence = new Equivalence(terms);
+                return equivalence;
+            }
+        }
+    ]);
+    return Equivalence;
+}());
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/ontology/equivalence.js"],"sourcesContent":["\"use strict\";\n\nimport { arrayUtilities } from \"necessary\";\n\nimport { define } from \"../ontology\";\nimport { stripBracketsFromTermNode } from \"../utilities/brackets\";\n\nconst { compress } = arrayUtilities;\n\nexport default define(class Equivalence {\n  constructor(terms) {\n    this.terms = terms;\n  }\n\n  getTerms() {\n    return this.terms;\n  }\n\n  addTerm(term, context) {\n    const termString = term.getString(),\n          equivalenceString = this.asString(); ///\n\n    context.trace(`Adding the '${termString}' term to the '${equivalenceString}' equivalence....`);\n\n    const termA = term, ///\n          termPresent = this.someTerm((term) => {\n            const termB = term, ///\n                  termAEqualToTermB = termA.isEqualTo(termB);\n\n            if (termAEqualToTermB) {\n              return true;\n            }\n          });\n\n    if (!termPresent) {\n      this.terms.push(term);\n\n      context.debug(`...added the '${termString}' term to the '${equivalenceString}' equivalence.`);\n    }\n  }\n\n  getType() {\n    const type = this.terms.reduce((type, term) => {\n      const termType = term.getType();\n\n      if (type === null) {\n        type = termType;  ///\n      } else {\n        const termTypeSubTypeOfType = termType.isSubTypeOf(type);\n\n        if (termTypeSubTypeOfType) {\n          type = termType;  ///\n        }\n      }\n\n      return type;\n    }, null);\n\n    return type;\n  }\n\n  equateTerm(term) {\n    const termA = term, ///\n          termEquates = this.someTerm((term) => {\n            const termB = term, ///\n                  termAEqualToTermB = termA.isEqualTo(termB);\n\n            if (termAEqualToTermB) {\n              return true;\n            }\n          });\n\n    return termEquates;\n  }\n\n  matchTermNode(termNode) {\n    termNode = stripBracketsFromTermNode(termNode); ///\n\n    const termNodeMatches = this.someTerm((term) => {\n      const termNodeMatches = term.matchTermNode(termNode);\n\n      if (termNodeMatches) {\n        return true;\n      }\n    });\n\n    return termNodeMatches;\n  }\n\n  matchTermNodes(termNodes) {\n    const termNodesMatch = termNodes.every((termNode) => {\n      const termNodeMatches = this.matchTermNode(termNode);\n\n      if (termNodeMatches) {\n        return true;\n      }\n    });\n\n    return termNodesMatch;\n  }\n\n  matchVariableNode(variableNode) {\n    const variableNodeA = variableNode, ///\n          variableNodeMatches = this.someTerm((term) => {\n            const termNode = term.getNode(),\n                  singularVariableNode = termNode.getSingularVariableNode();\n\n            if (singularVariableNode !== null) {\n              const variableNodeB = singularVariableNode, ///\n                    variableNodeAMatchesVariableNodeB = variableNodeA.match(variableNodeB);\n\n              if (variableNodeAMatchesVariableNodeB) {\n                return true;\n              }\n            }\n          });\n\n    return variableNodeMatches;\n  }\n\n  isDisjointFrom(equivalence) {\n    const disjointFrom = equivalence.everyTerm((term) => {\n      const termEquates = this.equateTerm(term);\n\n      if (!termEquates) {\n        return true;\n      }\n    });\n\n    return disjointFrom;\n  }\n\n  mergedWith(equivalence) {\n    const equivalenceA = this,\n          equivalenceB = equivalence, ///\n          equivalenceATerms = equivalenceA.getTerms(),\n          equivalenceTermsB = equivalenceB.getTerms(),\n          terms = [\n            ...equivalenceATerms,\n            ...equivalenceTermsB\n          ];\n\n    compress(terms, (termA, termB) => {\n      const termAEqualToTermB = termA.isEqualTo(termB);\n\n      if (termAEqualToTermB) {\n        return true;\n      }\n    });\n\n    equivalence = new Equivalence(terms);\n\n    return equivalence;\n  }\n\n  someTerm(callback) { return this.terms.some(callback); }\n\n  everyTerm(callback) { return this.terms.every(callback); }\n\n  someOtherTerm(term, callback) {\n    const termA = term, ///\n          terms = this.terms.filter((term) => {\n            const termB = term, ///\n                  termAEqualToTermB = termA.isEqualTo(termB);\n\n            if (!termAEqualToTermB) {\n              return true;\n            }\n          }),\n          result = terms.some(callback);\n\n    return result;\n  }\n\n  getGroundedTerms(definedVariables, groundedTerms, context) {\n    this.terms.forEach((term) => {\n      const termGrounded = term.isGrounded(definedVariables, context);\n\n      if (termGrounded) {\n        const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {\n          const groundedTermNode = groundedTerm.getNode(),\n                groundedTermNodeMatches = term.matchTermNode(groundedTermNode);\n\n          if (groundedTermNodeMatches) {\n            return true;\n          }\n        })\n\n        if (!termMatchesGroundedTerm) {\n          const groundedTerm = term;\n\n          groundedTerms.push(groundedTerm);\n        }\n      }\n    });\n  }\n\n  isInitiallyGrounded(context) {\n    const initiallyGroundedTerms = this.getInitiallyGroundedTerms(context),\n          initiallyGroundedTermsLength = initiallyGroundedTerms.length,\n          initiallyGrounded = (initiallyGroundedTermsLength > 0);\n\n    return initiallyGrounded;\n  }\n\n  isImplicitlyGrounded(definedVariables, context) {\n    const implicitlyGroundedTerms = this.getImplicitlyGroundedTerms(definedVariables, context),\n          implicitlyGroundedTermsLength = implicitlyGroundedTerms.length,\n          implicitlyGrounded = (implicitlyGroundedTermsLength > 0);\n\n    return implicitlyGrounded;\n  }\n\n  getInitiallyGroundedTerms(context) {\n    const initiallyGroundedTerms = this.terms.reduce((initiallyGroundedTerms, term) => {\n      const termInitiallyGrounded = term.isInitiallyGrounded(context);\n\n      if (termInitiallyGrounded) {\n        const initiallyGroundedTerm = term; ///\n\n        initiallyGroundedTerms.push(initiallyGroundedTerm);\n      }\n\n      return initiallyGroundedTerms;\n    }, []);\n\n    return initiallyGroundedTerms;\n  }\n\n  getImplicitlyGroundedTerms(definedVariables, context) {\n    const implicitlyGroundedTerms = this.terms.reduce((implicitlyGroundedTerms, term) => {\n      const termImplicitlyGrounded = term.isImplicitlyGrounded(definedVariables, context);\n\n      if (termImplicitlyGrounded) {\n        const implicitlyGroundedTerm = term; ///\n\n        implicitlyGroundedTerms.push(implicitlyGroundedTerm);\n      }\n\n      return implicitlyGroundedTerms;\n    }, []);\n\n    return implicitlyGroundedTerms;\n  }\n\n  asString() {\n    const type = this.getType(),\n          typeString = type.getString(),\n          termsString = this.terms.reduce((termsString, term) => {\n            const termString = term.getString();\n\n            termsString = (termsString === null) ?\n                            termString :\n                             `${termsString} = ${termString}`;\n\n            return termsString;\n          }, null),\n          string = `${termsString}:${typeString}`;\n\n    return string;\n  }\n\n  static fromEquality(equality) {\n    const terms = equality.getTerms(),\n          equivalence = new Equivalence(terms);\n\n    return equivalence;\n  }\n});\n"],"names":["compress","arrayUtilities","define","Equivalence","terms","getTerms","addTerm","term","context","termString","getString","equivalenceString","asString","trace","termA","termPresent","someTerm","termB","termAEqualToTermB","isEqualTo","push","debug","getType","type","reduce","termType","termTypeSubTypeOfType","isSubTypeOf","equateTerm","termEquates","matchTermNode","termNode","stripBracketsFromTermNode","termNodeMatches","matchTermNodes","termNodes","termNodesMatch","every","matchVariableNode","variableNode","variableNodeA","variableNodeMatches","getNode","singularVariableNode","getSingularVariableNode","variableNodeB","variableNodeAMatchesVariableNodeB","match","isDisjointFrom","equivalence","disjointFrom","everyTerm","mergedWith","equivalenceA","equivalenceB","equivalenceATerms","equivalenceTermsB","callback","some","someOtherTerm","filter","result","getGroundedTerms","definedVariables","groundedTerms","forEach","termGrounded","isGrounded","termMatchesGroundedTerm","groundedTerm","groundedTermNode","groundedTermNodeMatches","isInitiallyGrounded","initiallyGroundedTerms","getInitiallyGroundedTerms","initiallyGroundedTermsLength","length","initiallyGrounded","isImplicitlyGrounded","implicitlyGroundedTerms","getImplicitlyGroundedTerms","implicitlyGroundedTermsLength","implicitlyGrounded","termInitiallyGrounded","initiallyGroundedTerm","termImplicitlyGrounded","implicitlyGroundedTerm","typeString","termsString","string","fromEquality","equality"],"mappings":"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"}

package/lib/ontology/equivalences.js

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _necessary = require("necessary");
+var _ontology = require("../ontology");
+var _term = require("./term");
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+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 _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var push = _necessary.arrayUtilities.push, separate = _necessary.arrayUtilities.separate;
+var _default = (0, _ontology.define)(/*#__PURE__*/ function() {
+    function Equivalences(array) {
+        _class_call_check(this, Equivalences);
+        this.array = array;
+    }
+    _create_class(Equivalences, [
+        {
+            key: "getArray",
+            value: function getArray() {
+                return this.array;
+            }
+        },
+        {
+            key: "getLength",
+            value: function getLength() {
+                return this.array.length;
+            }
+        },
+        {
+            key: "getTypes",
+            value: function getTypes() {
+                var types = this.array.map(function(equivalence) {
+                    var type = equivalence.getType();
+                    return type;
+                });
+                return types;
+            }
+        },
+        {
+            key: "addEquivalence",
+            value: function addEquivalence(equivalence) {
+                this.array.push(equivalence);
+            }
+        },
+        {
+            key: "addEquivalences",
+            value: function addEquivalences(equivalences) {
+                var array = equivalences.getArray();
+                push(this.array, array);
+            }
+        },
+        {
+            key: "someEquivalence",
+            value: function someEquivalence(callback) {
+                return this.array.some(callback);
+            }
+        },
+        {
+            key: "everyEquivalence",
+            value: function everyEquivalence(callback) {
+                return this.array.every(callback);
+            }
+        },
+        {
+            key: "forEachEquivalence",
+            value: function forEachEquivalence(callback) {
+                this.array.forEach(callback);
+            }
+        },
+        {
+            key: "findEquivalenceByTerm",
+            value: function findEquivalenceByTerm(term) {
+                var equivalence = this.array.find(function(equivalence) {
+                    var termEquates = equivalence.equateTerm(term);
+                    if (termEquates) {
+                        return true;
+                    }
+                }) || null;
+                return equivalence;
+            }
+        },
+        {
+            key: "findEquivalenceByTermNodes",
+            value: function findEquivalenceByTermNodes(termNodes) {
+                var equivalence = this.array.find(function(equivalence) {
+                    var equivalenceMatchesTerms = equivalence.matchTermNodes(termNodes);
+                    if (equivalenceMatchesTerms) {
+                        return true;
+                    }
+                }) || null;
+                return equivalence;
+            }
+        },
+        {
+            key: "mergedWith",
+            value: function mergedWith(equivalences) {
+                var mergedEquivalences = this.clone(); ///
+                equivalences.forEachEquivalence(function(equivalence) {
+                    mergedEquivalences = mergedEquivalences.mergedWithEquivalence(equivalence);
+                });
+                return mergedEquivalences;
+            }
+        },
+        {
+            key: "mergedWithEquivalence",
+            value: function mergedWithEquivalence(equivalence) {
+                var equivalences = Equivalences.fromNothing();
+                var mergedEquivalence = equivalence; ///
+                this.forEachEquivalence(function(equivalence) {
+                    var mergedEquivalenceDisjointFromEquivalence = mergedEquivalence.isDisjointFrom(equivalence);
+                    if (mergedEquivalenceDisjointFromEquivalence) {
+                        equivalences.addEquivalence(equivalence);
+                    } else {
+                        mergedEquivalence = mergedEquivalence.mergedWith(equivalence);
+                    }
+                });
+                equivalence = mergedEquivalence; ///
+                equivalences.addEquivalence(equivalence);
+                return equivalences;
+            }
+        },
+        {
+            key: "separateEquivalences",
+            value: function separateEquivalences(equivalencesA, equivalencesB, callback) {
+                var equivalencesAArray = equivalencesA.getArray(), equivalencesBArray = equivalencesB.getArray();
+                separate(this.array, equivalencesAArray, equivalencesBArray, callback);
+            }
+        },
+        {
+            key: "separateInitiallyGroundedEquivalences",
+            value: function separateInitiallyGroundedEquivalences(remainingEquivalences, initiallyGroundedEquivalences, context) {
+                this.separateEquivalences(remainingEquivalences, initiallyGroundedEquivalences, function(equivalence) {
+                    var equivalenceInitiallyGrounded = equivalence.isInitiallyGrounded(context);
+                    if (!equivalenceInitiallyGrounded) {
+                        return true;
+                    }
+                });
+            }
+        },
+        {
+            key: "separateImplicitlyGroundedEquivalences",
+            value: function separateImplicitlyGroundedEquivalences(remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, context) {
+                this.separateEquivalences(remainingEquivalences, implicitlyGroundedEquivalences, function(equivalence) {
+                    var equivalenceImplicitlyGrounded = equivalence.isImplicitlyGrounded(definedVariables, context);
+                    if (!equivalenceImplicitlyGrounded) {
+                        return true;
+                    }
+                });
+            }
+        },
+        {
+            key: "separateGroundedTermsAndDefinedVariables",
+            value: function separateGroundedTermsAndDefinedVariables(groundedTerms, definedVariables, context) {
+                var equivalences = this, groundedEquivalences, remainingEquivalences, initiallyGroundedEquivalences, implicitlyGroundedEquivalences;
+                remainingEquivalences = Equivalences.fromNothing();
+                initiallyGroundedEquivalences = Equivalences.fromNothing();
+                equivalences.separateInitiallyGroundedEquivalences(remainingEquivalences, initiallyGroundedEquivalences, context);
+                var initiallyGroundedEquivalencesLength = initiallyGroundedEquivalences.getLength();
+                if (initiallyGroundedEquivalencesLength > 0) {
+                    groundedEquivalences = initiallyGroundedEquivalences; ///
+                    var implicitlyGroundedEquivalencesLength = 1;
+                    while(implicitlyGroundedEquivalencesLength > 0){
+                        var definedVariablesLength = 0, previousDefinedVariablesLength = -1;
+                        while(definedVariablesLength > previousDefinedVariablesLength){
+                            previousDefinedVariablesLength = definedVariablesLength; ///
+                            groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, context);
+                            definedVariablesFromGroundedTerms(groundedTerms, definedVariables, context);
+                            definedVariablesLength = definedVariables.length;
+                        }
+                        equivalences = remainingEquivalences; ///
+                        remainingEquivalences = [];
+                        implicitlyGroundedEquivalences = [];
+                        equivalences.separateImplicitlyGroundedEquivalences(remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, context);
+                        groundedEquivalences.addEquivalences(implicitlyGroundedEquivalences);
+                        implicitlyGroundedEquivalencesLength = implicitlyGroundedEquivalences.getLength(); ///
+                    }
+                }
+            }
+        },
+        {
+            key: "clone",
+            value: function clone() {
+                var array = _to_consumable_array(this.array), equivalences = new Equivalences(array);
+                return equivalences;
+            }
+        }
+    ], [
+        {
+            key: "fromNothing",
+            value: function fromNothing() {
+                var array = [], equivalences = new Equivalences(array);
+                return equivalences;
+            }
+        }
+    ]);
+    return Equivalences;
+}());
+function definedVariablesFromGroundedTerms(groundedTerms, definedVariables, context) {
+    groundedTerms.forEach(function(groundedTerm) {
+        var term = groundedTerm, variables = (0, _term.variablesFromTerm)(term, context);
+        variables.forEach(function(variable) {
+            var definedVariablesIncludesTermVariable = definedVariables.includes(variable);
+            if (!definedVariablesIncludesTermVariable) {
+                var definedVariable = variable; ///
+                definedVariables.push(definedVariable);
+            }
+        });
+    });
+}
+function groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, context) {
+    groundedEquivalences.forEachEquivalence(function(groundedEquivalence) {
+        groundedEquivalence.getGroundedTerms(definedVariables, groundedTerms, context);
+    });
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/ontology/equivalences.js"],"sourcesContent":["\"use strict\";\n\nimport { arrayUtilities } from \"necessary\";\n\nimport { define } from \"../ontology\";\nimport { variablesFromTerm } from \"./term\";\n\nconst { push, separate } = arrayUtilities;\n\nexport default define(class Equivalences {\n  constructor(array) {\n    this.array = array;\n  }\n\n  getArray() {\n    return this.array;\n  }\n\n  getLength() { return this.array.length; }\n\n  getTypes() {\n    const types = this.array.map((equivalence) => {\n      const type = equivalence.getType();\n\n      return type;\n    });\n\n    return types;\n  }\n\n  addEquivalence(equivalence) {\n    this.array.push(equivalence);\n  }\n\n  addEquivalences(equivalences) {\n    const array = equivalences.getArray();\n\n    push(this.array, array);\n  }\n\n  someEquivalence(callback) { return this.array.some(callback); }\n\n  everyEquivalence(callback) { return this.array.every(callback); }\n\n  forEachEquivalence(callback) { this.array.forEach(callback); }\n\n  findEquivalenceByTerm(term) {\n    const equivalence = this.array.find((equivalence) => {\n      const termEquates = equivalence.equateTerm(term);\n\n      if (termEquates) {\n        return true;\n      }\n    }) || null;\n\n    return equivalence;\n  }\n\n  findEquivalenceByTermNodes(termNodes) {\n    const equivalence = this.array.find((equivalence) => {\n      const equivalenceMatchesTerms = equivalence.matchTermNodes(termNodes);\n\n      if (equivalenceMatchesTerms) {\n        return true;\n      }\n    }) || null;\n\n    return equivalence;\n  }\n\n  mergedWith(equivalences) {\n    let  mergedEquivalences = this.clone(); ///\n\n    equivalences.forEachEquivalence((equivalence) => {\n      mergedEquivalences = mergedEquivalences.mergedWithEquivalence(equivalence);\n    });\n\n    return mergedEquivalences;\n  }\n\n  mergedWithEquivalence(equivalence) {\n    const equivalences = Equivalences.fromNothing();\n\n    let mergedEquivalence = equivalence; ///\n\n    this.forEachEquivalence((equivalence) => {\n      const mergedEquivalenceDisjointFromEquivalence = mergedEquivalence.isDisjointFrom(equivalence);\n\n      if (mergedEquivalenceDisjointFromEquivalence) {\n        equivalences.addEquivalence(equivalence);\n      } else {\n        mergedEquivalence = mergedEquivalence.mergedWith(equivalence);\n      }\n    });\n\n    equivalence = mergedEquivalence;  ///\n\n    equivalences.addEquivalence(equivalence);\n\n    return equivalences;\n  }\n\n  separateEquivalences(equivalencesA, equivalencesB, callback) {\n    const equivalencesAArray = equivalencesA.getArray(),\n          equivalencesBArray = equivalencesB.getArray();\n\n    separate(this.array, equivalencesAArray, equivalencesBArray, callback);\n  }\n\n  separateInitiallyGroundedEquivalences(remainingEquivalences, initiallyGroundedEquivalences, context) {\n    this.separateEquivalences(remainingEquivalences, initiallyGroundedEquivalences, (equivalence) => {\n      const equivalenceInitiallyGrounded = equivalence.isInitiallyGrounded(context);\n\n      if (!equivalenceInitiallyGrounded) {\n        return true;\n      }\n    });\n  }\n\n  separateImplicitlyGroundedEquivalences(remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, context) {\n    this.separateEquivalences(remainingEquivalences, implicitlyGroundedEquivalences, (equivalence) => {\n      const equivalenceImplicitlyGrounded = equivalence.isImplicitlyGrounded(definedVariables, context);\n\n      if (!equivalenceImplicitlyGrounded) {\n        return true;\n      }\n    });\n  }\n\n  separateGroundedTermsAndDefinedVariables(groundedTerms, definedVariables, context) {\n    let equivalences = this,\n        groundedEquivalences,\n        remainingEquivalences,\n        initiallyGroundedEquivalences,\n        implicitlyGroundedEquivalences;\n\n    remainingEquivalences =Equivalences.fromNothing();\n\n    initiallyGroundedEquivalences = Equivalences.fromNothing();\n\n    equivalences.separateInitiallyGroundedEquivalences(remainingEquivalences, initiallyGroundedEquivalences, context);\n\n    const initiallyGroundedEquivalencesLength = initiallyGroundedEquivalences.getLength();\n\n    if (initiallyGroundedEquivalencesLength > 0) {\n      groundedEquivalences = initiallyGroundedEquivalences; ///\n\n      let implicitlyGroundedEquivalencesLength = 1;\n\n      while (implicitlyGroundedEquivalencesLength > 0) {\n        let definedVariablesLength = 0,\n            previousDefinedVariablesLength = -1;\n\n        while (definedVariablesLength > previousDefinedVariablesLength) {\n          previousDefinedVariablesLength = definedVariablesLength;  ///\n\n          groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, context);\n\n          definedVariablesFromGroundedTerms(groundedTerms, definedVariables, context);\n\n          definedVariablesLength = definedVariables.length;\n        }\n\n        equivalences = remainingEquivalences; ///\n\n        remainingEquivalences = [];\n\n        implicitlyGroundedEquivalences = [];\n\n        equivalences.separateImplicitlyGroundedEquivalences(remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, context);\n\n        groundedEquivalences.addEquivalences(implicitlyGroundedEquivalences);\n\n        implicitlyGroundedEquivalencesLength = implicitlyGroundedEquivalences.getLength();  ///\n      }\n    }\n  }\n\n  clone() {\n    const array = [\n            ...this.array\n          ],\n          equivalences = new Equivalences(array);\n\n    return equivalences;\n  }\n\n  static fromNothing() {\n    const array = [],\n          equivalences = new Equivalences(array);\n\n    return equivalences;\n  }\n});\n\n\nfunction definedVariablesFromGroundedTerms(groundedTerms, definedVariables, context) {\n  groundedTerms.forEach((groundedTerm) => {\n    const term = groundedTerm,  ///\n          variables = variablesFromTerm(term, context);\n\n    variables.forEach((variable) => {\n      const definedVariablesIncludesTermVariable = definedVariables.includes(variable);\n\n      if (!definedVariablesIncludesTermVariable) {\n        const definedVariable = variable;  ///\n\n        definedVariables.push(definedVariable);\n      }\n    });\n  });\n}\n\nfunction groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, context) {\n  groundedEquivalences.forEachEquivalence((groundedEquivalence) => {\n    groundedEquivalence.getGroundedTerms(definedVariables, groundedTerms, context);\n  });\n}\n"],"names":["push","arrayUtilities","separate","define","Equivalences","array","getArray","getLength","length","getTypes","types","map","equivalence","type","getType","addEquivalence","addEquivalences","equivalences","someEquivalence","callback","some","everyEquivalence","every","forEachEquivalence","forEach","findEquivalenceByTerm","term","find","termEquates","equateTerm","findEquivalenceByTermNodes","termNodes","equivalenceMatchesTerms","matchTermNodes","mergedWith","mergedEquivalences","clone","mergedWithEquivalence","fromNothing","mergedEquivalence","mergedEquivalenceDisjointFromEquivalence","isDisjointFrom","separateEquivalences","equivalencesA","equivalencesB","equivalencesAArray","equivalencesBArray","separateInitiallyGroundedEquivalences","remainingEquivalences","initiallyGroundedEquivalences","context","equivalenceInitiallyGrounded","isInitiallyGrounded","separateImplicitlyGroundedEquivalences","implicitlyGroundedEquivalences","definedVariables","equivalenceImplicitlyGrounded","isImplicitlyGrounded","separateGroundedTermsAndDefinedVariables","groundedTerms","groundedEquivalences","initiallyGroundedEquivalencesLength","implicitlyGroundedEquivalencesLength","definedVariablesLength","previousDefinedVariablesLength","groundedTermsFromGroundedEquivalencesAndDefinedVariables","definedVariablesFromGroundedTerms","groundedTerm","variables","variablesFromTerm","variable","definedVariablesIncludesTermVariable","includes","definedVariable","groundedEquivalence","getGroundedTerms"],"mappings":"AAAA;;;;+BASA;;;eAAA;;;yBAP+B;wBAER;oBACW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAElC,IAAQA,OAAmBC,yBAAc,CAAjCD,MAAME,WAAaD,yBAAc,CAA3BC;IAEd,WAAeC,IAAAA,gBAAM,gBAAC;aAAMC,aACdC,KAAK;gCADSD;QAExB,IAAI,CAACC,KAAK,GAAGA;;;;YAGfC,KAAAA;mBAAAA,SAAAA;gBACE,OAAO,IAAI,CAACD,KAAK;YACnB;;;YAEAE,KAAAA;mBAAAA,SAAAA;gBAAc,OAAO,IAAI,CAACF,KAAK,CAACG,MAAM;YAAE;;;YAExCC,KAAAA;mBAAAA,SAAAA;gBACE,IAAMC,QAAQ,IAAI,CAACL,KAAK,CAACM,GAAG,CAAC,SAACC;oBAC5B,IAAMC,OAAOD,YAAYE,OAAO;oBAEhC,OAAOD;gBACT;gBAEA,OAAOH;YACT;;;YAEAK,KAAAA;mBAAAA,SAAAA,eAAeH,WAAW;gBACxB,IAAI,CAACP,KAAK,CAACL,IAAI,CAACY;YAClB;;;YAEAI,KAAAA;mBAAAA,SAAAA,gBAAgBC,YAAY;gBAC1B,IAAMZ,QAAQY,aAAaX,QAAQ;gBAEnCN,KAAK,IAAI,CAACK,KAAK,EAAEA;YACnB;;;YAEAa,KAAAA;mBAAAA,SAAAA,gBAAgBC,QAAQ;gBAAI,OAAO,IAAI,CAACd,KAAK,CAACe,IAAI,CAACD;YAAW;;;YAE9DE,KAAAA;mBAAAA,SAAAA,iBAAiBF,QAAQ;gBAAI,OAAO,IAAI,CAACd,KAAK,CAACiB,KAAK,CAACH;YAAW;;;YAEhEI,KAAAA;mBAAAA,SAAAA,mBAAmBJ,QAAQ;gBAAI,IAAI,CAACd,KAAK,CAACmB,OAAO,CAACL;YAAW;;;YAE7DM,KAAAA;mBAAAA,SAAAA,sBAAsBC,IAAI;gBACxB,IAAMd,cAAc,IAAI,CAACP,KAAK,CAACsB,IAAI,CAAC,SAACf;oBACnC,IAAMgB,cAAchB,YAAYiB,UAAU,CAACH;oBAE3C,IAAIE,aAAa;wBACf,OAAO;oBACT;gBACF,MAAM;gBAEN,OAAOhB;YACT;;;YAEAkB,KAAAA;mBAAAA,SAAAA,2BAA2BC,SAAS;gBAClC,IAAMnB,cAAc,IAAI,CAACP,KAAK,CAACsB,IAAI,CAAC,SAACf;oBACnC,IAAMoB,0BAA0BpB,YAAYqB,cAAc,CAACF;oBAE3D,IAAIC,yBAAyB;wBAC3B,OAAO;oBACT;gBACF,MAAM;gBAEN,OAAOpB;YACT;;;YAEAsB,KAAAA;mBAAAA,SAAAA,WAAWjB,YAAY;gBACrB,IAAKkB,qBAAqB,IAAI,CAACC,KAAK,IAAI,GAAG;gBAE3CnB,aAAaM,kBAAkB,CAAC,SAACX;oBAC/BuB,qBAAqBA,mBAAmBE,qBAAqB,CAACzB;gBAChE;gBAEA,OAAOuB;YACT;;;YAEAE,KAAAA;mBAAAA,SAAAA,sBAAsBzB,WAAW;gBAC/B,IAAMK,eAAeb,aAAakC,WAAW;gBAE7C,IAAIC,oBAAoB3B,aAAa,GAAG;gBAExC,IAAI,CAACW,kBAAkB,CAAC,SAACX;oBACvB,IAAM4B,2CAA2CD,kBAAkBE,cAAc,CAAC7B;oBAElF,IAAI4B,0CAA0C;wBAC5CvB,aAAaF,cAAc,CAACH;oBAC9B,OAAO;wBACL2B,oBAAoBA,kBAAkBL,UAAU,CAACtB;oBACnD;gBACF;gBAEAA,cAAc2B,mBAAoB,GAAG;gBAErCtB,aAAaF,cAAc,CAACH;gBAE5B,OAAOK;YACT;;;YAEAyB,KAAAA;mBAAAA,SAAAA,qBAAqBC,aAAa,EAAEC,aAAa,EAAEzB,QAAQ;gBACzD,IAAM0B,qBAAqBF,cAAcrC,QAAQ,IAC3CwC,qBAAqBF,cAActC,QAAQ;gBAEjDJ,SAAS,IAAI,CAACG,KAAK,EAAEwC,oBAAoBC,oBAAoB3B;YAC/D;;;YAEA4B,KAAAA;mBAAAA,SAAAA,sCAAsCC,qBAAqB,EAAEC,6BAA6B,EAAEC,OAAO;gBACjG,IAAI,CAACR,oBAAoB,CAACM,uBAAuBC,+BAA+B,SAACrC;oBAC/E,IAAMuC,+BAA+BvC,YAAYwC,mBAAmB,CAACF;oBAErE,IAAI,CAACC,8BAA8B;wBACjC,OAAO;oBACT;gBACF;YACF;;;YAEAE,KAAAA;mBAAAA,SAAAA,uCAAuCL,qBAAqB,EAAEM,8BAA8B,EAAEC,gBAAgB,EAAEL,OAAO;gBACrH,IAAI,CAACR,oBAAoB,CAACM,uBAAuBM,gCAAgC,SAAC1C;oBAChF,IAAM4C,gCAAgC5C,YAAY6C,oBAAoB,CAACF,kBAAkBL;oBAEzF,IAAI,CAACM,+BAA+B;wBAClC,OAAO;oBACT;gBACF;YACF;;;YAEAE,KAAAA;mBAAAA,SAAAA,yCAAyCC,aAAa,EAAEJ,gBAAgB,EAAEL,OAAO;gBAC/E,IAAIjC,eAAe,IAAI,EACnB2C,sBACAZ,uBACAC,+BACAK;gBAEJN,wBAAuB5C,aAAakC,WAAW;gBAE/CW,gCAAgC7C,aAAakC,WAAW;gBAExDrB,aAAa8B,qCAAqC,CAACC,uBAAuBC,+BAA+BC;gBAEzG,IAAMW,sCAAsCZ,8BAA8B1C,SAAS;gBAEnF,IAAIsD,sCAAsC,GAAG;oBAC3CD,uBAAuBX,+BAA+B,GAAG;oBAEzD,IAAIa,uCAAuC;oBAE3C,MAAOA,uCAAuC,EAAG;wBAC/C,IAAIC,yBAAyB,GACzBC,iCAAiC,CAAC;wBAEtC,MAAOD,yBAAyBC,+BAAgC;4BAC9DA,iCAAiCD,wBAAyB,GAAG;4BAE7DE,yDAAyDL,sBAAsBL,kBAAkBI,eAAeT;4BAEhHgB,kCAAkCP,eAAeJ,kBAAkBL;4BAEnEa,yBAAyBR,iBAAiB/C,MAAM;wBAClD;wBAEAS,eAAe+B,uBAAuB,GAAG;wBAEzCA,wBAAwB,EAAE;wBAE1BM,iCAAiC,EAAE;wBAEnCrC,aAAaoC,sCAAsC,CAACL,uBAAuBM,gCAAgCC,kBAAkBL;wBAE7HU,qBAAqB5C,eAAe,CAACsC;wBAErCQ,uCAAuCR,+BAA+B/C,SAAS,IAAK,GAAG;oBACzF;gBACF;YACF;;;YAEA6B,KAAAA;mBAAAA,SAAAA;gBACE,IAAM/B,QACE,qBAAG,IAAI,CAACA,KAAK,GAEfY,eAAe,IAAIb,aAAaC;gBAEtC,OAAOY;YACT;;;;YAEOqB,KAAAA;mBAAP,SAAOA;gBACL,IAAMjC,QAAQ,EAAE,EACVY,eAAe,IAAIb,aAAaC;gBAEtC,OAAOY;YACT;;;;;AAIF,SAASiD,kCAAkCP,aAAa,EAAEJ,gBAAgB,EAAEL,OAAO;IACjFS,cAAcnC,OAAO,CAAC,SAAC2C;QACrB,IAAMzC,OAAOyC,cACPC,YAAYC,IAAAA,uBAAiB,EAAC3C,MAAMwB;QAE1CkB,UAAU5C,OAAO,CAAC,SAAC8C;YACjB,IAAMC,uCAAuChB,iBAAiBiB,QAAQ,CAACF;YAEvE,IAAI,CAACC,sCAAsC;gBACzC,IAAME,kBAAkBH,UAAW,GAAG;gBAEtCf,iBAAiBvD,IAAI,CAACyE;YACxB;QACF;IACF;AACF;AAEA,SAASR,yDAAyDL,oBAAoB,EAAEL,gBAAgB,EAAEI,aAAa,EAAET,OAAO;IAC9HU,qBAAqBrC,kBAAkB,CAAC,SAACmD;QACvCA,oBAAoBC,gBAAgB,CAACpB,kBAAkBI,eAAeT;IACxE;AACF"}